按通道号和查询类型查询任务列表

zhangqian

2023-10-30 f5eb41782ed6584664b797df820423f63490d4d3

按通道号和查询类型查询任务列表

 api/v1/task.go

@@ -414,3 +414,74 @@
    logx.Info("----------------下发工艺参数完毕-----------------")
    return nil
}

// TaskListByChannel
// @Tags      Task
// @Summary   获取任务列表2
// @Produce   application/json
// @Param     object  query    request.SimpleTaskList true  "查询参数"
// @Success   200   {object}  contextx.Response{data=map[int32]response.taskResponse}  "成功"
// @Router    /v1/task/listByChannel [get]
func (slf *TaskApi) TaskListByChannel(c *gin.Context) {
    var params request.TaskListByChannel
    ctx, ok := contextx.NewContext(c, &params)
    if !ok {
        return
    }

    channelAmount, err := service.NewDevicePlcService().GetDeviceChannelAmount()
    if err != nil {
        ctx.FailWithMsg(ecode.NeedConfirmedErr, err.Error())
        return
    }

    dataMap := make(map[int32]*response.TaskResponse, channelAmount)
    if params.Channel != nil {
        taskResponse, err := getTaskResponseByChannel(params, *params.Channel)
        if err != nil {
            ctx.FailWithMsg(ecode.DBErr, err.Error())
            return
        }
        dataMap[*params.Channel] = taskResponse
        ctx.OkWithDetailed(dataMap)
        return
    }

    //不传channel取所有channel的
    var wg sync.WaitGroup
    var mu sync.Mutex
    for i := 0; i < channelAmount; i++ {
        wg.Add(1)
        go func(channel int32) {
            defer wg.Done()
            taskResponse, err := getTaskResponseByChannel(params, channel)
            if err != nil {
                ctx.FailWithMsg(ecode.DBErr, err.Error())
                return
            }
            mu.Lock()
            defer mu.Unlock()
            dataMap[channel] = taskResponse
        }(int32(i))
    }
    wg.Wait()
    ctx.OkWithDetailed(dataMap)
}

func getTaskResponseByChannel(params request.TaskListByChannel, channel int32) (taskResponse *response.TaskResponse, err error) {
    taskResponse, err = service.NewTaskService().GetTask2(params.Offset, params.Limit, []int32{channel}, params.Type) //取进行中的或未开始的
    if err != nil {
        return
    }

    nowTs := time.Now().Unix()
    flagMap := make(map[int32]struct{}, 0)
    for _, task := range taskResponse.Tasks {
        if _, ok := flagMap[task.Channel]; !ok && !service.TaskFlagGet(task.Channel) && task.Procedure.StartTime <= nowTs {
            task.CanStarted = true
            flagMap[task.Channel] = struct{}{}
        }
    }
    taskResponse.Prompt = conf.Conf.Prompt
    return
}

 model/procedures.go

@@ -34,11 +34,15 @@
        PageSize     int
        Orm          *gorm.DB
        Preload      bool
        StartTimeMin int64
        StartTimeMax int64
        EndTimeMin   int64
        EndTimeMax   int64
        StatusNot    ProcedureStatus
        ProcedureIds []string
        Channels     []int32
        Offset       int
        Limit        int
    }
)

@@ -81,6 +85,11 @@
    return slf
}

func (slf *ProceduresSearch) SetOffset(offset, limit int) *ProceduresSearch {
    slf.Offset, slf.Limit = offset, limit
    return slf
}

func (slf *ProceduresSearch) SetOrder(order string) *ProceduresSearch {
    slf.Order = order
    return slf
@@ -96,6 +105,11 @@
    return slf
}

func (slf *ProceduresSearch) SetStartTimeMin(ts int64) *ProceduresSearch {
    slf.StartTimeMin = ts
    return slf
}

func (slf *ProceduresSearch) SetStartTimeMax(ts int64) *ProceduresSearch {
    slf.StartTimeMax = ts
    return slf
@@ -103,6 +117,11 @@

func (slf *ProceduresSearch) SetEndTimeMin(ts int64) *ProceduresSearch {
    slf.EndTimeMin = ts
    return slf
}

func (slf *ProceduresSearch) SetEndTimeMax(ts int64) *ProceduresSearch {
    slf.EndTimeMax = ts
    return slf
}

@@ -141,6 +160,11 @@
    return slf
}

func (slf *ProceduresSearch) SetChannel(channel int32) *ProceduresSearch {
    slf.Channel = channel
    return slf
}

func (slf *ProceduresSearch) build() *gorm.DB {
    var db = slf.Orm.Model(&Procedures{})

@@ -168,8 +192,16 @@
        db = db.Where("start_time <= ?", slf.StartTimeMax)
    }

    if slf.StartTimeMin != 0 {
        db = db.Where("start_time >= ?", slf.EndTimeMin)
    }

    if slf.EndTimeMin != 0 {
        db = db.Where("end_time > ?", slf.EndTimeMin)
    }

    if slf.EndTimeMax != 0 {
        db = db.Where("end_time < ?", slf.StartTimeMax)
    }

    if slf.Status != 0 {
@@ -303,6 +335,11 @@
    if slf.PageNum*slf.PageSize > 0 {
        db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
    }

    if slf.Offset*slf.Limit > 0 {
        db = db.Offset(slf.Offset).Limit(slf.Limit)
    }

    if err := db.Find(&records).Error; err != nil {
        return records, total, fmt.Errorf("find records err: %v", err)
    }

 model/request/task.go

@@ -31,3 +31,19 @@
    ProcedureId uint   `json:"procedureId" form:"procedureId" binding:"required"` //当前的工序id
    Number      string `json:"number" form:"number"  binding:"required"`          //当前正在使用的工艺参数编号
}

// TaskListByChannel 按channel返回任务列表请求参数
type TaskListByChannel struct {
    Offset  int       `json:"offset,omitempty"` //默认0
    Limit   int       `json:"limit,omitempty"`  //默认3
    Type    QueryType `json:"type,omitempty"`   //1 未完成 2 今天未完成 3 已完成
    Channel *int32    `json:"channel"`          //通道号。不传取全部的
}

type QueryType int

const (
    QueryTypeUnFinish QueryType = 1
    QueryTypeToday    QueryType = 2
    QueryTypeFinished QueryType = 3
)

 router/index.go

@@ -41,6 +41,7 @@
        taskGroup.POST("sendProcessParams", taskApi.TaskStart)             // 下发工艺参数并开始工序
        taskGroup.POST("updateProcessParams", taskApi.UpdateProcessParams) // 更新工艺参数
        taskGroup.PUT("finish/:id", taskApi.TaskFinish)                    // 完成工序
        taskGroup.PUT("list", taskApi.TaskListByChannel)                   //按通道号查询任务列表           // 简易任务列表
    }

    configApi := new(v1.ConfigApi)

 service/task.go

@@ -5,6 +5,7 @@
    "apsClient/constvar"
    "apsClient/model"
    "apsClient/model/common"
    "apsClient/model/request"
    "apsClient/model/response"
    "apsClient/pkg/ecode"
    "apsClient/pkg/logx"
@@ -29,7 +30,7 @@
    taskResp = &response.TaskResponse{
        Tasks:     taskList,
        TaskCount: count,
        Workers:   slf.WorkerDistinct(workers),
        Workers:   workers,
    }

    var (
@@ -99,8 +100,9 @@
        workers = append(workers, procedure.ProceduresInfo.Workers...)
    }
    taskResp = &response.TaskResponse{
        Tasks:   taskList,
        Workers: slf.WorkerDistinct(workers),
        Tasks:     taskList,
        TaskCount: count,
        Workers:   slf.WorkerDistinct(workers),
    }
    return taskResp, ecode.OK
}
@@ -200,3 +202,84 @@
func (slf TaskService) RemoveTaskStatusSync(ids []uint) (err error) {
    return model.NewTaskStatusSyncSearch(nil).SetIDs(ids).Delete()
}

// GetTask2 获取任务列表2
func (slf TaskService) GetTask2(offset, limit int, channels []int32, queryType request.QueryType) (taskResp *response.TaskResponse, err error) {
    var taskList []*response.TaskData
    var count int64
    var workers []*common.ProcedureWorker

    taskResp = &response.TaskResponse{
        Tasks:     taskList,
        TaskCount: count,
        Workers:   workers,
    }

    var (
        orders       []*model.Order
        procedures   []*model.Procedures
        workOrderIds []string
    )
    search := model.NewProceduresSearch(nil).
        SetDeviceId(conf.Conf.System.DeviceId).
        SetOffset(offset, limit).SetChannels(channels)
    nowTs := time.Now().Unix()
    switch queryType {
    case request.QueryTypeUnFinish:
        search.SetStatusNot(model.ProcedureStatusFinished).SetOrder("status desc, start_time asc")
    case request.QueryTypeToday:
        search.SetStatusNot(model.ProcedureStatusFinished).SetStartTimeMin(nowTs).SetEndTimeMax(nowTs + 86400).SetOrder("status desc, start_time asc")
    case request.QueryTypeFinished:
        search.SetStatus(model.ProcedureStatusFinished).SetOrder("start_time desc")
    }

    procedures, total, err := search.Find()
    if err != nil {
        return taskResp, err
    }

    if err != nil {
        return taskResp, err
    }
    if len(procedures) == 0 {
        return taskResp, nil
    }

    for _, procedure := range procedures {
        workOrderIds = append(workOrderIds, procedure.WorkOrderID)
    }
    orders, err = model.NewOrderSearch(nil).SetWorkOrderIds(workOrderIds).FindNotTotal() //由工序反推工单
    if err != nil {
        return taskResp, err
    }

    orderMap := make(map[string]*model.Order, len(workOrderIds))
    for _, order := range orders {
        orderMap[order.WorkOrderID] = order
    }
    for _, procedure := range procedures {
        taskData := response.TaskData{
            Order:                 orderMap[procedure.WorkOrderID],
            Procedure:             procedure,
            AllProcedures:         procedure.ProceduresInfo.AllProcedureNames,
            CurrentProcedureIndex: 0,
            Channel:               procedure.Channel,
        }
        index := 0
        for _, name := range procedure.ProceduresInfo.AllProcedureNames {
            if name == procedure.ProceduresInfo.ProcedureName {
                break
            }
            index++
        }
        taskData.CurrentProcedureIndex = index
        taskList = append(taskList, &taskData)
        workers = append(workers, procedure.ProceduresInfo.Workers...)
    }
    taskResp = &response.TaskResponse{
        Tasks:     taskList,
        TaskCount: total,
        Workers:   slf.WorkerDistinct(workers),
    }
    return taskResp, err
}