fix

zhangqian

2023-12-01 8324f872ef3a4d0c978a9b1d062800c6a1701c12

 service/cache_store.go

@@ -1,10 +1,14 @@
package service

import (
   "apsClient/conf"
   "apsClient/constvar"
   "apsClient/model"
   "apsClient/model/response"
   "fmt"
   "github.com/jinzhu/gorm"
   "github.com/spf13/cast"
   "sync"
   "time"
)

type CacheStore struct {
@@ -44,45 +48,103 @@
}

const (
   PlcCacheKey             = "plc:%v"
   CurrentTaskCacheKey     = "current_task"
   CurrentProgressCacheKey = "current_progress"
   PlcCacheKey             = "plc:%v:%v:%v"                    //plc:deviceID:channel:key 缓存加工数或目标数
   CurrentTaskCacheKey     = "current_task:%v:%v"              //current_task:deviceID:channel 缓存当前任务id
   CurrentProgressCacheKey = "current_progress:%v:%v"          //current_progress:deviceId:channel
   PlcCacheKeyUpdateTime   = "finish_number_update_time:%v:%v" //finish_number_update_time:deviceID:channel
   TaskStartTimeCache      = "task_start_time:%v:%v"           //task_start_time:deviceID:channel
   TaskEndTimeCache        = "task_end_time:%v:%v"             //task_end_time:deviceID:channel
)

func PlcCacheGet(key string) (interface{}, bool) {
   return defaultCacheStore.Get(fmt.Sprintf(PlcCacheKey, key))
func PlcCacheGet(deviceId string, channel int32, key string) (interface{}, bool) {
   return defaultCacheStore.Get(fmt.Sprintf(PlcCacheKey, deviceId, channel, key))
}

func PlcCacheSet(key string, value interface{}) {
   defaultCacheStore.Add(fmt.Sprintf(PlcCacheKey, key), value)
}

func TaskCacheSet(value *response.TaskData) {
   defaultCacheStore.Add(CurrentTaskCacheKey, value)
}

func TaskCacheUnset() {
   defaultCacheStore.Remove(CurrentTaskCacheKey)
}

func TaskCacheGet() (*response.TaskData, bool) {
   if v, ok := defaultCacheStore.Get(CurrentTaskCacheKey); ok {
      return v.(*response.TaskData), ok
func PlcCacheSet(deviceId string, channel int32, key string, value interface{}) {
   if key == constvar.PlcCacheKeyFinishNumber {
      oldFinishNumber, exists := PlcCacheGet(deviceId, channel, key)
      if !exists || cast.ToInt(oldFinishNumber) != cast.ToInt(value) { //finishNumber有了变化，设置更新时间缓存
         FinishUpdateTimeSet(deviceId, channel, time.Now().Unix())
      }
   }
   return nil, false
   defaultCacheStore.Add(fmt.Sprintf(PlcCacheKey, deviceId, channel, key), value)
}

func ProgressCacheGet() (*model.ProductionProgress, bool) {
   if v, ok := defaultCacheStore.Get(CurrentProgressCacheKey); ok {
      return v.(*model.ProductionProgress), ok
// FinishUpdateTimeGet 用于判断plc状态，超过多少时间未更新视为待机
func FinishUpdateTimeGet(deviceId string, channel int32) interface{} {
   val, ok := defaultCacheStore.Get(fmt.Sprintf(PlcCacheKeyUpdateTime, deviceId, channel))
   if ok {
      return val
   }
   return nil, false
   return 0
}

func ProgressCacheSet(value *model.ProductionProgress) {
   defaultCacheStore.Add(CurrentProgressCacheKey, value)
func FinishUpdateTimeSet(deviceId string, channel int32, value interface{}) {
   defaultCacheStore.Add(fmt.Sprintf(PlcCacheKeyUpdateTime, deviceId, channel), value)
}

func ProgressCacheUnset() {
   defaultCacheStore.Remove(CurrentProgressCacheKey)
func TaskStartTimeSet(deviceID string, channel int32, ts int64) {
   defaultCacheStore.Add(fmt.Sprintf(TaskStartTimeCache, deviceID, channel), ts)
}

// TaskStartTimeGet 用于前端展示工序运行时间
func TaskStartTimeGet(deviceId string, channel int32) int64 {
   if v, ok := defaultCacheStore.Get(fmt.Sprintf(TaskStartTimeCache, deviceId, channel)); ok {
      return v.(int64)
   }
   procedure, err := model.NewProceduresSearch(nil).SetDeviceId(conf.Conf.CurrentDeviceID).SetStatus(model.ProcedureStatusProcessing).SetChannels([]int32{channel}).First() //进行中任务
   if err == gorm.ErrRecordNotFound {
      procedure, err = model.NewProceduresSearch(nil).SetDeviceId(conf.Conf.CurrentDeviceID).
         SetStatus(model.ProcedureStatusFinished).SetChannels([]int32{channel}).SetOrder("real_end_time desc").First() //上一个结束的任务
      if err == gorm.ErrRecordNotFound { //进行中和结束的都没有，开始时间和结束时间都设置0
         TaskStartTimeSet(deviceId, channel, int64(0))
         TaskEndTimeSet(deviceId, channel, int64(0))
         return 0
      } else {
         TaskStartTimeSet(deviceId, channel, procedure.RealStartTime)
         TaskEndTimeSet(deviceId, channel, procedure.RealEndTime)
         return 0
      }
   } else {
      TaskStartTimeSet(deviceId, channel, procedure.RealStartTime)
      TaskEndTimeSet(deviceId, channel, int64(0))
      return procedure.RealStartTime
   }
}

func TaskEndTimeSet(deviceID string, channel int32, ts int64) {
   defaultCacheStore.Add(fmt.Sprintf(TaskEndTimeCache, deviceID, channel), ts)
}

func TaskEndTimeGet(deviceID string, channel int32) int64 {
   if v, ok := defaultCacheStore.Get(fmt.Sprintf(TaskEndTimeCache, deviceID, channel)); ok {
      return v.(int64)
   }
   return 0
}

func TaskFlagSet(deviceID string, channel int32, taskId int) {
   defaultCacheStore.Add(fmt.Sprintf(CurrentTaskCacheKey, deviceID, channel), taskId)
}

func TaskFlagUnset(deviceID string, channel int32) {
   defaultCacheStore.Add(fmt.Sprintf(CurrentTaskCacheKey, deviceID, channel), 0)
}

func TaskFlagGet(deviceID string, channel int32) bool {
   if v, ok := defaultCacheStore.Get(fmt.Sprintf(CurrentTaskCacheKey, deviceID, channel)); ok {
      return v.(int) > 0
   }
   procedure, err := model.NewProceduresSearch(nil).SetDeviceId(conf.Conf.CurrentDeviceID).SetStatus(model.ProcedureStatusProcessing).SetChannels([]int32{channel}).First()
   if err == gorm.ErrRecordNotFound {
      defaultCacheStore.Add(fmt.Sprintf(CurrentTaskCacheKey, deviceID, channel), 0)
      return false
   } else {
      defaultCacheStore.Add(fmt.Sprintf(CurrentTaskCacheKey, deviceID, channel), int(procedure.ID))
      return true
   }
}

func ProgressCacheUnset(deviceID string, channel int32) {
   defaultCacheStore.Remove(fmt.Sprintf(CurrentProgressCacheKey, deviceID, channel))
}