任务获取修改，状态2只返回已开始和已结束的

zhangqian

2023-09-27 b331c9990a0396301e934daffe095f99d62d1c89

 service/cache_store.go

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

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

type CacheStore struct {
@@ -44,45 +46,64 @@
}

const (
   PlcCacheKey             = "plc:%v:%v"
   CurrentTaskCacheKey     = "current_task"
   CurrentProgressCacheKey = "current_progress:%v"
   PlcCacheKey             = "plc:%v:%v"                    //plc:channel:key
   CurrentTaskCacheKey     = "current_task:%v"              //current_task:channel
   CurrentProgressCacheKey = "current_progress:%v"          //current_progress:channel
   PlcCacheKeyUpdateTime   = "finish_number_update_time:%v" //finish_number_update_time:channel
)

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

func PlcCacheSet(position int, key string, value interface{}) {
   defaultCacheStore.Add(fmt.Sprintf(PlcCacheKey, position, 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(channel int32, key string, value interface{}) {
   if key == constvar.PlcCacheKeyFinishNumber {
      oldFinishNumber, exists := PlcCacheGet(channel, key)
      if !exists || cast.ToInt(oldFinishNumber) != cast.ToInt(value) { //finishNumber有了变化，设置更新时间缓存
         FinishUpdateTimeSet(channel, time.Now().Unix())
      }
   }
   return nil, false
   defaultCacheStore.Add(fmt.Sprintf(PlcCacheKey, channel, key), value)
}

func ProgressCacheGet(position int) (*model.ProductionProgress, bool) {
   if v, ok := defaultCacheStore.Get(fmt.Sprintf(CurrentProgressCacheKey, position)); ok {
func FinishUpdateTimeGet(channel int32) interface{} {
   val, ok := defaultCacheStore.Get(fmt.Sprintf(PlcCacheKeyUpdateTime, channel))
   if ok {
      return val
   }
   return 0
}

func FinishUpdateTimeSet(channel int32, value interface{}) {
   defaultCacheStore.Add(fmt.Sprintf(PlcCacheKeyUpdateTime, channel), value)
}

func TaskFlagSet(channel int32) {
   defaultCacheStore.Add(fmt.Sprintf(CurrentTaskCacheKey, channel), struct{}{})
}

func TaskFlagUnset(channel int32) {
   defaultCacheStore.Remove(fmt.Sprintf(CurrentTaskCacheKey, channel))
}

func TaskFlagGet(channel int32) bool {
   if _, ok := defaultCacheStore.Get(fmt.Sprintf(CurrentTaskCacheKey, channel)); ok {
      return true
   }
   return false
}

func ProgressCacheGet(channel int32) (*model.ProductionProgress, bool) {
   if v, ok := defaultCacheStore.Get(fmt.Sprintf(CurrentProgressCacheKey, channel)); ok {
      return v.(*model.ProductionProgress), ok
   }
   return nil, false
}

func ProgressCacheSet(position int, value *model.ProductionProgress) {
   defaultCacheStore.Add(fmt.Sprintf(CurrentProgressCacheKey, position), value)
func ProgressCacheSet(channel int32, value *model.ProductionProgress) {
   defaultCacheStore.Add(fmt.Sprintf(CurrentProgressCacheKey, channel), value)
}

func ProgressCacheUnset(position int) {
   defaultCacheStore.Remove(fmt.Sprintf(CurrentProgressCacheKey, position))
func ProgressCacheUnset(channel int32) {
   defaultCacheStore.Remove(fmt.Sprintf(CurrentProgressCacheKey, channel))
}