浏览代码

冰排累计释冷时间添加释冷结束状态
保温箱累计预冷时间添加预冷结束状态
冰排解绑

huangyan 2 月之前
父节点
当前提交
ddace311d9

+ 35 - 1
app/admin/controller/ice_raft.go

@@ -491,7 +491,7 @@ func (e IceRaftController) IsOutStorage(c *gin.Context) {
 // @Security Bearer
 func (e IceRaftController) BindCoolerBox(c *gin.Context) {
 	s := service.IceRaft{}
-	req := dto.IceRaftOutStorageReq{}
+	req := dto.BindCoolerBox{}
 	err := e.MakeContext(c).
 		MakeOrm().
 		Bind(&req, binding.JSON, nil).
@@ -512,6 +512,40 @@ func (e IceRaftController) BindCoolerBox(c *gin.Context) {
 	e.OK(nil, "绑定成功")
 }
 
+// UnBindCoolerBox 冰排解邦
+// @Summary 冰排解邦
+// @Description 冰排解邦
+// @Tags 冰排
+// @Accept  application/json
+// @Product application/json
+// @Param data body dto.IceRaftOutStorageReq true "body"
+// @Success 200 {string} string	"{"code": 200, "message": "绑定成功"}"
+// @Success 200 {string} string	"{"code": -1, "message": "绑定失败"}"
+// @Router /api/UnbindCoolerBox [post]
+// @Security Bearer
+func (e IceRaftController) UnBindCoolerBox(c *gin.Context) {
+	s := service.IceRaft{}
+	req := dto.UnBindCoolerBox{}
+	err := e.MakeContext(c).
+		MakeOrm().
+		Bind(&req, binding.JSON, nil).
+		MakeService(&s.Service).
+		Errors
+	if err != nil {
+		e.Logger.Error(err)
+		e.Error(500, err, err.Error())
+		return
+	}
+	//数据权限检查
+	p := actions.GetPermissionFromContext(c)
+	err = s.UnBindCookerBox(&req, p)
+	if err != nil {
+		e.Error(500, err, err.Error())
+		return
+	}
+	e.OK(nil, "修改成功")
+}
+
 type IceRaftRecordController struct {
 	api.Api
 }

+ 17 - 15
app/admin/model/cooler_box.go

@@ -10,24 +10,26 @@ const (
 	CoolerBoxStatusDisable = "1"
 )
 
-// 保温箱
+// CoolerBox 保温箱
 type CoolerBox struct {
 	model2.Model
-	Name              string                  `json:"name" gorm:"size:128"`                                 // 商品名称
-	Sn                string                  `json:"sn" gorm:"size:128"`                                   // sn
-	Status            string                  `json:"status" gorm:"size:4;not null;default:'2';comment:状态"` // 1-停用 2-正常
-	HistorySn         model2.StringList       `json:"historySn"`                                            // 历史绑定的sn
-	ColdSpots         string                  `json:"cold_spots"`                                           //遇冷地点
-	ColdTemperatures  string                  `json:"cold_temperatures"`                                    //遇冷温度
-	ForColdCoolerTime int                     `json:"for_cold_cooler_time" gorm:"comment:预冷要求"`             //保温箱预冷要求
+	Name              string                  `json:"name" gorm:"size:128"`                                        // 商品名称
+	Sn                string                  `json:"sn" gorm:"size:128"`                                          // sn
+	Status            string                  `json:"status" gorm:"size:4;not null;default:'2';comment:状态"`        // 1-停用 2-正常
+	HistorySn         model2.StringList       `json:"historySn"`                                                   // 历史绑定的sn
+	ColdSpots         string                  `json:"cold_spots"`                                                  //遇冷地点
+	ColdTemperatures  string                  `json:"cold_temperatures"`                                           //遇冷温度
+	ForColdCoolerTime float32                 `json:"for_cold_cooler_time" gorm:"type:decimal(10,2);comment:预冷要求"` //保温箱预冷要求
 	DeviceData        natsModel.DeviceData_R2 `json:"deviceData" gorm:"-"`
-	MonitorStatus     int                     `json:"monitorStatus" gorm:"comment:监控状态"` // 监控状态 0-未监控 1-监控中
-	BindIceRaftId     model2.StringList       `json:"bindIceRaftId" gorm:"comment:绑定冰排"` // 绑定的冰排id
-	UseStatus         string                  `json:"useStatus" gorm:"-"`
+	MonitorStatus     int                     `json:"monitorStatus" gorm:"comment:监控状态"`           // 监控状态 0-未监控 1-监控中
+	ForColdStatus     int                     `json:"forColdStatus" gorm:"default:0;comment:预冷状态"` // 0-未预冷 1-预冷中 2-使用中
+	BindIceRaftId     model2.StringList       `json:"bindIceRaftId" gorm:"comment:绑定冰排"`           // 绑定的冰排id
+	UseStatus         int                     `json:"useStatus" gorm:"default:0;comment:预冷状态"`     // 0-未预冷 1-预冷中 2-使用中 3遇冷结束
 	model2.ControlBy
 	model2.ModelTime
 	model2.DeptBy
-	IceRaft []IceRaft `json:"ice_raft" gorm:"-"`
+	IceRaft          []IceRaft       `json:"ice_raft" gorm:"-"`
+	CoolerBoxRecords CoolerBoxRecord `json:"cooler_box_record" gorm:"-"`
 }
 
 // CoolerBoxRecord 保温箱历史记录
@@ -41,12 +43,12 @@ type CoolerBoxRecord struct {
 	CoolerBoxStarTime model2.Time       `json:"coolerBoxStarTime"  gorm:"size:128;comment:保温箱开始预冷时间"` //保温箱开始预冷时间
 	CoolerUserTime    model2.Time       `json:"coolerBoxUserTime"  gorm:"size:128;comment:保温箱开始使用时间"` //保温箱使用时间
 	CoolerColdAddress string            `json:"cooler-cold-address" gorm:"size:128;comment:保温箱预冷地点"`  //保温箱预冷地点
-	ColdTemperatures  string            `json:"cold_temperatures"`                                    //遇冷温度
+	ColdTemperatures  string            `json:"cold_temperatures" gorm:"size:128;comment:保温箱预冷温度"`    //遇冷温度
 	CoolerColdUsers   string            `json:"cooler-cold-users" gorm:"size:128;comment:保温箱预冷操作人员"`  //保温箱预冷操作人员
 	CoolerUseUsers    string            `json:"cooler-use-users" gorm:"size:128;comment:保温箱使用操作人员"`   //保温箱使用操作人员
 	CoolerEndUseTime  model2.Time       `json:"coolerEndUseTime"  gorm:"size:128;comment:保温箱结束使用时间"`
-	ForColdCoolerTime int               `json:"for_cold_cooler_time" gorm:"comment:预冷要求"`
-	ForColdDuration   string            `json:"for_cold_duration" gorm:"-"` // 预冷时长
+	ForColdCoolerTime float32           `json:"for_cold_cooler_time" gorm:"type:decimal(10,2);comment:预冷要求"`
+	ForColdDuration   string            `json:"for_cold_duration" gorm:"comment:预冷累计时长"` // 预冷累计时长
 	model2.ControlBy
 	model2.ModelTime
 	model2.DeptBy

+ 58 - 52
app/admin/model/ice_raft.go

@@ -15,13 +15,13 @@ type IceRaft struct {
 	IceRaftRecordId int               `json:"iceRaftRecordId" gorm:"size:128"`                      // 最新入库记录
 	FreezeClaim     model2.FloatList  `json:"freezeClaim" gorm:"type:json;comment:冷冻要求"`            // 冷冻要求 单位小时
 	IceRaftRecord   IceRaftRecordOmit `json:"iceRaftRecord" gorm:"->;foreignkey:IceRaftRecordId;references:Id"`
-	Label           string            `json:"label" gorm:"size:128;comment:标签"`                         // 标签
-	IceColdAddress  string            `json:"iceColdAddress" gorm:"size:128;comment:冰排预冷地点"`            //冰排预冷地点
-	SuitableForCold float32           `json:"suitableForCold" gorm:"type:decimal(10,2);comment:冰排适冷温度"` // 冰排遇冷温度
-	Sort            int               `json:"sort" gorm:"size:4;comment:排序"`                            // 排序
-	ForColdTime     int               `json:"forColdTime" gorm:"comment:适冷时长"`                          // 适冷时长 单位分钟
-	BindCoolerBox   int               `json:"bindCoolerBox" gorm:"comment:绑定保温箱"`                       //绑定保温箱  当该字段为零时,代表未绑定保温箱可正常出库
-	CoolerBoxName   string            `json:"coolerBoxName" gorm:"-"`                                   // 保温箱名称
+	Label           string            `json:"label" gorm:"size:128;comment:标签"`                   // 标签
+	IceColdAddress  string            `json:"iceColdAddress" gorm:"size:128;comment:冰排预冷地点"`      //冰排预冷地点
+	SuitableForCold string            `json:"suitableForCold" gorm:"size:128;comment:冰排适冷温度"`     // 冰排遇冷温度
+	Sort            int               `json:"sort" gorm:"size:4;comment:排序"`                      // 排序
+	ForColdTime     float64           `json:"forColdTime" gorm:"type:decimal(10,2);comment:适冷时长"` // 适冷时长 单位小时
+	BindCoolerBox   model2.IntList    `json:"bindCoolerBox" gorm:"type:json;comment:绑定保温箱"`       //绑定保温箱  当该字段为零时,代表未绑定保温箱可正常出库
+	CoolerBoxName   model2.StringList `json:"coolerBoxName" gorm:"type:json;comment:保温箱名称"`       // 保温箱名称
 	model2.ControlBy
 	model2.ModelTime
 	model2.DeptBy
@@ -40,11 +40,12 @@ func (IceRaftOmit) TableName() string {
 }
 
 const (
-	IceRaftRecordStatusFreezing    = "1" // 冷冻中
-	IceRaftRecordStatusWaitUse     = "2" // 待使用
-	IceRaftRecordStatusUsing       = "3" // 使用中
-	IceRaftRecordStatusFinish      = "4" // 已结束
-	IceRaftRecordReleasedInTheCold = "5" // 释冷中
+	IceRaftRecordStatusFreezing       = "1" // 冷冻中
+	IceRaftRecordStatusWaitUse        = "2" // 待使用
+	IceRaftRecordStatusUsing          = "3" // 使用中
+	IceRaftRecordStatusFinish         = "4" // 已结束
+	IceRaftRecordReleasedInTheCold    = "5" // 释冷中
+	IceRaftRecordReleasedInTheColdEnd = "6" // 释冷完成
 )
 
 func GetIceRaftRecordStatus(s string) string {
@@ -61,40 +62,43 @@ func GetIceRaftRecordStatus(s string) string {
 		return "已结束"
 	case IceRaftRecordReleasedInTheCold:
 		return "释冷中"
+	case IceRaftRecordReleasedInTheColdEnd:
+		return "释冷完成"
 	}
 	return ""
 }
 
-// 冰排记录
+// IceRaftRecord 冰排记录
 type IceRaftRecord struct {
 	model2.Model
 	IceRaftId         int              `json:"iceRaftId" gorm:"size:128;comment:冰排id"`
-	Label             string           `json:"label" gorm:"size:128;comment:标签"`                         // 标签
-	Code              string           `json:"code" gorm:"size:128;comment:编号"`                          // 编号
-	Status            string           `json:"status" gorm:"size:4;not null;default:'2';comment:状态"`     // 0未入库 1-冷冻中 2-待使用 3-使用中 4已结束 5-释冷中
-	Sort              int              `json:"sort" gorm:"size:4;comment:排序"`                            // 排序
-	ForColdTime       int              `json:"forColdTime" gorm:"comment:适冷时长"`                          // 适冷时长 单位分钟
-	InStorageTime     model2.Time      `json:"inStorageTime"  gorm:"size:128;comment:入库时间"`              // 入库时间
-	OutStorageTime    model2.Time      `json:"outStorageTime"  gorm:"size:128;comment:出库时间"`             // 出库时间
-	IceLockerId       int              `json:"iceLockerId" gorm:"size:128;comment:冷冻柜id"`                // 冷冻柜id
-	CoolerBoxId       int              `json:"coolerBoxId" gorm:"size:128;comment:保温箱id"`                // 保温箱id
-	FreezeClaim       model2.FloatList `json:"freezeClaim" gorm:"type:json;comment:冷冻要求"`                // 冷冻要求 单位小时
-	FreezeDuration    int              `json:"freezeDuration" gorm:"size:128;comment:冷冻时长"`              // 冷冻时长 单位分钟
-	SuitableForCold   float32          `json:"suitableForCold" gorm:"type:decimal(10,2);comment:冰排适冷温度"` // 冰排适冷温度
-	EndForColdTime    model2.Time      `json:"endForColdTime"  gorm:"size:128;comment:适冷结束时间"`           // 适冷结束时间
-	IsSuitableForCold int              `json:"isSuitableForCold" gorm:"size:4;not null;comment:是否结束适冷"`  //0 未适冷 1已适冷
-	CoolerBoxStarTime model2.Time      `json:"coolerBoxStarTime"  gorm:"size:128;comment:保温箱开始预冷时间"`     //保温箱开始预冷时间
-	CoolerBoxEndTime  model2.Time      `json:"coolerBoxEndTime"  gorm:"size:128;comment:保温箱结束记录时间"`      //保温箱结束记录时间
-	StartIceColdTime  model2.Time      `json:"start_ice_cold_time" gorm:"size:128;comment:释冷开始时间"`       //冰排释冷开始时间
-	IceColdAddress    string           `json:"ice_cold_address" gorm:"size:128;comment:冰排预冷地点"`          //冰排预冷地点
-	IceColdUsers      string           `json:"ice_cold_users" gorm:"size:128;comment:冰排预冷操作人员"`          //冰排预冷操作人员
-	IceUseUsers       string           `json:"ice_use_users" gorm:"size:128;comment:冰排使用操作人员"`           //冰排使用操作人员
-	IceUseTime        model2.Time      `json:"ice_use_time" gorm:"size:128;comment:冰排使用时间"`              //冰排使用时间
-	CoolerColdAddress string           `json:"cooler-cold-address" gorm:"size:128;comment:保温箱预冷地点"`      //保温箱预冷地点
-	CoolerColdUsers   string           `json:"cooler-cold-users" gorm:"size:128;comment:保温箱预冷操作人员"`      //保温箱预冷操作人员
-	CoolerUseUsers    string           `json:"cooler-use-users" gorm:"size:128;comment:保温箱使用操作人员"`       //保温箱使用操作人员
-	ReturnDate        model2.Time      `json:"returnDate" gorm:"size:128;comment:归还日期"`                  // 归还日期
-	CoolingTime       string           `json:"coolingTime" gorm:"-"`                                     //释冷时间
+	Label             string           `json:"label" gorm:"size:128;comment:标签"`                           // 标签
+	Code              string           `json:"code" gorm:"size:128;comment:编号"`                            // 编号
+	Status            string           `json:"status" gorm:"size:4;not null;default:'2';comment:状态"`       // 0未入库 1-冷冻中 2-待使用 3-使用中 4已结束 5-释冷中 6-释冷完成
+	Sort              int              `json:"sort" gorm:"size:4;comment:排序"`                              // 排序
+	ForColdTime       float64          `json:"forColdTime" gorm:"type:decimal(10,2);comment:要求适冷时间"`       // 适冷时长 单位小时
+	ForColdTimeActual float64          `json:"forColdTimeActual" gorm:"type:decimal(10,2);comment:实际适冷时间"` // 适冷时长 单位小时
+	InStorageTime     model2.Time      `json:"inStorageTime"  gorm:"size:128;comment:入库时间"`                // 入库时间
+	OutStorageTime    model2.Time      `json:"outStorageTime"  gorm:"size:128;comment:出库时间"`               // 出库时间
+	IceLockerId       int              `json:"iceLockerId" gorm:"size:128;comment:冷冻柜id"`                  // 冷冻柜id
+	CoolerBoxId       int              `json:"coolerBoxId" gorm:"size:128;comment:保温箱id"`                  // 保温箱id
+	FreezeClaim       model2.FloatList `json:"freezeClaim" gorm:"type:json;comment:冷冻要求"`                  // 冷冻要求 单位小时
+	FreezeDuration    int              `json:"freezeDuration" gorm:"size:128;comment:冷冻时长"`                // 冷冻时长 单位分钟
+	SuitableForCold   string           `json:"suitableForCold"  gorm:"size:128;comment:冰排适冷温度"`            // 冰排适冷温度
+	EndForColdTime    model2.Time      `json:"endForColdTime"  gorm:"size:128;comment:适冷结束时间"`             // 适冷结束时间
+	IsSuitableForCold int              `json:"isSuitableForCold" gorm:"size:4;not null;comment:是否结束适冷"`    //0 未适冷 1已适冷
+	CoolerBoxStarTime model2.Time      `json:"coolerBoxStarTime"  gorm:"size:128;comment:保温箱开始预冷时间"`       //保温箱开始预冷时间
+	CoolerBoxEndTime  model2.Time      `json:"coolerBoxEndTime"  gorm:"size:128;comment:保温箱结束记录时间"`        //保温箱结束记录时间
+	StartIceColdTime  model2.Time      `json:"start_ice_cold_time" gorm:"size:128;comment:释冷开始时间"`         //冰排释冷开始时间
+	IceColdAddress    string           `json:"ice_cold_address" gorm:"size:128;comment:冰排预冷地点"`            //冰排预冷地点
+	IceColdUsers      string           `json:"ice_cold_users" gorm:"size:128;comment:冰排预冷操作人员"`            //冰排预冷操作人员
+	IceUseUsers       string           `json:"ice_use_users" gorm:"size:128;comment:冰排使用操作人员"`             //冰排使用操作人员
+	IceUseTime        model2.Time      `json:"ice_use_time" gorm:"size:128;comment:冰排使用时间"`                //冰排使用时间
+	CoolerColdAddress string           `json:"cooler-cold-address" gorm:"size:128;comment:保温箱预冷地点"`        //保温箱预冷地点
+	CoolerColdUsers   string           `json:"cooler-cold-users" gorm:"size:128;comment:保温箱预冷操作人员"`        //保温箱预冷操作人员
+	CoolerUseUsers    string           `json:"cooler-use-users" gorm:"size:128;comment:保温箱使用操作人员"`         //保温箱使用操作人员
+	ReturnDate        model2.Time      `json:"returnDate" gorm:"size:128;comment:归还日期"`                    // 归还日期
+	CoolingTime       string           `json:"coolingTime" gorm:"-"`                                       //释冷时间
 	IceLocker         IceLockerOmit    `json:"iceLocker" gorm:"->"`
 	CoolerBox         CoolerBoxOmit    `json:"coolerBox" gorm:"->"`
 	CoolerBoxRecord   CoolerBoxRecord  `json:"coolerBoxRecord" gorm:"-"`
@@ -105,19 +109,20 @@ type IceRaftRecord struct {
 }
 
 type IceRaftRecordOmit struct {
-	Id                int              `json:"id,omitempty"`                                        // 主键编码
-	IceRaftId         int              `json:"iceRaftId,omitempty"`                                 // 冰排id
-	Status            string           `json:"status"`                                              // 1-停用 2-正常
-	InStorageTime     model2.Time      `json:"inStorageTime,omitempty"`                             // 入库时间
-	OutStorageTime    model2.Time      `json:"outStorageTime,omitempty"`                            // 出库时间
-	IceLockerId       int              `json:"iceLockerId,omitempty"`                               // 冷冻柜id
-	CoolerBoxId       int              `json:"coolerBoxId,omitempty"`                               // 保温箱id
-	FreezeClaim       model2.FloatList `json:"freezeClaim" gorm:"type:json;comment:冷冻要求"`           // 冷冻要求 单位小时
-	FreezeDuration    int              `json:"freezeDuration"`                                      // 冷冻时长 单位分钟
-	SuitableForCold   float32          `json:"suitableForCold" `                                    // 冰排适冷温度
-	EndForColdTime    model2.Time      `json:"endForColdTime"  `                                    // 适冷结束时间
-	IsSuitableForCold int              `json:"isSuitableForCold" `                                  //0 未适冷 1已适冷
-	StartIceColdTime  model2.Time      `json:"start_ice_cold_time" gorm:"size:128;comment:释冷开始时间"`  //冰排释冷开始时间
+	Id                int              `json:"id,omitempty"`                                       // 主键编码
+	IceRaftId         int              `json:"iceRaftId,omitempty"`                                // 冰排id
+	Status            string           `json:"status"`                                             // 1-停用 2-正常
+	InStorageTime     model2.Time      `json:"inStorageTime,omitempty"`                            // 入库时间
+	OutStorageTime    model2.Time      `json:"outStorageTime,omitempty"`                           // 出库时间
+	IceLockerId       int              `json:"iceLockerId,omitempty"`                              // 冷冻柜id
+	CoolerBoxId       int              `json:"coolerBoxId,omitempty"`                              // 保温箱id
+	FreezeClaim       model2.FloatList `json:"freezeClaim" gorm:"type:json;comment:冷冻要求"`          // 冷冻要求 单位小时
+	FreezeDuration    int              `json:"freezeDuration"`                                     // 冷冻时长 单位分钟
+	SuitableForCold   string           `json:"suitableForCold" `                                   // 冰排适冷温度
+	EndForColdTime    model2.Time      `json:"endForColdTime"  `                                   // 适冷结束时间
+	IsSuitableForCold int              `json:"isSuitableForCold" `                                 //0 未适冷 1已适冷
+	StartIceColdTime  model2.Time      `json:"start_ice_cold_time" gorm:"size:128;comment:释冷开始时间"` //冰排释冷开始时间
+	ForColdTimeActual float32          `json:"forColdTimeActual"`
 	IceColdAddress    string           `json:"ice_cold_address" gorm:"size:128;comment:冰排预冷地点"`     //冰排预冷地点
 	IceColdUsers      string           `json:"ice_cold_users" gorm:"size:128;comment:冰排预冷操作人员"`     //冰排预冷操作人员
 	IceUseUsers       string           `json:"ice_use_users" gorm:"size:128;comment:冰排使用操作人员"`      //冰排使用操作人员
@@ -125,6 +130,7 @@ type IceRaftRecordOmit struct {
 	CoolerColdAddress string           `json:"cooler-cold-address" gorm:"size:128;comment:保温箱预冷地点"` //保温箱预冷地点
 	CoolerColdUsers   string           `json:"cooler-cold-users" gorm:"size:128;comment:保温箱预冷操作人员"` //保温箱预冷操作人员
 	CoolerUseUsers    string           `json:"cooler-use-users" gorm:"size:128;comment:保温箱使用操作人员"`  //保温箱使用操作人员
+	ReturnDate        model2.Time      `json:"returnDate" gorm:"size:128;comment:归还日期"`             // 归还日期
 	CoolingTime       string           `json:"coolingTime" gorm:"-"`                                //释冷时间
 	IceLocker         IceLockerOmit    `json:"iceLocker" gorm:"->"`
 	CoolerBox         CoolerBoxOmit    `json:"coolerBox" gorm:"->"`

+ 1 - 0
app/admin/router/ice_raft.go

@@ -29,6 +29,7 @@ func registerIceRaftRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddle
 		r.GET("/cooler-box", cont.GetPageByCoolerBoxId)
 		r.POST("/isoutstorage", cont.IsOutStorage)
 		r.POST("/bindCoolerBox", cont.BindCoolerBox)
+		r.POST("/UnbindCoolerBox", cont.UnBindCoolerBox)
 	}
 
 	cont2 := controller.IceRaftRecordController{}

+ 1 - 0
app/admin/service/address.go

@@ -8,6 +8,7 @@ import (
 	"cold-delivery/common/global"
 	"errors"
 	"fmt"
+
 	"gogs.baozhida.cn/zoie/OAuth-core/service"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"

+ 2 - 0
app/admin/service/company.go

@@ -390,6 +390,8 @@ func (e *Company) DeptPageCall(deptList *[]model.SysDept, menu model.SysDept) mo
 		mi.IsCoolerShow = list[j].IsCoolerShow
 		mi.IsIceReleaseCold = list[j].IsIceReleaseCold
 		mi.CompanyAddress = list[j].CompanyAddress
+		mi.IceRaftManage = list[j].IceRaftManage
+		mi.AppName = list[j].AppName
 		mi.Children = []model.SysDept{}
 		ms := e.DeptPageCall(deptList, mi)
 		min = append(min, ms)

+ 32 - 7
app/admin/service/cooler_box.go

@@ -64,6 +64,7 @@ func (e *CoolerBox) GetPage(c *dto.CoolerBoxGetPageReq, list *[]model.CoolerBox,
 			}
 		}
 	}
+
 	for i, _ := range *list {
 		var dataIce model.IceRaft
 		var dataIces []model.IceRaft
@@ -81,7 +82,15 @@ func (e *CoolerBox) GetPage(c *dto.CoolerBoxGetPageReq, list *[]model.CoolerBox,
 			return global.GetFailedErr
 		}
 		(*list)[i].IceRaft = dataIces
-		e.Orm.Model(&model.CoolerBoxRecord{}).Select("status").Where("cooler_box_id = ?", (*list)[i].Id).Order("cooler_user_time desc").First(&(*list)[i].UseStatus)
+		err = e.Orm.Model(&model.CoolerBoxRecord{}).Where("cooler_box_id = ?", (*list)[i].Id).Where("status = ?", 1).First(&(*list)[i].CoolerBoxRecords).Error
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				continue
+			} else {
+				e.Log.Errorf("查询保温箱记录失败: %s", err)
+				return global.GetFailedErr
+			}
+		}
 	}
 	//排序
 	sort.SliceStable(*list, func(i, j int) bool {
@@ -634,7 +643,7 @@ func (e *CoolerBox) CoolerBoxStarTime(c *dto.IceStartbleForColfTimReq, p *action
 		}
 	}()
 	var user model.SysUser
-	first := e.Orm.Model(&model.SysUser{}).Where("id = ?", p.UserId).First(&user)
+	first := tx.Model(&model.SysUser{}).Where("id = ?", p.UserId).First(&user)
 	if first.Error != nil {
 		return global.GetFailedErr
 	}
@@ -642,7 +651,7 @@ func (e *CoolerBox) CoolerBoxStarTime(c *dto.IceStartbleForColfTimReq, p *action
 	for _, v := range c.Id {
 		var cooler model.CoolerBoxRecord
 		var coolerBox model.CoolerBox
-		err = e.Orm.Model(&model.CoolerBox{}).Where("id = ?", v).First(&coolerBox).Error
+		err = tx.Model(&model.CoolerBox{}).Where("id = ?", v).First(&coolerBox).Error
 		if err != nil {
 			e.Log.Errorf("获取保温箱信息失败: %s", err)
 			return errors.New("获取保温箱信息失败")
@@ -657,16 +666,26 @@ func (e *CoolerBox) CoolerBoxStarTime(c *dto.IceStartbleForColfTimReq, p *action
 		cooler.DeptId = p.DeptId
 		cooler.Sn = coolerBox.Sn
 		cooler.Name = coolerBox.Name
-		err = e.Orm.Create(&cooler).Error
+		err = tx.Create(&cooler).Error
 		if err != nil {
 			e.Log.Errorf("db error: %s", err)
 			return global.CreateFailedErr
 		}
+		//更新保温箱状态为遇冷中  1
+		if coolerBox.UseStatus == 1 || coolerBox.UseStatus == 3 {
+			e.Log.Errorf("保温箱已经遇冷,不能重复遇冷: %s", err)
+			return errors.New("保温箱已经遇冷,不能重复遇冷")
+		}
+		err = tx.Model(&model.CoolerBox{}).Where("id =?", v).Update("use_status", 1).Error
+		if err != nil {
+			e.Log.Errorf("更新保温箱状态失败: %s", err)
+			return errors.New("更新保温箱状态失败")
+		}
 	}
 	return nil
 }
 
-// 保温箱结束使用
+// CoolerBoxEndUse 保温箱结束使用
 func (e *CoolerBox) CoolerBoxEndUse(c *dto.IceStartbleForColfTimReq, p *actions.DataPermission) error {
 	var err error
 
@@ -682,7 +701,7 @@ func (e *CoolerBox) CoolerBoxEndUse(c *dto.IceStartbleForColfTimReq, p *actions.
 	for _, v := range c.Id {
 		var cooler model.CoolerBoxRecord
 		var coolerBox model.CoolerBox
-		err = e.Orm.Model(&model.CoolerBox{}).Where("id = ?", v).First(&coolerBox).Error
+		err = tx.Model(&model.CoolerBox{}).Where("id = ?", v).First(&coolerBox).Error
 		if err != nil {
 			e.Log.Errorf("获取保温箱信息失败: %s", err)
 			return errors.New("获取保温箱信息失败")
@@ -690,11 +709,17 @@ func (e *CoolerBox) CoolerBoxEndUse(c *dto.IceStartbleForColfTimReq, p *actions.
 		//保温箱使用状态变为结束使用
 		cooler.CoolerEndUseTime = model2.Time(time.Now())
 		cooler.Status = "2"
-		err = e.Orm.Model(&cooler).Where("cooler_box_id = ?", v).Updates(&cooler).Error
+		err = tx.Model(&cooler).Where("cooler_box_id = ?", v).Updates(&cooler).Error
 		if err != nil {
 			e.Log.Errorf("db error: %s", err)
 			return global.CreateFailedErr
 		}
+		//更新保温箱状态为默认状态  0
+		err = tx.Model(&model.CoolerBox{}).Where("id =?", v).Update("use_status", 0).Error
+		if err != nil {
+			e.Log.Errorf("更新保温箱状态失败: %s", err)
+			return errors.New("更新保温箱状态失败")
+		}
 	}
 	return nil
 }

+ 2 - 2
app/admin/service/dto/cooler_box.go

@@ -33,7 +33,7 @@ type CoolerBoxInsertReq struct {
 	ColdSpots         string   `json:"cold_spots"`                           //遇冷地点
 	ColdTemperatures  string   `json:"cold_temperatures"`                    //遇冷温度
 	Code              []string `json:"code"`
-	ForColdCoolerTime int      `json:"for_cold_cooler_time"` //保温箱预冷要求
+	ForColdCoolerTime float32  `json:"for_cold_cooler_time" gorm:"comment:预冷要求"` //保温箱预冷要求
 	common.ControlBy  `swaggerignore:"true"`
 	common.DeptBy     `swaggerignore:"true"`
 }
@@ -71,7 +71,7 @@ type CoolerBoxUpdateReq struct {
 	ColdSpots         string   `json:"cold_spots"`      //遇冷地点
 	ColdTemperatures  string   `json:"cold_temperatures"`
 	Code              []string `json:"code"`
-	ForColdCoolerTime int      `json:"for_cold_cooler_time"` //保温箱预冷要求
+	ForColdCoolerTime float32  `json:"for_cold_cooler_time" gorm:"comment:预冷要求"` //保温箱预冷要求
 	common.ControlBy  `swaggerignore:"true"`
 }
 

+ 13 - 5
app/admin/service/dto/ice_raft.go

@@ -55,9 +55,9 @@ type IceRaftInsertReq struct {
 	FreezeClaim      common.FloatList `json:"freezeClaim"`                                              // 冷冻要求 单位小时
 	Label            string           `json:"label"`                                                    // 标签
 	IceColdAddress   string           `json:"iceColdAddress" gorm:"size:128;comment:冰排预冷地点"`            //冰排遭冷地点
-	SuitableForCold  float32          `json:"suitableForCold" gorm:"type:decimal(10,2);comment:冰排适冷温度"` // 冰排遇冷温度
+	SuitableForCold  string           `json:"suitableForCold" gorm:"type:decimal(10,2);comment:冰排适冷温度"` // 冰排遇冷温度
 	Sort             int              `json:"sort"`                                                     // 排序
-	ForColdTime      int              `json:"forColdTime"`                                              // 释冷时长 单位分钟
+	ForColdTime      float64          `json:"forColdTime"`                                              // 释冷时长 单位分钟
 	common.ControlBy `swaggerignore:"true"`
 	common.DeptBy    `swaggerignore:"true"`
 }
@@ -96,9 +96,9 @@ type IceRaftUpdateReq struct {
 	Status           string           `json:"status"`                                                   // 1-停用 2-正常
 	FreezeClaim      common.FloatList `json:"freezeClaim"`                                              // 冷冻要求 单位小时
 	IceColdAddress   string           `json:"iceColdAddress" gorm:"size:128;comment:冰排预冷地点"`            //冰排预冷地点
-	SuitableForCold  float32          `json:"suitableForCold" gorm:"type:decimal(10,2);comment:冰排适冷温度"` // 冰排遇冷温度
+	SuitableForCold  string           `json:"suitableForCold" gorm:"type:decimal(10,2);comment:冰排适冷温度"` // 冰排遇冷温度
 	Sort             int              `json:"sort"`
-	ForColdTime      int              `json:"forColdTime"` // 适冷时长 单位分钟
+	ForColdTime      float64          `json:"forColdTime"` // 适冷时长 单位分钟
 	common.ControlBy `swaggerignore:"true"`
 }
 
@@ -156,9 +156,17 @@ type IceRaftInStorageReq struct {
 type IceRaftOutStorageReq struct {
 	Code             []string `json:"code"`
 	CoolerBoxId      int      `json:"coolerBoxId"`     // 保温箱id
-	SuitableForCold  float32  `json:"suitableForCold"` // 冰排适冷温度
+	SuitableForCold  string   `json:"suitableForCold"` // 冰排适冷温度
 	common.ControlBy `swaggerignore:"true"`
 }
+type BindCoolerBox struct {
+	Code        []string `json:"code"`
+	CoolerBoxId []int    `json:"coolerBoxId"` // 保温箱id
+}
+type UnBindCoolerBox struct {
+	Code        string `json:"code"`
+	CoolerBoxId []int  `json:"coolerBoxId"` // 保温箱id
+}
 type IceStartbleForColfTimReq struct {
 	Id []string `json:"id"`
 }

+ 192 - 87
app/admin/service/ice_raft.go

@@ -6,13 +6,16 @@ import (
 	"cold-delivery/common/actions"
 	cDto "cold-delivery/common/dto"
 	"cold-delivery/common/global"
+	"cold-delivery/common/lib"
 	model2 "cold-delivery/common/model"
 	"errors"
 	"fmt"
-	"gogs.baozhida.cn/zoie/OAuth-core/service"
-	"gorm.io/gorm"
 	"sort"
+	"strings"
 	"time"
+
+	"gogs.baozhida.cn/zoie/OAuth-core/service"
+	"gorm.io/gorm"
 )
 
 type IceRaft struct {
@@ -41,15 +44,6 @@ func (e *IceRaft) GetPage(c *dto.IceRaftGetPageReq, list *[]model.IceRaft, count
 			Find(list).Limit(-1).Offset(-1).
 			Count(count).Error
 	}
-	for i, _ := range *list {
-		if (*list)[i].BindCoolerBox != 0 {
-			err = e.Orm.Model(&model.CoolerBox{}).Select("name").Where("id = ?", (*list)[i].BindCoolerBox).First(&(*list)[i].CoolerBoxName).Error
-			if err != nil {
-				e.Log.Errorf("db error: %s", err)
-				return global.GetFailedErr
-			}
-		}
-	}
 	if err != nil {
 		e.Log.Errorf("db error: %s", err)
 		return global.GetFailedErr
@@ -71,7 +65,7 @@ func IceRaftNameRecordStatusScopes(status string) func(db *gorm.DB) *gorm.DB {
 func IceRaftNameRecordIceLockerScopes(status string) func(db *gorm.DB) *gorm.DB {
 	return func(db *gorm.DB) *gorm.DB {
 		if len(status) == 0 {
-			return db.Where("ice_raft_record.status = 1 or ice_raft_record.status =2")
+			return db.Where("ice_raft_record.status = 1 or ice_raft_record.status =2 or ice_raft_record.status =5 or ice_raft_record.status =6")
 		}
 		if status == "0" {
 			return db.Where("ice_raft_record.status is null")
@@ -150,17 +144,17 @@ func (e *IceRaft) GetRecordPage(c *dto.IceRaftGetNewestRecordPageReq, list *[]mo
 			Find(list).Limit(-1).Offset(-1).
 			Count(count).Error
 	}
-	for i, _ := range *list {
-		if (*list)[i].IceRaftRecord.IsSuitableForCold == 1 {
-			start, _ := time.Parse("2006-01-02 15:04:05", (*list)[i].IceRaftRecord.StartIceColdTime.String())
-			end, _ := time.Parse("2006-01-02 15:04:05", (*list)[i].IceRaftRecord.EndForColdTime.String())
-			sub := end.Sub(start)
-			hours := sub.Hours()
-			minutes := int(sub.Minutes()) % 60
-			sprintf := fmt.Sprintf("%vh%dm\n", hours, minutes)
-			(*list)[i].IceRaftRecord.CoolingTime = sprintf
-		}
-	}
+	//for i, _ := range *list {
+	//	if (*list)[i].IceRaftRecord.IsSuitableForCold == 1 && len((*list)[i].IceRaftRecord.StartIceColdTime.String()) != 0 {
+	//		start, _ := time.Parse("2006-01-02 15:04:05", (*list)[i].IceRaftRecord.StartIceColdTime.String())
+	//		end, _ := time.Parse("2006-01-02 15:04:05", (*list)[i].IceRaftRecord.EndForColdTime.String())
+	//		sub := end.Sub(start)
+	//		hours := sub.Hours()
+	//		minutes := int(sub.Minutes()) % 60
+	//		sprintf := fmt.Sprintf("%vh%dm\n", hours, minutes)
+	//		(*list)[i].IceRaftRecord.CoolingTime = sprintf
+	//	}
+	//}
 	if err != nil {
 		e.Log.Errorf("db error: %s", err)
 		return global.GetFailedErr
@@ -456,13 +450,14 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 		err = errors.New("保温箱状态异常")
 		return err
 	}
-	var user model.SysUser
-	falseIce := make([]string, 0)
-	first := e.Orm.Model(&model.SysUser{}).Where("id = ?", p.UserId).First(&user)
-	if first.Error != nil {
-		err = errors.New("获取用户信息失败")
-		return err
+	if len(coolerBoxModel.BindIceRaftId) != 0 {
+		is := lib.StrListEqual(coolerBoxModel.BindIceRaftId, c.Code)
+		if !is {
+			err = errors.New("保温箱已绑定冰排,禁止出库")
+			return err
+		}
 	}
+	falseIce := make([]string, 0)
 	err, sysUser := GetUserProfile(e.Orm, p.UserId)
 	if err != nil {
 		err = errors.New("获取用户信息失败")
@@ -485,12 +480,21 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 			return err
 		}
 
-		//判断冰排绑定,当冰排绑定和需要绑定的保温箱id不一致时禁止冰排出库装箱
-		if iceRaftModel.BindCoolerBox != 0 && iceRaftModel.BindCoolerBox != coolerBoxModel.Id {
-			err = errors.New(fmt.Sprintf("冰排【%s】绑定的保温箱id为%d,当前保温箱id为%d,禁止出库!", code, iceRaftModel.BindCoolerBox, c.CoolerBoxId))
+		var iceRaftSuccess []string
+		var iceRaftErr []string
+		if len(iceRaftModel.BindCoolerBox) != 0 {
+			for _, v := range iceRaftModel.BindCoolerBox {
+				if v == coolerBoxModel.Id {
+					iceRaftSuccess = append(iceRaftSuccess, code)
+				} else {
+					iceRaftErr = append(iceRaftErr, fmt.Sprintf("冰排【%s】已绑定保温箱【%v】,禁止出库!", code, iceRaftModel.CoolerBoxName))
+				}
+			}
+		}
+		if len(iceRaftErr) != 0 && len(iceRaftSuccess) == 0 {
+			err = errors.New(strings.Join(iceRaftErr, " "))
 			return err
 		}
-
 		// 获取冰排记录
 		var iceRaftRecordModel model.IceRaftRecord
 		err = e.Orm.Scopes(actions.Permission(iceRaftRecordModel.TableName(), p)).
@@ -500,7 +504,7 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 			e.Log.Errorf("db error: %s", err)
 			return errors.New("获取冰排记录失败,请确认冰排是否入库!")
 		}
-		if len(iceRaftRecordModel.OutStorageTime.String()) > 0 {
+		if len(iceRaftRecordModel.OutStorageTime.String()) > 0 && iceRaftRecordModel.Status == model.IceRaftRecordStatusUsing {
 			err = errors.New(fmt.Sprintf("冰排【%s】已出库,禁止出库!", code))
 			return err
 		}
@@ -509,21 +513,32 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 		sort.Slice(iceRaftRecordModel.FreezeClaim, func(i, j int) bool {
 			return iceRaftRecordModel.FreezeClaim[i] < iceRaftRecordModel.FreezeClaim[j]
 		})
-
-		if sysUser.Dept.IsOutStorage {
-			for _, v := range iceRaftRecordModel.FreezeClaim {
-				if inTime.Add(time.Hour * time.Duration(v)).After(time.Now()) {
-					str := fmt.Sprintf("冰排【%s】未达到冷冻时长【%v】,禁止出库", code, v)
-					err = errors.New(str)
-					return err
-				}
-			}
+		fmt.Println("冷冻要求====================", iceRaftRecordModel.FreezeClaim)
+
+		//if sysUser.Dept.IsOutStorage {
+		//	for _, v := range iceRaftRecordModel.FreezeClaim {
+		//		if inTime.Add(time.Hour * time.Duration(v)).After(time.Now()) {
+		//			str := fmt.Sprintf("冰排【%s】未达到冷冻时长【%v】,禁止出库", code, v)
+		//			err = errors.New(str)
+		//			return err
+		//		}
+		//	}
+		//}
+		if inTime.Add(time.Hour * time.Duration(iceRaftRecordModel.FreezeClaim[0])).After(time.Now()) {
+			str := fmt.Sprintf("冰排【%s】未达到冷冻时长【%v】,禁止出库", code, iceRaftRecordModel.FreezeClaim[0])
+			err = errors.New(str)
+			return err
 		}
 		//判断冰排释冷要求是否为0,如果不为零,则判断是否达到释冷时长,否则不允许出库
-		if sysUser.Dept.IsIceReleaseCold && iceRaftRecordModel.ForColdTime != 0 {
-			start, err := time.Parse("2006-01-02 15:04:05", iceRaftRecordModel.StartIceColdTime.String())
-			if start.Add(time.Minute * time.Duration(iceRaftRecordModel.ForColdTime)).After(time.Now()) {
-				err = errors.New(fmt.Sprintf("冰排【%s】未达到释冷时长【%v】,禁止出库", code, iceRaftRecordModel.ForColdTime))
+		if sysUser.Dept.IsIceReleaseCold && iceRaftModel.ForColdTime != 0 {
+			if len(iceRaftRecordModel.StartIceColdTime.String()) != 0 {
+				start, err := time.Parse("2006-01-02 15:04:05", iceRaftRecordModel.StartIceColdTime.String())
+				if start.Add(time.Hour * time.Duration(iceRaftRecordModel.ForColdTime)).After(time.Now()) {
+					err = errors.New(fmt.Sprintf("冰排【%s】未达到释冷时长【%v】小时,禁止出库", code, iceRaftRecordModel.ForColdTime))
+					return err
+				}
+			} else {
+				err = errors.New(fmt.Sprintf("冰排【%s】还未开始释冷,请先释冷再出库!!!", code))
 				return err
 			}
 		}
@@ -531,10 +546,10 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 		iceRaftRecordModel.Status = model.IceRaftRecordStatusUsing
 		iceRaftRecordModel.CoolerBoxId = coolerBoxModel.Id
 		iceRaftRecordModel.OutStorageTime = model2.Time(time.Now())
-		iceRaftRecordModel.IceUseUsers = user.NickName
+		iceRaftRecordModel.IceUseUsers = sysUser.NickName
 		iceRaftRecordModel.IceUseTime = model2.Time(time.Now())
 		iceRaftRecordModel.IceRaftId = iceRaftModel.Id
-		if user.Dept.IsIceReleaseCold {
+		if sysUser.Dept.IsIceReleaseCold {
 			iceRaftRecordModel.IsSuitableForCold = 1
 			iceRaftRecordModel.SuitableForCold = iceRaftModel.SuitableForCold
 			iceRaftRecordModel.EndForColdTime = model2.Time(time.Now())
@@ -569,7 +584,7 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 	cooler.DeptId = p.DeptId
 	cooler.Name = coolerBoxModel.Name
 	cooler.HistoryCode = append(cooler.HistoryCode, c.Code...)
-	cooler.CoolerUseUsers = user.NickName
+	cooler.CoolerUseUsers = sysUser.NickName
 	cooler.ForColdCoolerTime = coolerBoxModel.ForColdCoolerTime
 	//查询是否有正在使用中的保温箱记录
 	var count int64
@@ -589,11 +604,17 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 	}
 	if sysUser.Dept.IsCoolerReleaseCold && coolerBoxModel.ForColdCoolerTime != 0 {
 		start, err := time.Parse("2006-01-02 15:04:05", coolerBoxRecordModel.CoolerBoxStarTime.String())
-		if start.Add(time.Minute * time.Duration(coolerBoxModel.ForColdCoolerTime)).After(time.Now()) {
+		if start.Add(time.Hour * time.Duration(coolerBoxModel.ForColdCoolerTime)).After(time.Now()) {
 			err = errors.New(fmt.Sprintf("保温箱未达到释冷时长【%v】分钟,禁止装箱", coolerBoxModel.ForColdCoolerTime))
 			return err
 		}
 	}
+	//更新保温箱状态为使用中  2
+	err = e.Orm.Table(model.CoolerBox{}.TableName()).Where("id =?", coolerBoxModel.Id).Update("use_status", "2").Error
+	if err != nil {
+		e.Log.Errorf("更新保温箱状态失败: %s", err)
+		return errors.New("更新保温箱状态失败")
+	}
 	//如果有正在使用中的保温箱记录,就更新
 	if count > 0 {
 		err = tx.Where("id = ?", coolerBoxRecordModel.Id).Updates(&cooler).Error
@@ -606,7 +627,7 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 }
 
 // BindCookerBox 冰排绑定保温箱
-func (e *IceRaft) BindCookerBox(c *dto.IceRaftOutStorageReq, p *actions.DataPermission) error {
+func (e *IceRaft) BindCookerBox(c *dto.BindCoolerBox, p *actions.DataPermission) error {
 	var err error
 
 	tx := e.Orm.Begin()
@@ -618,51 +639,115 @@ func (e *IceRaft) BindCookerBox(c *dto.IceRaftOutStorageReq, p *actions.DataPerm
 		}
 	}()
 	// 查询保温箱信息
-	var coolerBoxModel model.CoolerBox
-	err = e.Orm.Scopes(actions.Permission(coolerBoxModel.TableName(), p)).
-		First(&coolerBoxModel, c.CoolerBoxId).Error
-	if err != nil {
-		e.Log.Errorf("db error: %s", err)
-		return errors.New("获取保温箱信息失败")
-	}
-	if coolerBoxModel.Status != model.CoolerBoxStatusNormal {
-		err = errors.New("保温箱状态异常")
-		return err
-	}
-	for _, code := range c.Code {
-		// 查询冰排是否存在
-		var iceRaftModel model.IceRaft
-		err = e.Orm.Scopes(actions.Permission(iceRaftModel.TableName(), p)).
-			Where("code = ?", code).
-			Preload("IceRaftRecord").
-			First(&iceRaftModel).Error
+	for _, v := range c.CoolerBoxId {
+		var coolerBoxModel model.CoolerBox
+		err = e.Orm.Scopes(actions.Permission(coolerBoxModel.TableName(), p)).Where("id =?", v).
+			First(&coolerBoxModel).Error
 		if err != nil {
-			e.Log.Errorf("获取冰排信息失败: %s", err)
-			return errors.New("获取冰排信息失败")
+			e.Log.Errorf("db error: %s", err)
+			return errors.New("获取保温箱信息失败")
 		}
-
-		if iceRaftModel.Status != model.IceRaftStatusNormal {
-			err = errors.New(fmt.Sprintf("冰排【%s】状态异常", code))
+		if coolerBoxModel.Status != model.CoolerBoxStatusNormal {
+			err = errors.New("保温箱状态不可用")
 			return err
 		}
-		if iceRaftModel.BindCoolerBox != 0 {
-			err = tx.Model(&coolerBoxModel).Where("id =?", iceRaftModel.BindCoolerBox).Update("bind_ice_raft_id", "").Error
-			err = errors.New("更新绑定失败")
-			return err
+		for _, code := range c.Code {
+			// 查询冰排是否存在
+			var iceRaftModel model.IceRaft
+			err = e.Orm.Scopes(actions.Permission(iceRaftModel.TableName(), p)).
+				Where("code = ?", code).
+				Preload("IceRaftRecord").
+				First(&iceRaftModel).Error
+			if err != nil {
+				e.Log.Errorf("获取冰排信息失败: %s", err)
+				return errors.New("获取冰排信息失败")
+			}
+
+			if iceRaftModel.Status != model.IceRaftStatusNormal {
+				err = errors.New(fmt.Sprintf("冰排【%s】状态异常", code))
+				return err
+			}
+			iceRaftModel.CoolerBoxName = append(iceRaftModel.CoolerBoxName, coolerBoxModel.Name)
+			iceRaftModel.BindCoolerBox = append(iceRaftModel.BindCoolerBox, coolerBoxModel.Id)
+			iceRaftModel.CoolerBoxName = cDto.UniqueSlice(iceRaftModel.CoolerBoxName)
+			iceRaftModel.BindCoolerBox = cDto.UniqueSliceInt(iceRaftModel.BindCoolerBox)
+
+			err = e.Orm.Model(&iceRaftModel).Where("id =?", iceRaftModel.Id).Update("bind_cooler_box", iceRaftModel.BindCoolerBox).Update("cooler_box_name", iceRaftModel.CoolerBoxName).Error
+			if err != nil {
+				e.Log.Errorf("绑定保温箱失败: %s", err)
+				return errors.New("绑定保温箱失败")
+			}
+			coolerBoxModel.BindIceRaftId = append(coolerBoxModel.BindIceRaftId, code)
+			coolerBoxModel.BindIceRaftId = cDto.UniqueSlice(coolerBoxModel.BindIceRaftId)
+			err = e.Orm.Model(&coolerBoxModel).Where("id =?", coolerBoxModel.Id).Update("bind_ice_raft_id", coolerBoxModel.BindIceRaftId).Error
+			if err != nil {
+				e.Log.Errorf("绑定保温箱失败: %s", err)
+				return errors.New("绑定保温箱失败")
+			}
+		}
+	}
+	return nil
+}
+func (e *IceRaft) UnBindCookerBox(c *dto.UnBindCoolerBox, p *actions.DataPermission) error {
+	var err error
+
+	tx := e.Orm.Begin()
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+		} else {
+			tx.Commit()
+		}
+	}()
+	// 查询冰排是否存在
+	var iceRaftModel model.IceRaft
+	err = e.Orm.Scopes(actions.Permission(iceRaftModel.TableName(), p)).
+		Where("code = ?", c.Code).
+		Preload("IceRaftRecord").
+		First(&iceRaftModel).Error
+	if err != nil {
+		e.Log.Errorf("获取冰排信息失败: %s", err)
+		return errors.New("获取冰排信息失败")
+	}
+	for _, v := range iceRaftModel.BindCoolerBox {
+		var coolerBoxModel model.CoolerBox
+		err = e.Orm.Scopes(actions.Permission(coolerBoxModel.TableName(), p)).Where("id =?", v).First(&coolerBoxModel).Error
+		if err != nil {
+			e.Log.Errorf("获取保温箱信息失败: %s", err)
+			return errors.New("获取保温箱信息失败")
 		}
-		err = tx.Model(&iceRaftModel).Where("id =?", iceRaftModel.Id).Update("bind_cooler_box", coolerBoxModel.Id).Error
+		coolerBoxModel.BindIceRaftId = cDto.RemoveValue(coolerBoxModel.BindIceRaftId, c.Code)
+		err = e.Orm.Model(&coolerBoxModel).Where("id =?", coolerBoxModel.Id).Update("bind_ice_raft_id", coolerBoxModel.BindIceRaftId).Error
 		if err != nil {
-			e.Log.Errorf("绑定保温箱失败: %s", err)
-			return errors.New("绑定保温箱失败")
+			e.Log.Errorf("绑保温箱失败: %s", err)
+			return errors.New("绑保温箱失败")
 		}
-		coolerBoxModel.BindIceRaftId = append(coolerBoxModel.BindIceRaftId, code)
+	}
+	iceRaftModel.CoolerBoxName = []string{}
+	iceRaftModel.BindCoolerBox = []int{}
+	for _, v := range c.CoolerBoxId {
+		var coolerBoxModel model.CoolerBox
+		err = e.Orm.Scopes(actions.Permission(coolerBoxModel.TableName(), p)).Where("id =?", v).First(&coolerBoxModel).Error
+		if err != nil {
+			e.Log.Errorf("获取保温箱信息失败: %s", err)
+			return errors.New("获取保温箱信息失败")
+		}
+		iceRaftModel.CoolerBoxName = append(iceRaftModel.CoolerBoxName, coolerBoxModel.Name)
+		iceRaftModel.BindCoolerBox = append(iceRaftModel.BindCoolerBox, coolerBoxModel.Id)
+
+		coolerBoxModel.BindIceRaftId = append(coolerBoxModel.BindIceRaftId, c.Code)
 		coolerBoxModel.BindIceRaftId = cDto.UniqueSlice(coolerBoxModel.BindIceRaftId)
-		err = tx.Model(&coolerBoxModel).Where("id =?", coolerBoxModel.Id).Update("bind_ice_raft_id", coolerBoxModel.BindIceRaftId).Error
+		err = e.Orm.Model(&coolerBoxModel).Where("id =?", coolerBoxModel.Id).Update("bind_ice_raft_id", coolerBoxModel.BindIceRaftId).Error
 		if err != nil {
-			e.Log.Errorf("绑定保温箱失败: %s", err)
-			return errors.New("绑定保温箱失败")
+			e.Log.Errorf("修改保温箱失败: %s", err)
+			return errors.New("修改保温箱失败")
 		}
 	}
+	err = e.Orm.Model(&iceRaftModel).Where("id =?", iceRaftModel.Id).Update("bind_cooler_box", iceRaftModel.BindCoolerBox).Update("cooler_box_name", iceRaftModel.CoolerBoxName).Error
+	if err != nil {
+		e.Log.Errorf("绑定保温箱失败: %s", err)
+		return errors.New("绑定保温箱失败")
+	}
 	return nil
 }
 
@@ -678,12 +763,13 @@ func (e *IceRaft) IsOutStorage(c *dto.IceOutStorageReq, p *actions.DataPermissio
 		var iceRaftRecordModel model.IceRaftRecord
 		err = e.Orm.Scopes(actions.Permission(iceRaftRecordModel.TableName(), p)).
 			Where("code = ?", v).
-			Where("status = ?", model.IceRaftRecordStatusFreezing).
+			Where("status = ?", model.IceRaftRecordStatusFreezing).Where("status != ?", 0).
 			First(&iceRaftRecordModel).Error
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				err = e.Orm.Scopes(actions.Permission(iceRaftRecordModel.TableName(), p)).
 					Where("code = ?", v).
+					Where("status != ?", 0).
 					Where("status = ?", model.IceRaftRecordStatusWaitUse).
 					Or("status=?", model.IceRaftRecordStatusUsing).
 					First(&iceRaftRecordModel).Error
@@ -960,6 +1046,25 @@ func (e *IceRaftRecord) StartForCold(c *dto.IceStartbleForColfTimReq, p *actions
 		if err != nil {
 			return global.GetFailedErr
 		}
+		// 获取冰排记录
+		if iceRaftRecordModel.Status == model.IceRaftRecordReleasedInTheCold || iceRaftRecordModel.Status == model.IceRaftRecordReleasedInTheColdEnd {
+			err = errors.New(fmt.Sprintf("冰排【%s】已释冷!", iceRaftRecordModel.Code))
+			return err
+		}
+
+		inTime := iceRaftRecordModel.InStorageTime.Local()
+		sort.Slice(iceRaftRecordModel.FreezeClaim, func(i, j int) bool {
+			return iceRaftRecordModel.FreezeClaim[i] < iceRaftRecordModel.FreezeClaim[j]
+		})
+		if user.Dept.IsOutStorage {
+			for _, vs := range iceRaftRecordModel.FreezeClaim {
+				if inTime.Add(time.Hour * time.Duration(vs)).After(time.Now()) {
+					str := fmt.Sprintf("冰排【%s】未达到冷冻时长【%v】,禁止出库", iceRaftRecordModel.Code, vs)
+					err = errors.New(str)
+					return err
+				}
+			}
+		}
 		iceRaftRecordModel.StartIceColdTime = model2.Time(time.Now())
 		iceRaftRecordModel.Status = model.IceRaftRecordReleasedInTheCold //释冷中
 		iceRaftRecordModel.IceColdUsers = user.NickName

+ 6 - 0
app/admin/service/waybill.go

@@ -1010,6 +1010,12 @@ func (e *Waybill) Receipt(c *dto.WaybillReceiptReq, p *actions.DataPermission) e
 		err = errors.New(fmt.Sprintf("运单状态为%s,禁止操作", model.WaybillStatusMap[waybillModel.Status]))
 		return err
 	}
+	//更新保温箱状态为默认状态  0
+	err = tx.Model(&model.CoolerBox{}).Where("id =?", coolerBox.Id).Update("use_status", 0).Error
+	if err != nil {
+		e.Log.Errorf("更新保温箱状态失败: %s", err)
+		return errors.New("更新保温箱状态失败")
+	}
 
 	if waybillModel.Status == model.WaybillStatusReceipts || waybillModel.Status == model.WaybillStatusRejections {
 		return nil

+ 90 - 3
app/jobs/jobs.go

@@ -19,6 +19,8 @@ func InitJob() {
 		//"ExamplesOne":     ExamplesOne{},
 		"CountIceRaftRecordFreezeDuration": CountIceRaftRecordFreezeDuration{},
 		"UpdateCoolerBoxMonitorStatus":     UpdateCoolerBoxMonitorStatus{},
+		"CountIceRaftRecordForColdNow":     CountIceRaftRecordForColdNow{},
+		"CountCoolerBoxForColdNow":         CountCoolerBoxForColdNow{},
 		// ...
 	}
 }
@@ -46,15 +48,23 @@ func (t ExamplesOne) Exec(arg interface{}) error {
 	return nil
 }
 
-// 统计冰排冷冻时长
+// CountIceRaftRecordFreezeDuration 统计冰排冷冻时长
 type CountIceRaftRecordFreezeDuration struct {
 }
 
-// 更新保温箱监控状态
+// UpdateCoolerBoxMonitorStatus 更新保温箱监控状态
 type UpdateCoolerBoxMonitorStatus struct {
 }
 
-// 统计冰排冷冻时长
+// CountIceRaftRecordForColdNow 统计冰排释冷时长
+type CountIceRaftRecordForColdNow struct {
+}
+
+// CountCoolerBoxForColdNow 统计保温箱遇冷时长
+type CountCoolerBoxForColdNow struct {
+}
+
+// Exec 统计冰排冷冻时长
 func (t CountIceRaftRecordFreezeDuration) Exec(arg interface{}) error {
 
 	iceRaftRecordList := make([]sysModel.IceRaftRecord, 0)
@@ -124,3 +134,80 @@ func (t UpdateCoolerBoxMonitorStatus) Exec(arg interface{}) error {
 	}
 	return nil
 }
+
+// Exec 统计冰排释冷时长
+func (t CountIceRaftRecordForColdNow) Exec(arg interface{}) error {
+
+	iceRaftRecordList := make([]sysModel.IceRaftRecord, 0)
+	// GetOrm 获取orm连接
+	orm, _ := db.GetOrm(&gin.Context{})
+
+	err := orm.Where("status = ? or status = ?", sysModel.IceRaftRecordReleasedInTheCold, sysModel.IceRaftRecordReleasedInTheColdEnd).
+		Find(&iceRaftRecordList).Error
+	if err != nil {
+		log.Errorf("db error: %s", err)
+		return global.GetFailedErr
+	}
+	//冰排释冷时长
+	for _, record := range iceRaftRecordList {
+		inTime := record.StartIceColdTime.Local()
+		//if inTime.Add(time.Hour * time.Duration(record.FreezeClaim)).After(time.Now()) {
+		if inTime.Add(time.Duration(time.Hour * time.Duration(record.ForColdTime))).After(time.Now()) {
+			// 未达到冷冻时长 不修改状态 只修改时间
+			record.ForColdTimeActual = float64(int(time.Now().Sub(inTime).Minutes()))
+		} else {
+			record.ForColdTimeActual = float64(int(time.Now().Sub(inTime).Minutes()))
+			record.Status = sysModel.IceRaftRecordReleasedInTheColdEnd
+		}
+		if err := orm.Save(&record).Error; err != nil {
+			log.Errorf("db error: %s", err)
+			return global.UpdateFailedErr
+		}
+
+	}
+	return nil
+}
+func (t CountCoolerBoxForColdNow) Exec(arg interface{}) error {
+	CoolerBoxListRecord := make([]sysModel.CoolerBoxRecord, 0)
+	// GetOrm 获取orm连接
+	orm, _ := db.GetOrm(&gin.Context{})
+
+	err := orm.Where("status = ?", 1).
+		Find(&CoolerBoxListRecord).Error
+	if err != nil {
+		log.Errorf("db error: %s", err)
+		return global.GetFailedErr
+	}
+	//冰排释冷时长
+	for _, record := range CoolerBoxListRecord {
+		inTime := record.CoolerBoxStarTime.String()
+		if len(inTime) != 0 {
+			var coolerBox sysModel.CoolerBox
+			var sprintf string
+			err := orm.Where("id = ?", record.CoolerBoxId).First(&coolerBox).Error
+			if err != nil {
+				log.Errorf("db error: %s", err)
+				return global.GetFailedErr
+			}
+			sub := time.Now().Sub(record.CoolerBoxStarTime.Local())
+			hours := int(sub.Hours())
+			minutes := int(sub.Minutes()) % 60
+			sprintf = fmt.Sprintf("%dh%dm\n", hours, minutes)
+			if record.CoolerBoxStarTime.Local().Add(time.Duration(time.Hour * time.Duration(coolerBox.ForColdCoolerTime))).After(time.Now()) {
+				// 未达到冷冻时长 不修改状态 只修改时间
+				record.ForColdDuration = sprintf
+			} else {
+				record.ForColdDuration = sprintf
+				coolerBox.UseStatus = 3 //遇冷结束
+			}
+			err = orm.Save(&coolerBox).Error
+			err = orm.Save(&record).Error
+			if err := orm.Save(&record).Error; err != nil {
+				log.Errorf("db error: %s", err)
+				return global.UpdateFailedErr
+			}
+
+		}
+	}
+	return nil
+}

+ 22 - 0
common/dto/uniqueSlice.go

@@ -13,3 +13,25 @@ func UniqueSlice(slice []string) []string {
 
 	return result
 }
+func UniqueSliceInt(slice []int) []int {
+	seen := make(map[int]struct{}) // 使用空结构体节省内存
+	result := []int{}
+
+	for _, value := range slice {
+		if _, ok := seen[value]; !ok {
+			seen[value] = struct{}{}
+			result = append(result, value)
+		}
+	}
+
+	return result
+}
+func RemoveValue(slice []string, value string) []string {
+	result := []string{}
+	for _, v := range slice {
+		if v != value {
+			result = append(result, v)
+		}
+	}
+	return result
+}

+ 8 - 8
common/lib/lib.go

@@ -3,13 +3,14 @@ package lib
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/nats-io/nats.go"
 	"math/rand"
 	"os"
 	"path/filepath"
 	"runtime"
 	"sync"
 
+	"github.com/nats-io/nats.go"
+
 	"sort"
 	"strconv"
 	"strings"
@@ -472,15 +473,14 @@ func FindStrListExtraData(data1, data2 []string) []string {
 }
 
 func StrListEqual(slice1, slice2 []string) bool {
-	if len(slice1) != len(slice2) {
-		return false
+	m := make(map[string]bool)
+	for _, v := range slice1 {
+		m[v] = true
 	}
-
-	for i := range slice1 {
-		if slice1[i] != slice2[i] {
+	for _, v := range slice2 {
+		if !m[v] {
 			return false
 		}
 	}
-
 	return true
-}
+}

+ 21 - 0
common/model/byat.go

@@ -101,7 +101,28 @@ func (t *Time) Scan(v interface{}) error {
 
 type StringList []string
 type FloatList []float64
+type IntList []int
 
+func (f *IntList) Scan(value interface{}) error {
+	if value == nil {
+		return nil
+	}
+
+	switch v := value.(type) {
+	case string:
+		return json.Unmarshal([]byte(v), f)
+	case []byte:
+		return json.Unmarshal(v, f)
+	case int:
+		*f = IntList{v}
+		return nil
+	default:
+		return errors.New("cannot unmarshal type into FloatList")
+	}
+}
+func (f IntList) Value() (driver.Value, error) {
+	return json.Marshal(f)
+}
 func (f *FloatList) Scan(value interface{}) error {
 	if value == nil {
 		return nil