Browse Source

1.在入库的那里,冰排编号那里有个下拉菜单,冰排的编号可以选择,2.冰排配套:菜单里面只出现选定保温箱名下的冰排

huangyan 1 month ago
parent
commit
4d4d5ca5e0

+ 68 - 0
app/admin/controller/ice_raft.go

@@ -512,6 +512,74 @@ func (e IceRaftController) BindCoolerBox(c *gin.Context) {
 	e.OK(nil, "绑定成功")
 }
 
+// GetCoolerBoxBindCieRaft 获取保温箱可绑定冰排
+// @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/bindCoolerBox [post]
+// @Security Bearer
+func (e IceRaftController) GetCoolerBoxBindCieRaft(c *gin.Context) {
+	s := service.IceRaft{}
+	req := dto.GetCoolerBoxByIceRaft{}
+	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
+	}
+	//数据权限检查
+	list := make([]string, 0)
+	p := actions.GetPermissionFromContext(c)
+	err = s.GetCoolerBoxBindCieRaft(&req, p, &list)
+	if err != nil {
+		e.Error(500, err, err.Error())
+		return
+	}
+	e.OK(list, "获取成功")
+}
+
+// GetIceRaft 获取未入库冰排
+// @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/bindCoolerBox [post]
+// @Security Bearer
+func (e IceRaftController) GetIceRaft(c *gin.Context) {
+	s := service.IceRaft{}
+	err := e.MakeContext(c).
+		MakeOrm().
+		MakeService(&s.Service).
+		Errors
+	if err != nil {
+		e.Logger.Error(err)
+		e.Error(500, err, err.Error())
+		return
+	}
+	//数据权限检查
+	list := make([]model.IceRaft, 0)
+	p := actions.GetPermissionFromContext(c)
+	err = s.GetCoolerIceRaft(p, &list)
+	if err != nil {
+		e.Error(500, err, err.Error())
+		return
+	}
+	e.OK(list, "获取成功")
+}
+
 // UnBindCoolerBox 冰排解邦
 // @Summary 冰排解邦
 // @Description 冰排解邦

+ 2 - 2
app/admin/model/cooler_box.go

@@ -19,7 +19,7 @@ type CoolerBox struct {
 	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:预冷要求"` //保温箱预冷要求
+	ForColdCoolerTime float64                 `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-监控中
 	ForColdStatus     int                     `json:"forColdStatus" gorm:"default:0;comment:预冷状态"` // 0-未预冷 1-预冷中 2-使用中
@@ -47,7 +47,7 @@ type CoolerBoxRecord struct {
 	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 float32           `json:"for_cold_cooler_time" gorm:"type:decimal(10,2);comment:预冷要求"`
+	ForColdCoolerTime float64           `json:"for_cold_cooler_time" gorm:"type:decimal(10,2);comment:预冷要求"`
 	ForColdDuration   string            `json:"for_cold_duration" gorm:"comment:预冷累计时长"` // 预冷累计时长
 	model2.ControlBy
 	model2.ModelTime

+ 6 - 4
app/admin/model/ice_raft.go

@@ -77,13 +77,13 @@ type IceRaftRecord struct {
 	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:实际适冷时间"` // 适冷时长 单位小时
+	ForColdTimeActual float64          `json:"forColdTimeActual" gorm:"type:decimal(10,0);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:冷冻时长"`                // 冷冻时长 单位分钟
+	FreezeDuration    float64          `json:"freezeDuration" gorm:"type:decimal(10,2);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已适冷
@@ -117,12 +117,12 @@ type IceRaftRecordOmit struct {
 	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"`                                     // 冷冻时长 单位分钟
+	FreezeDuration    float64          `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"`
+	ForColdTimeActual float64          `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:冰排使用操作人员"`      //冰排使用操作人员
@@ -134,6 +134,8 @@ type IceRaftRecordOmit struct {
 	CoolingTime       string           `json:"coolingTime" gorm:"-"`                                //释冷时间
 	IceLocker         IceLockerOmit    `json:"iceLocker" gorm:"->"`
 	CoolerBox         CoolerBoxOmit    `json:"coolerBox" gorm:"->"`
+	model2.ControlBy
+	model2.ModelTime
 }
 
 func (IceRaftRecord) TableName() string {

+ 2 - 1
app/admin/model/sys_dept.go

@@ -28,7 +28,8 @@ type SysDept struct {
 	IsOutStorage        bool      `json:"isOutStorage" gorm:"type:boolean;default:true"`         //是否可以出库  true 需要验证  false 随时出库
 	IceRaftManage       bool      `json:"iceRaftManage" gorm:"type:boolean;default:false"`       //false 全部有  true 只有冰排管理
 	Children            []SysDept `json:"children" gorm:"-"`
-	CompanyAddress      string    `json:"companyAddress"` //公司地址
+	CompanyAddress      string    `json:"companyAddress"`    //公司地址
+	CompanyCoordinate   string    `json:"companyCoordinate"` //坐标地址
 	model2.ControlBy
 	model2.ModelTime
 }

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

@@ -30,6 +30,8 @@ func registerIceRaftRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddle
 		r.POST("/isoutstorage", cont.IsOutStorage)
 		r.POST("/bindCoolerBox", cont.BindCoolerBox)
 		r.POST("/UnbindCoolerBox", cont.UnBindCoolerBox)
+		r.POST("/GetCoolerBoxBindCieRaft", cont.GetCoolerBoxBindCieRaft)
+		r.GET("/GetCoolerIceRaft", cont.GetIceRaft)
 	}
 
 	cont2 := controller.IceRaftRecordController{}

+ 53 - 68
app/admin/service/cooler_box.go

@@ -65,7 +65,7 @@ func (e *CoolerBox) GetPage(c *dto.CoolerBoxGetPageReq, list *[]model.CoolerBox,
 		}
 	}
 
-	for i, _ := range *list {
+	for i := range *list {
 		var dataIce model.IceRaft
 		var dataIces []model.IceRaft
 		err := e.Orm.Model(&dataIce).
@@ -561,8 +561,7 @@ func (e *CoolerBox) GetCoolerBoxIceAll(c *dto.GetCoolerBoxIceAll, list *[]model.
 			actions.Permission(cooler.TableName(), p),
 			CollerStartTimeAndEndTimeScopes(c.StartTime, c.EndTime),
 		).
-			Where("status = ?", 2).
-			Find(&list).Count(count).Error
+			Find(&list).Limit(-1).Offset(-1).Order("cooler_user_time asc").Count(count).Error
 	} else {
 		err = e.Orm.Scopes(
 			cDto.Paginate(c.GetPageSize(), c.GetPageIndex()),
@@ -570,23 +569,9 @@ func (e *CoolerBox) GetCoolerBoxIceAll(c *dto.GetCoolerBoxIceAll, list *[]model.
 			actions.Permission(cooler.TableName(), p),
 			CollerStartTimeAndEndTimeScopes(c.StartTime, c.EndTime),
 		).
-			Where("status = ?", 2).
-			Find(&list).Limit(-1).Offset(-1).Order("cooler_user_time desc").Count(count).
+			Find(&list).Limit(-1).Offset(-1).Order("cooler_user_time asc").Count(count).
 			Count(count).Error
 	}
-	for i, _ := range *list {
-		if (*list)[i].CoolerBoxStarTime.String() != "" && (*list)[i].CoolerUserTime.String() != "" {
-			start, _ := time.Parse("2006-01-02 15:04:05", (*list)[i].CoolerBoxStarTime.String())
-			end, _ := time.Parse("2006-01-02 15:04:05", (*list)[i].CoolerUserTime.String())
-			sub := end.Sub(start)
-			hours := int(sub.Hours())
-			minutes := int(sub.Minutes()) % 60
-			sprintf := fmt.Sprintf("%dh%dm\n", hours, minutes)
-			(*list)[i].ForColdDuration = sprintf
-		} else {
-			(*list)[i].ForColdDuration = ""
-		}
-	}
 	if err != nil {
 		e.Log.Errorf("db error: %s", err)
 		if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -597,40 +582,7 @@ func (e *CoolerBox) GetCoolerBoxIceAll(c *dto.GetCoolerBoxIceAll, list *[]model.
 	return nil
 }
 
-// CoolerBoxStarTime 保温箱开始释冷
-//
-//	func (e *CoolerBox) CoolerBoxStarTime(c *dto.IceStartbleForColfTimReq, p *actions.DataPermission) error {
-//		var err error
-//
-//		tx := e.Orm.Begin()
-//		defer func() {
-//			if err != nil {
-//				tx.Rollback()
-//			} else {
-//				tx.Commit()
-//			}
-//		}()
-//		//查询冰排是否存在
-//		for _, v := range c.Id {
-//			var iceRaftRecordModel model.IceRaftRecord
-//			err = e.Orm.Scopes(actions.Permission(iceRaftRecordModel.TableName(), p)).
-//				First(&iceRaftRecordModel, v).Error
-//			if err != nil {
-//				e.Log.Errorf("db error: %s", err)
-//				if errors.Is(err, gorm.ErrRecordNotFound) {
-//					return global.UpdateNotFoundOrNoPermissionErr
-//				}
-//				return global.UpdateFailedErr
-//			}
-//			iceRaftRecordModel.CoolerBoxStarTime = model2.Time(time.Now())
-//			updates := tx.Where("id = ?", iceRaftRecordModel.Id).Updates(&iceRaftRecordModel)
-//			if err = updates.Error; err != nil {
-//				e.Log.Errorf("db error: %s", err)
-//				return global.UpdateFailedErr
-//			}
-//		}
-//		return nil
-//	}
+// CoolerBoxStarTime 保温箱开始遇冷
 func (e *CoolerBox) CoolerBoxStarTime(c *dto.IceStartbleForColfTimReq, p *actions.DataPermission) error {
 	var err error
 
@@ -666,15 +618,16 @@ func (e *CoolerBox) CoolerBoxStarTime(c *dto.IceStartbleForColfTimReq, p *action
 		cooler.DeptId = p.DeptId
 		cooler.Sn = coolerBox.Sn
 		cooler.Name = coolerBox.Name
+		cooler.ForColdCoolerTime = coolerBox.ForColdCoolerTime
 		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("保温箱已经遇冷,不能重复遇冷")
+		//更新保温箱状态为遇冷中
+		if coolerBox.UseStatus != 0 {
+			e.Log.Errorf("保温箱已经预冷,不能重复预冷: %s", err)
+			return errors.New("保温箱已经预冷,不能重复预冷")
 		}
 		err = tx.Model(&model.CoolerBox{}).Where("id =?", v).Update("use_status", 1).Error
 		if err != nil {
@@ -699,26 +652,58 @@ func (e *CoolerBox) CoolerBoxEndUse(c *dto.IceStartbleForColfTimReq, p *actions.
 	}()
 	//添加保温箱记录
 	for _, v := range c.Id {
-		var cooler model.CoolerBoxRecord
+		var coolerRecord model.CoolerBoxRecord
 		var coolerBox model.CoolerBox
 		err = tx.Model(&model.CoolerBox{}).Where("id = ?", v).First(&coolerBox).Error
 		if err != nil {
 			e.Log.Errorf("获取保温箱信息失败: %s", err)
 			return errors.New("获取保温箱信息失败")
 		}
-		//保温箱使用状态变为结束使用
-		cooler.CoolerEndUseTime = model2.Time(time.Now())
-		cooler.Status = "2"
-		err = tx.Model(&cooler).Where("cooler_box_id = ?", v).Updates(&cooler).Error
+		//if coolerBox.UseStatus != 2 {
+		//	e.Log.Errorf("保温箱未开始使用使用,不能结束使用: %s", err)
+		//	return errors.New("保温箱未开始使用使用,不能结束使用")
+		//}
+		//err := tx.Model(&model.CoolerBoxRecord{}).Where("cooler_box_id = ?", v).Where("status = ?", 1).First(&cooler).Error
+		//if err != nil {
+		//	if errors.Is(err, gorm.ErrRecordNotFound) {
+		//		return errors.New("保温箱未开始使用使用,不能结束使用")
+		//	} else {
+		//		e.Log.Errorf("查询保温箱记录失败: %s", err)
+		//		return errors.New("查询保温箱记录失败")
+		//	}
+		//}
+		err = tx.Model(&model.CoolerBoxRecord{}).Where("cooler_box_id = ?", v).Where("status = ?", 1).First(&coolerRecord).Error
 		if err != nil {
-			e.Log.Errorf("db error: %s", err)
-			return global.CreateFailedErr
+			e.Log.Errorf("获取保温箱记录失败: %s", err)
+			return errors.New("保温箱未开始使用不能结束使用")
 		}
-		//更新保温箱状态为默认状态  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("更新保温箱状态失败")
+		if len(coolerRecord.CoolerUserTime.String()) == 0 {
+			err = tx.Model(&model.CoolerBoxRecord{}).Where("cooler_box_id = ?", v).Where("status = ?", 1).Delete(&coolerRecord).Error
+			if err != nil {
+				e.Log.Errorf("删除保温箱记录失败: %s", err)
+				return errors.New("删除保温箱记录失败")
+			}
+			//更新保温箱信息为默认未使用状态
+			err = tx.Model(&model.CoolerBox{}).Where("id = ?", v).Update("use_status", 0).Error
+			if err != nil {
+				e.Log.Errorf("保温箱状态更新失败: %s", err)
+				return errors.New("保温箱状态更新失败")
+			}
+		} else {
+			//保温箱使用状态变为结束使用
+			coolerRecord.CoolerEndUseTime = model2.Time(time.Now())
+			coolerRecord.Status = "2"
+			err = tx.Model(&coolerRecord).Where("cooler_box_id = ?", v).Updates(&coolerRecord).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

+ 5 - 1
app/admin/service/dto/company.go

@@ -6,7 +6,7 @@ import (
 	common "cold-delivery/common/model"
 )
 
-// SysDeptGetPageReq 列表或者搜索使用结构体
+// CompanyGetPageReq SysDeptGetPageReq 列表或者搜索使用结构体
 type CompanyGetPageReq struct {
 	dto.Pagination `search:"-"`
 	Name           string `form:"name" search:"type:contains;column:name;table:sys_dept" example:"公司名称"` //公司名称
@@ -42,6 +42,7 @@ type CompanyInsertReq struct {
 	IceRaftManage       bool   `json:"iceRaftManage"`                                         //冰排管理
 	CompanyAddress      string `json:"companyAddress"`                                        //公司地址
 	AppName             string `json:"appName"`                                               // app名称
+	CompanyCoordinate   string `json:"companyCoordinate"`                                     //坐标地址
 	common.ControlBy    `swaggerignore:"true"`
 }
 
@@ -59,6 +60,7 @@ func (s *CompanyInsertReq) Generate(model *model.SysDept) {
 	model.IsOutStorage = s.IsOutStorage
 	model.IceRaftManage = s.IceRaftManage
 	model.AppName = s.AppName
+	model.CompanyCoordinate = s.AppName
 }
 
 // GetId 获取数据对应的ID
@@ -78,6 +80,7 @@ type CompanyUpdateReq struct {
 	IceRaftManage       bool   `json:"iceRaftManage"`                                  //冰排管理
 	CompanyAddress      string `json:"companyAddress"`                                 //公司地址
 	AppName             string `json:"appName"`                                        // app名称
+	CompanyCoordinate   string `json:"companyCoordinate"`                              //坐标地址
 	common.ControlBy    `swaggerignore:"true"`
 }
 
@@ -96,6 +99,7 @@ func (s *CompanyUpdateReq) Generate(model *model.SysDept) {
 	model.IsOutStorage = s.IsOutStorage
 	model.IceRaftManage = s.IceRaftManage
 	model.AppName = s.AppName
+	model.CompanyCoordinate = s.CompanyCoordinate
 }
 
 // GetId 获取数据对应的ID

+ 3 - 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 float32  `json:"for_cold_cooler_time" gorm:"comment:预冷要求"` //保温箱预冷要求
+	ForColdCoolerTime float64  `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 float32  `json:"for_cold_cooler_time" gorm:"comment:预冷要求"` //保温箱预冷要求
+	ForColdCoolerTime float64  `json:"for_cold_cooler_time" gorm:"comment:预冷要求"` //保温箱预冷要求
 	common.ControlBy  `swaggerignore:"true"`
 }
 
@@ -155,6 +155,7 @@ type GetCoolerBoxIceAll struct {
 	StartTime      string `form:"startTime" search:"-"`                                                            // 开始时间
 	EndTime        string `form:"endTime" search:"-"`                                                              // 结束时间
 	CoolerBoxId    string `form:"coolerBoxId" search:"type:contains;column:cooler_box_id;table:cooler_box_record"` // 保温箱id
+	Status         string `form:"status" search:"type:contains;column:status;table:cooler_box_record"`             // 状态
 }
 
 func (m *GetCoolerBoxIceAll) GetNeedSearch() interface{} {

+ 4 - 1
app/admin/service/dto/ice_raft.go

@@ -137,6 +137,9 @@ func (s *IceRaftGetReq) GetId() interface{} {
 type IceRaftGetByCodeReq struct {
 	Code string `uri:"code"`
 }
+type GetCoolerBoxByIceRaft struct {
+	Id string `json:"id"`
+}
 
 type IceRaftDeleteReq struct {
 	Id               int `json:"id"`
@@ -156,7 +159,7 @@ type IceRaftInStorageReq struct {
 type IceRaftOutStorageReq struct {
 	Code             []string `json:"code"`
 	CoolerBoxId      int      `json:"coolerBoxId"`     // 保温箱id
-	SuitableForCold  string   `json:"suitableForCold"` // 冰排适冷温度
+	SuitableForCold  int      `json:"suitableForCold"` // 冰排适冷温度
 	common.ControlBy `swaggerignore:"true"`
 }
 type BindCoolerBox struct {

+ 4 - 0
app/admin/service/ice_locker.go

@@ -10,6 +10,7 @@ import (
 	"errors"
 	"gogs.baozhida.cn/zoie/OAuth-core/service"
 	"gorm.io/gorm"
+	"math"
 )
 
 type IceLocker struct {
@@ -365,6 +366,9 @@ func (e *IceLocker) GetIceLocker(c *dto.GetIceLockerReq, list *[]model.IceRaft,
 		}
 		return global.GetFailedErr
 	}
+	for i := range *list {
+		(*list)[i].IceRaftRecord.ForColdTimeActual = math.Floor((*list)[i].IceRaftRecord.ForColdTimeActual)
+	}
 
 	return nil
 }

+ 158 - 67
app/admin/service/ice_raft.go

@@ -8,8 +8,10 @@ import (
 	"cold-delivery/common/global"
 	"cold-delivery/common/lib"
 	model2 "cold-delivery/common/model"
+	"database/sql"
 	"errors"
 	"fmt"
+	"math"
 	"sort"
 	"strings"
 	"time"
@@ -31,7 +33,7 @@ func (e *IceRaft) GetPage(c *dto.IceRaftGetPageReq, list *[]model.IceRaft, count
 		err = e.Orm.Model(&data).
 			Scopes(
 				actions.Permission(data.TableName(), p),
-			).Order("ice_raft.sort desc").
+			).Order("ice_raft.sort asc").
 			Find(list).Limit(-1).Offset(-1).
 			Count(count).Error
 	} else {
@@ -40,7 +42,7 @@ func (e *IceRaft) GetPage(c *dto.IceRaftGetPageReq, list *[]model.IceRaft, count
 				cDto.MakeCondition(c.GetNeedSearch()),
 				cDto.Paginate(c.GetPageSize(), c.GetPageIndex()),
 				actions.Permission(data.TableName(), p),
-			).Order("ice_raft.sort desc").
+			).Order("ice_raft.sort asc").
 			Find(list).Limit(-1).Offset(-1).
 			Count(count).Error
 	}
@@ -155,6 +157,9 @@ func (e *IceRaft) GetRecordPage(c *dto.IceRaftGetNewestRecordPageReq, list *[]mo
 	//		(*list)[i].IceRaftRecord.CoolingTime = sprintf
 	//	}
 	//}
+	for i := range *list {
+		(*list)[i].IceRaftRecord.ForColdTimeActual = math.Floor((*list)[i].IceRaftRecord.ForColdTimeActual)
+	}
 	if err != nil {
 		e.Log.Errorf("db error: %s", err)
 		return global.GetFailedErr
@@ -381,50 +386,60 @@ func (e *IceRaft) InStorage(c *dto.IceRaftInStorageReq, p *actions.DataPermissio
 			err = errors.New(fmt.Sprintf("冰排【%s】状态为%s,入库失败!", code, model.GetIceRaftRecordStatus(iceRaftModel.IceRaftRecord.Status)))
 			return err
 		}
-
-		// 更新冰排记录状态 使用中 -> 已完成
-		err = tx.Model(&model.IceRaftRecord{}).
-			Where("ice_raft_id = ? and status = ?", iceRaftModel.Id, model.IceRaftRecordStatusUsing).
-			Updates(map[string]interface{}{
-				"status":      model.IceRaftRecordStatusFinish,
-				"return_date": model2.Time(time.Now()),
+		if iceRaftModel.IceRaftRecord.Status == model.IceRaftRecordReleasedInTheCold || iceRaftModel.IceRaftRecord.Status == model.IceRaftRecordReleasedInTheColdEnd {
+			err = tx.Model(&model.IceRaftRecord{}).Where("ice_raft_id = ?", iceRaftModel.Id).
+				Where("status = ?", model.IceRaftRecordReleasedInTheCold).
+				Or("status = ?", model.IceRaftRecordReleasedInTheColdEnd).Updates(map[string]interface{}{
+				"status":           model.IceRaftRecordStatusFreezing,
+				"out_storage_time": sql.NullTime{Valid: false},
+				"in_storage_time":  model2.Time(time.Now()),
+				"freeze_duration":  0,
 			}).Error
-
-		// 添加冰排记录
-		var iceRaftRecordModel = model.IceRaftRecord{
-			IceLockerId:   iceLockerModel.Id,
-			IceRaftId:     iceRaftModel.Id,
-			Status:        model.IceRaftRecordStatusFreezing,
-			Label:         iceRaftModel.Label,
-			Code:          code,
-			InStorageTime: model2.Time(time.Now()),
-			Sort:          iceRaftModel.Sort,
-			ForColdTime:   iceRaftModel.ForColdTime,
-			//FreezeClaim:   iceRaftModel.FreezeClaim,
-			DeptBy: model2.DeptBy{
-				DeptId: p.DeptId,
-			},
-		}
-		iceRaftRecordModel.FreezeClaim = append(iceRaftRecordModel.FreezeClaim, iceRaftModel.FreezeClaim...)
-		err = tx.Create(&iceRaftRecordModel).Error
-		if err != nil {
-			e.Log.Errorf("db error: %s", err)
-			return errors.New("添加冰排记录失败")
-		}
-
-		// 更新冰排使用记录
-		err = tx.Model(&iceRaftModel).
-			Where("id = ?", iceRaftModel.Id).
-			Updates(map[string]interface{}{
-				"ice_raft_record_id": iceRaftRecordModel.Id,
-			}).Error
-		if err != nil {
-			e.Log.Errorf("db error: %s", err)
-			return errors.New("关联冰排记录失败")
+			if err != nil {
+				e.Log.Errorf("db 添加冰排记录失败: %s", err)
+				return errors.New("添加冰排记录失败")
+			}
+		} else {
+			// 更新冰排记录状态 使用中 -> 已完成
+			err = tx.Model(&model.IceRaftRecord{}).
+				Where("ice_raft_id = ? and status = ?", iceRaftModel.Id, model.IceRaftRecordStatusUsing).
+				Updates(map[string]interface{}{
+					"status":      model.IceRaftRecordStatusFinish,
+					"return_date": model2.Time(time.Now()),
+				}).Error
+
+			// 添加冰排记录
+			var iceRaftRecordModel = model.IceRaftRecord{
+				IceLockerId:   iceLockerModel.Id,
+				IceRaftId:     iceRaftModel.Id,
+				Status:        model.IceRaftRecordStatusFreezing,
+				Label:         iceRaftModel.Label,
+				Code:          code,
+				InStorageTime: model2.Time(time.Now()),
+				Sort:          iceRaftModel.Sort,
+				ForColdTime:   iceRaftModel.ForColdTime,
+				DeptBy: model2.DeptBy{
+					DeptId: p.DeptId,
+				},
+			}
+			iceRaftRecordModel.FreezeClaim = append(iceRaftRecordModel.FreezeClaim, iceRaftModel.FreezeClaim...)
+			err = tx.Create(&iceRaftRecordModel).Error
+			if err != nil {
+				e.Log.Errorf("db error: %s", err)
+				return errors.New("添加冰排记录失败")
+			}
+			// 更新冰排使用记录
+			err = tx.Model(&iceRaftModel).
+				Where("id = ?", iceRaftModel.Id).
+				Updates(map[string]interface{}{
+					"ice_raft_record_id": iceRaftRecordModel.Id,
+				}).Error
+			if err != nil {
+				e.Log.Errorf("db error: %s", err)
+				return errors.New("关联冰排记录失败")
+			}
 		}
-
 	}
-
 	return nil
 }
 func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermission) error {
@@ -472,7 +487,7 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 			First(&iceRaftModel).Error
 		if err != nil {
 			e.Log.Errorf("db error: %s", err)
-			return errors.New("获取冰排信息失败")
+			return errors.New("获取冰排信息失败,请检查该冰排是否存在")
 		}
 
 		if iceRaftModel.Status != model.IceRaftStatusNormal {
@@ -513,18 +528,8 @@ 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]
 		})
-		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()) {
+
+		if inTime.Add(time.Duration(iceRaftRecordModel.FreezeClaim[0] * float64(time.Hour))).After(time.Now()) {
 			str := fmt.Sprintf("冰排【%s】未达到冷冻时长【%v】,禁止出库", code, iceRaftRecordModel.FreezeClaim[0])
 			err = errors.New(str)
 			return err
@@ -532,9 +537,9 @@ func (e *IceRaft) OutStorage(c *dto.IceRaftOutStorageReq, p *actions.DataPermiss
 		//判断冰排释冷要求是否为0,如果不为零,则判断是否达到释冷时长,否则不允许出库
 		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))
+				start := iceRaftRecordModel.StartIceColdTime.Local()
+				if start.Add(time.Duration(iceRaftModel.ForColdTime * float64(time.Hour))).After(time.Now()) {
+					err = errors.New(fmt.Sprintf("冰排【%s】未达到释冷时长【%v】小时,禁止出库", code, iceRaftModel.ForColdTime))
 					return err
 				}
 			} else {
@@ -603,9 +608,9 @@ 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.Hour * time.Duration(coolerBoxModel.ForColdCoolerTime)).After(time.Now()) {
-			err = errors.New(fmt.Sprintf("保温箱未达到释冷时长【%v】分钟,禁止装箱", coolerBoxModel.ForColdCoolerTime))
+		start := coolerBoxRecordModel.CoolerBoxStarTime.Local()
+		if start.Add(time.Duration(coolerBoxModel.ForColdCoolerTime * float64(time.Hour))).After(time.Now()) {
+			err = errors.New(fmt.Sprintf("保温箱未达到预冷时长【%v】小时,禁止装箱", coolerBoxModel.ForColdCoolerTime))
 			return err
 		}
 	}
@@ -688,6 +693,87 @@ func (e *IceRaft) BindCookerBox(c *dto.BindCoolerBox, p *actions.DataPermission)
 	}
 	return nil
 }
+
+// GetCoolerBoxBindCieRaft 获取保温箱可绑定冰排
+func (e *IceRaft) GetCoolerBoxBindCieRaft(c *dto.GetCoolerBoxByIceRaft, p *actions.DataPermission, list *[]string) error {
+	var err error
+
+	tx := e.Orm.Begin()
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+		} else {
+			tx.Commit()
+		}
+	}()
+	// 查询保温箱信息
+	var coolerBoxModel model.CoolerBox
+	err = e.Orm.Scopes(actions.Permission(coolerBoxModel.TableName(), p)).Where("id =?", c.Id).
+		First(&coolerBoxModel).Error
+	if err != nil {
+		e.Log.Errorf("db error: %s", err)
+		return errors.New("获取保温箱信息失败")
+	}
+	if coolerBoxModel.Status != model.CoolerBoxStatusNormal {
+		err = errors.New("保温箱状态不可用")
+		return err
+	}
+	if len(coolerBoxModel.BindIceRaftId) > 0 {
+		for _, code := range coolerBoxModel.BindIceRaftId {
+			// 查询冰排是否存在
+			var iceRaftModel model.IceRaftRecord
+			err = e.Orm.Scopes(actions.Permission(iceRaftModel.TableName(), p)).
+				Where("code = ?", code).Where("status = ?", model.IceRaftRecordStatusWaitUse).
+				First(&iceRaftModel).Error
+			if err != nil {
+				if errors.Is(gorm.ErrRecordNotFound, err) {
+					return nil
+				}
+				e.Log.Errorf("获取冰排信息失败: %s", err)
+				return errors.New("获取冰排信息失败")
+			}
+			*list = append(*list, iceRaftModel.Code)
+		}
+	} else {
+		var iceRaftModel []model.IceRaftRecord
+		err = e.Orm.Scopes(actions.Permission(model.IceRaftRecord{}.TableName(), p)).
+			Where("status = ?", model.IceRaftRecordStatusWaitUse).Find(&iceRaftModel).Error
+		if err != nil {
+			e.Log.Errorf("获取冰排信息失败: %s", err)
+			return errors.New("获取冰排信息失败")
+		}
+		for _, v := range iceRaftModel {
+			*list = append(*list, v.Code)
+		}
+	}
+
+	return nil
+}
+func (e *IceRaft) GetCoolerIceRaft(p *actions.DataPermission, list *[]model.IceRaft) error {
+	var err error
+
+	tx := e.Orm.Begin()
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+		} else {
+			tx.Commit()
+		}
+	}()
+	// 查询保温箱信息
+	var data model.IceRaft
+	err = e.Orm.Model(&data).
+		Scopes(
+			actions.Permission(data.TableName(), p)).
+		Where("ice_raft.status = '2'").
+		Joins("left join ice_raft_record on ice_raft.ice_raft_record_id = ice_raft_record.id").
+		Where("ice_raft_record.`status` IS NULL").
+		Preload("IceRaftRecord.IceLocker").
+		Preload("IceRaftRecord.CoolerBox").
+		Preload("IceRaftRecord").
+		Find(list).Limit(-1).Offset(-1).Error
+	return nil
+}
 func (e *IceRaft) UnBindCookerBox(c *dto.UnBindCoolerBox, p *actions.DataPermission) error {
 	var err error
 
@@ -757,7 +843,7 @@ func (e *IceRaft) IsOutStorage(c *dto.IceOutStorageReq, p *actions.DataPermissio
 	var str string
 	msg := make([]string, 0)
 	sussce := make([]string, 0)
-	FreezeDuration := make([]int, 0)
+	FreezeDuration := make([]float64, 0)
 	// 获取冰排记录
 	for _, v := range c.Code {
 		var iceRaftRecordModel model.IceRaftRecord
@@ -772,6 +858,7 @@ func (e *IceRaft) IsOutStorage(c *dto.IceOutStorageReq, p *actions.DataPermissio
 					Where("status != ?", 0).
 					Where("status = ?", model.IceRaftRecordStatusWaitUse).
 					Or("status=?", model.IceRaftRecordStatusUsing).
+					Or("status=?", model.IceRaftRecordReleasedInTheColdEnd).
 					First(&iceRaftRecordModel).Error
 				if err != nil {
 					e.Log.Errorf("db error: %s", err)
@@ -798,9 +885,9 @@ func (e *IceRaft) IsOutStorage(c *dto.IceOutStorageReq, p *actions.DataPermissio
 			return iceRaftRecordModel.FreezeClaim[i] < iceRaftRecordModel.FreezeClaim[j]
 		})
 		for _, vs := range iceRaftRecordModel.FreezeClaim {
-			if inTime.Add(time.Hour * time.Duration(vs)).After(time.Now()) {
+			if inTime.Add(time.Duration(vs * float64(time.Hour))).After(time.Now()) {
 				hour := iceRaftRecordModel.FreezeDuration / 60
-				minutes := iceRaftRecordModel.FreezeDuration % 60
+				minutes := int(iceRaftRecordModel.FreezeDuration) % 60
 				str = fmt.Sprintf("冰排编号【%s】未达到冷冻时长【%v】小时,已达到冷冻时长【%v】小时【%v】分钟,是否继续出库", v, vs, hour, minutes)
 				sussce = append(sussce, v)
 				FreezeDuration = append(FreezeDuration, iceRaftRecordModel.FreezeDuration)
@@ -814,7 +901,7 @@ func (e *IceRaft) IsOutStorage(c *dto.IceOutStorageReq, p *actions.DataPermissio
 		sort.Slice(FreezeDuration, func(i, j int) bool {
 			return FreezeDuration[i] < FreezeDuration[j]
 		})
-		str = fmt.Sprintf("冰排%v未达到冷冻要求,已达到冷冻时长【%v】小时【%v】分钟", sussce, FreezeDuration[0]/60, FreezeDuration[0]%60)
+		str = fmt.Sprintf("冰排%v未达到冷冻要求,已达到冷冻时长【%v】小时【%v】分钟", sussce, FreezeDuration[0]/60, int(FreezeDuration[0])%60)
 	}
 	return nil, str
 }
@@ -941,7 +1028,7 @@ func (e *IceRaftRecord) Remove(c *dto.IceRaftRecordDeleteReq, p *actions.DataPer
 		return global.DeleteFailedErr
 	}
 
-	db := tx.Delete(&iceRaftRecordModel)
+	db := tx.Unscoped().Delete(&iceRaftRecordModel)
 
 	if err = db.Error; err != nil {
 		e.Log.Errorf("db error: %s", err)
@@ -1051,6 +1138,10 @@ func (e *IceRaftRecord) StartForCold(c *dto.IceStartbleForColfTimReq, p *actions
 			err = errors.New(fmt.Sprintf("冰排【%s】已释冷!", iceRaftRecordModel.Code))
 			return err
 		}
+		if iceRaftRecordModel.Status != model.IceRaftRecordStatusWaitUse {
+			err = errors.New(fmt.Sprintf("冰排【%s】状态为【%v】不可释冷!", iceRaftRecordModel.Code, model.GetIceRaftRecordStatus(iceRaftRecordModel.Status)))
+			return err
+		}
 
 		inTime := iceRaftRecordModel.InStorageTime.Local()
 		sort.Slice(iceRaftRecordModel.FreezeClaim, func(i, j int) bool {

+ 42 - 31
app/jobs/jobs.go

@@ -5,6 +5,7 @@ import (
 	"cold-delivery/common/global"
 	"cold-delivery/common/nats/nats_server"
 	"cold-delivery/db"
+	"errors"
 	"fmt"
 	"github.com/gin-gonic/gin"
 	log "gogs.baozhida.cn/zoie/OAuth-core/logger"
@@ -84,11 +85,11 @@ func (t CountIceRaftRecordFreezeDuration) Exec(arg interface{}) error {
 		})
 		inTime := record.InStorageTime.Local()
 		//if inTime.Add(time.Hour * time.Duration(record.FreezeClaim)).After(time.Now()) {
-		if inTime.Add(time.Duration(time.Hour * time.Duration(record.FreezeClaim[0]))).After(time.Now()) {
+		if inTime.Add(time.Duration(record.FreezeClaim[0] * float64(time.Hour))).After(time.Now()) {
 			// 未达到冷冻时长 不修改状态 只修改时间
-			record.FreezeDuration = int(time.Now().Sub(inTime).Minutes())
+			record.FreezeDuration = float64(int(time.Now().Sub(inTime).Minutes()))
 		} else {
-			record.FreezeDuration = int(time.Now().Sub(inTime).Minutes())
+			record.FreezeDuration = float64(int(time.Now().Sub(inTime).Minutes()))
 			record.Status = sysModel.IceRaftRecordStatusWaitUse
 		}
 
@@ -137,36 +138,44 @@ func (t UpdateCoolerBoxMonitorStatus) Exec(arg interface{}) error {
 
 // 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).
+	var iceRaftRecordList []sysModel.IceRaftRecord
+
+	err := orm.Where("status = ?", sysModel.IceRaftRecordReleasedInTheCold).
+		Or("status = ?", sysModel.IceRaftRecordReleasedInTheColdEnd).
 		Find(&iceRaftRecordList).Error
 	if err != nil {
-		log.Errorf("db error: %s", err)
-		return global.GetFailedErr
+		log.Errorf("db 查询冰排记录失败: %s", err)
+		return errors.New("查询冰排记录失败")
 	}
 	//冰排释冷时长
 	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()) {
+		var iceRaft sysModel.IceRaft
+		err = orm.Where("id = ?", record.IceRaftId).First(&iceRaft).Error
+		if err != nil {
+			log.Errorf("冰排不存在: %s", err)
+			//return errors.New("查询冰排失败")
+		}
+		if inTime.Add(time.Duration(iceRaft.ForColdTime * float64(time.Hour))).After(time.Now()) {
 			// 未达到冷冻时长 不修改状态 只修改时间
-			record.ForColdTimeActual = float64(int(time.Now().Sub(inTime).Minutes()))
+			record.ForColdTimeActual = time.Now().Sub(inTime).Minutes()
 		} else {
-			record.ForColdTimeActual = float64(int(time.Now().Sub(inTime).Minutes()))
+			record.ForColdTimeActual = time.Now().Sub(inTime).Minutes()
 			record.Status = sysModel.IceRaftRecordReleasedInTheColdEnd
 		}
-		if err := orm.Save(&record).Error; err != nil {
-			log.Errorf("db error: %s", err)
+		if err = orm.Save(&record).Error; err != nil {
+			log.Errorf("更新冰排释冷时间失败: %s", err)
+			fmt.Println("===================================更新冰排释冷时间失败===================================", err)
 			return global.UpdateFailedErr
 		}
-
 	}
 	return nil
 }
+
+// Exec 统计保温箱遇冷时长
 func (t CountCoolerBoxForColdNow) Exec(arg interface{}) error {
 	CoolerBoxListRecord := make([]sysModel.CoolerBoxRecord, 0)
 	// GetOrm 获取orm连接
@@ -189,22 +198,24 @@ func (t CountCoolerBoxForColdNow) Exec(arg interface{}) error {
 				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
+			if (coolerBox.UseStatus == 1 || coolerBox.UseStatus == 3) && len(record.CoolerUserTime.String()) == 0 {
+				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(coolerBox.ForColdCoolerTime * float64(time.Hour))).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
+				}
 			}
 
 		}