存储全部设备的工序和订单&代码优化

zhangqian

2023-09-02 001d1f605c0a275a139f5c8fa66e631eb998e3b9

存储全部设备的工序和订单&代码优化

 api/v1/task.go

@@ -1,12 +1,9 @@
package v1

import (
    "apsClient/conf"
    "apsClient/constvar"
    "apsClient/model"
    "apsClient/model/common"
    "apsClient/model/response"
    "apsClient/nsq"
    "apsClient/pkg/contextx"
    "apsClient/pkg/convertx"
    "apsClient/pkg/ecode"
@@ -14,7 +11,6 @@
    "apsClient/pkg/plc"
    "apsClient/service"
    "apsClient/service/plc_address"
    "encoding/json"
    "errors"
    "fmt"
    "github.com/gin-gonic/gin"
@@ -96,60 +92,21 @@
        return
    }

    paramsMap := make(map[string]interface{})
    var paramsNumber string
    data, err := model.NewProcessModelSearch().
        SetWorkOrder(procedure.WorkOrderID).
        SetDevice(procedure.ProceduresInfo.DeviceName).
        SetOrderId(procedure.OrderID).
        SetProcedure(procedure.ProceduresInfo.ProcedureName).
        SetProduct(order.ProductName).
        SetOrder("id desc").First()
    if err == nil {
        err = json.Unmarshal([]byte(data.Params), &data.ParamsMap)
        paramsMap = data.ParamsMap
        paramsNumber = data.Number
        if err != nil {
            logx.Errorf("process model json.Unmarshal:%v", err)
            ctx.FailWithMsg(ecode.UnknownErr, "未获取到工艺参数")
            return
        }
    } else if err == gorm.ErrRecordNotFound { //如何数据库没有从云端获取
        caller := nsq.NewCaller(fmt.Sprintf(constvar.NsqTopicProcessParamsRequest, conf.Conf.NsqConf.NodeId), fmt.Sprintf(constvar.NsqTopicProcessParamsResponse, conf.Conf.NsqConf.NodeId))
        var result common.ResponseProcessParams
        err = caller.Call(common.RequestProcessParams{
            WorkOrder: procedure.WorkOrderID,
            OrderId:   procedure.OrderID,
            Product:   order.ProductName,
            Procedure: procedure.ProceduresInfo.ProcedureName,
            Device:    procedure.ProceduresInfo.DeviceName}, &result, time.Second*3)
        if err != nil {
            logx.Errorf("TaskStart GetProcessModel error:%v", err.Error())
            ctx.FailWithMsg(ecode.UnknownErr, "未获取到工艺参数")
            return
        }
        if result.ParamsMap == nil {
            logx.Errorf("TaskStart GetProcessModel response miss process params:%v", result)
            ctx.FailWithMsg(ecode.UnknownErr, "未获取到工艺参数")
            return
        }
        paramsMap = result.ParamsMap
        paramsNumber = result.Number
    } else {
        logx.Errorf("TaskStart GetProcessModel  err:%v", err)
        ctx.FailWithMsg(ecode.UnknownErr, "未获取到工艺参数")
    processModel, err := service.NewTaskService().GetProcessParams(procedure, order)
    if err != nil || processModel == nil || processModel.ParamsMap == nil {
        ctx.Fail(ecode.UnknownErr)
        return
    }

    processParamsArr := make([]response.ProcessParams, 0, len(paramsMap))
    for k, v := range paramsMap {
    processParamsArr := make([]response.ProcessParams, 0, len(processModel.ParamsMap))
    for k, v := range processModel.ParamsMap {
        processParamsArr = append(processParamsArr, response.ProcessParams{
            Key:   k,
            Value: v,
        })
    }
    resp := response.ProcessParamsResponse{
        Number: paramsNumber,
        Number: processModel.Number,
        Params: processParamsArr,
    }
    ctx.OkWithDetailed(resp)
@@ -221,23 +178,9 @@
        return
    }

    caller := nsq.NewCaller(fmt.Sprintf(constvar.NsqTopicProcessParamsRequest, conf.Conf.NsqConf.NodeId), fmt.Sprintf(constvar.NsqTopicProcessParamsResponse, conf.Conf.NsqConf.NodeId))
    var result common.ResponseProcessParams

    err = caller.Call(common.RequestProcessParams{
        WorkOrder: procedure.WorkOrderID,
        OrderId:   procedure.OrderID,
        Product:   order.ProductName,
        Procedure: procedure.ProceduresInfo.ProcedureName,
        Device:    procedure.ProceduresInfo.DeviceName}, &result, time.Second*3)
    if err != nil {
        logx.Errorf("SendProcessParams GetProcessModel error:%v", err.Error())
        ctx.FailWithMsg(ecode.UnknownErr, "未获取到工艺参数")
        return
    }
    if result.ParamsMap == nil {
        logx.Errorf("SendProcessParams GetProcessModel response miss process params:%v", result)
        ctx.FailWithMsg(ecode.UnknownErr, "未获取到工艺参数")
    processModel, err := service.NewTaskService().GetProcessParams(procedure, order)
    if err != nil || processModel == nil || processModel.ParamsMap == nil {
        ctx.Fail(ecode.UnknownErr)
        return
    }

@@ -263,7 +206,7 @@
        return
    }
    plcConfig.MaxTryTimes = 2
    err = SendParams(result.ParamsMap, plcConfig)
    err = SendParams(processModel.ParamsMap, plcConfig)
    if err != nil {
        logx.Errorf("SendProcessParams: %v", err.Error())
        ctx.FailWithMsg(ecode.NeedConfirmedErr, "糟糕，工艺下发失败。")

 model/procedures.go

@@ -15,7 +15,7 @@
        ID             int    `gorm:"primarykey"`
        WorkOrderID    string `gorm:"index;type:varchar(191);not null;comment:工单ID" json:"-"`
        OrderID        string `gorm:"index;type:varchar(191);not null;comment:订单ID" json:"-"`
        DeviceID       string `gorm:"type:varchar(191);comment:设备ID" json:"deviceId"`
        DeviceID       string `gorm:"index;type:varchar(191);comment:设备ID" json:"deviceId"`
        StartTime      int64  `gorm:"comment:计划开始时间" json:"startTime"`
        EndTime        int64  `gorm:"comment:计划结束时间" json:"endTime"`
        Status         ProcedureStatus

 model/process_model.go

@@ -18,6 +18,7 @@
        Device     string                 `gorm:"column:device;type:varchar(255);not null;default '';comment:设备" json:"device"`           //设备
        Params     string                 `gorm:"type:text;comment:工艺参数键值对json串"`
        ParamsMap  map[string]interface{} `json:"paramsMap" gorm:"-"`
        DeviceId   string                 `json:"deviceId" gorm:"-"` //用于过滤获取nsq消息
    }

    ProcessModelSearch struct {

 nsq/msg_handler.go

@@ -43,41 +43,48 @@
        return err
    }
    for _, task := range tasks {
        oldWorkOrder, err := model.NewOrderSearch(nil).SetWorkOrderId(task.WorkOrder.WorkOrderID).First()
        if oldWorkOrder != nil && oldWorkOrder.WorkOrderID != "" && oldWorkOrder.Status != model.OrderStatusWaitProcess { //已开始的工序不可以修改
            continue
        }

        procedureRecords := make([]*model.Procedures, 0, len(task.Procedures))
        for _, procedure := range task.Procedures {
            if procedure.DeviceID == conf.Conf.System.DeviceId { //只存储本设备的工序
                err = model.WithTransaction(func(db *gorm.DB) error {
                    _, err := model.NewOrderSearch(db).SetWorkOrderId(task.WorkOrder.WorkOrderID).First()
                    if err == gorm.ErrRecordNotFound {
                        var orderRecord model.Order
                        err = structx.AssignTo(task.WorkOrder, &orderRecord)
                        orderRecord.Status = model.OrderStatusWaitProcess
                        if err != nil {
                            logx.Errorf(" structx.Assign task.Order to orderRecord err: %v", err.Error())
                            return err
                        }
                        if err = model.NewOrderSearch(db).Create(&orderRecord); err != nil {
                            return err
                        }
                    }
                    procedureRecord := model.Procedures{
                        StartTime:   procedure.StartTime,
                        EndTime:     procedure.EndTime,
                        WorkOrderID: task.WorkOrder.WorkOrderID,
                        OrderID:     task.WorkOrder.OrderID,
                        Status:      model.ProcedureStatusWaitProcess,
                    }
                    procedureData, err := json.Marshal(procedure)
                    procedureRecord.ProcedureData = string(procedureData)
                    if err != nil {
                        logx.Errorf(" json.Marshal(procedure) err: %v", err.Error())
                        return err
                    }
                    return model.NewProceduresSearch(db).Create(&procedureRecord)
                })
                if err != nil {
                    logx.Errorf(" save procedure err: %v", err.Error())
                }
            procedureRecord := model.Procedures{
                WorkOrderID:    task.WorkOrder.WorkOrderID,
                OrderID:        task.WorkOrder.OrderID,
                DeviceID:       procedure.DeviceID,
                StartTime:      procedure.StartTime,
                EndTime:        procedure.EndTime,
                Status:         model.ProcedureStatusWaitProcess,
                ProcedureData:  "",
                ProceduresInfo: common.ProductProcedure{},
            }
            procedureData, err := json.Marshal(procedure)
            if err != nil {
                return err
            }
            procedureRecord.ProcedureData = string(procedureData)
            procedureRecords = append(procedureRecords, &procedureRecord)
        }

        var orderRecord model.Order
        err = structx.AssignTo(task.WorkOrder, &orderRecord)
        orderRecord.Status = model.OrderStatusWaitProcess
        if err != nil {
            logx.Errorf(" structx.Assign task.Order to orderRecord err: %v", err.Error())
            return err
        }

        err = model.WithTransaction(func(db *gorm.DB) error {
            if err = model.NewOrderSearch(db).Save(&orderRecord); err != nil {
                return err
            }
            return model.NewProceduresSearch(db).CreateBatch(procedureRecords)
        })
        if err != nil {
            logx.Errorf(" save task message error err: %v", err.Error())
            return err
        }
    }
    return nil
@@ -140,9 +147,14 @@
        logx.Infof("unmarshal process params sync err :%s", err)
        return err
    }
    err = model.NewProcessModelSearch().Create(&processModel)
    if err != nil {
        logx.Infof("save process params err :%s", err)
    if processModel.DeviceId != conf.Conf.System.DeviceId { //不是发给本设备的消息
        return nil
    }
    if processModel.Params != "" {
        err = model.NewProcessModelSearch().Create(&processModel)
        if err != nil {
            logx.Infof("save process params err :%s", err)
        }
    }
    //通知回复收到
    ReceivedMessageChan <- &ReceivedMessage{

 service/task.go

@@ -1,9 +1,17 @@
package service

import (
    "apsClient/conf"
    "apsClient/constvar"
    "apsClient/model"
    "apsClient/model/common"
    "apsClient/model/response"
    "apsClient/nsq"
    "apsClient/pkg/ecode"
    "apsClient/pkg/logx"
    "apsClient/pkg/structx"
    "encoding/json"
    "fmt"
    "gorm.io/gorm"
    "time"
)
@@ -37,6 +45,7 @@
    procedure, err := model.NewProceduresSearch(nil).SetOrder("start_time asc").
        SetWorkOrderId(order.WorkOrderID).
        SetStartTimeMax(nowTs).
        SetDeviceId(conf.Conf.System.DeviceId).
        SetStatusNot(model.ProcedureStatusFinished).
        First()
    if err == gorm.ErrRecordNotFound { //该订单本设备全部工序完成，把订单置为完成状态（只是对本设备完成）
@@ -82,6 +91,51 @@
    return model.NewOrderSearch(nil).SetWorkOrderId(workOrderId).First()
}

func (slf TaskService) GetProcessParams(procedure *model.Procedures, order *model.Order) (processModel *model.ProcessModel, err error) {
    data, err := model.NewProcessModelSearch().
        SetWorkOrder(procedure.WorkOrderID).
        SetDevice(procedure.ProceduresInfo.DeviceName).
        SetOrderId(procedure.OrderID).
        SetProcedure(procedure.ProceduresInfo.ProcedureName).
        SetProduct(order.ProductName).
        SetOrder("id desc").First()
    if err != nil && err != gorm.ErrRecordNotFound {
        logx.Errorf("TaskStart GetProcessModel  err:%v", err)
        return nil, err
    }
    if err == nil {
        err = json.Unmarshal([]byte(data.Params), &data.ParamsMap)
        if err != nil {
            logx.Errorf("process model json.Unmarshal:%v", err)
            return
        }
        return data, nil
    }

    if err == gorm.ErrRecordNotFound { //如果数据库没有从云端获取
        caller := nsq.NewCaller(fmt.Sprintf(constvar.NsqTopicProcessParamsRequest, conf.Conf.NsqConf.NodeId), fmt.Sprintf(constvar.NsqTopicProcessParamsResponse, conf.Conf.NsqConf.NodeId))
        var result common.ResponseProcessParams
        err = caller.Call(common.RequestProcessParams{
            WorkOrder: procedure.WorkOrderID,
            OrderId:   procedure.OrderID,
            Product:   order.ProductName,
            Procedure: procedure.ProceduresInfo.ProcedureName,
            Device:    procedure.ProceduresInfo.DeviceName}, &result, time.Second*3)
        if err != nil {
            logx.Errorf("TaskStart GetProcessModel error:%v", err.Error())
            return
        }
        if result.ParamsMap == nil {
            logx.Errorf("TaskStart GetProcessModel response miss process params:%v", result)
            return
        }
        processModel = new(model.ProcessModel)
        err = structx.AssignTo(result, &processModel)
        return processModel, err
    }
    return
}

// GetCurrentTask 获取待完成或进行中的任务， 每个工单只有一个工序
func (slf TaskService) GetCurrentTask() (workOrder *model.Order, err error) {
    nowTs := time.Now().Unix()

 test/msg_handler_test.go

@@ -79,7 +79,7 @@
            Workers:         workers,
        }, {ProcedureID: "ProcedureID 2",
            ProcedureName:   "ProcedureName 2",
            DeviceID:        "DeviceID1",
            DeviceID:        "DeviceID2",
            DeviceName:      "DeviceName 1",
            StartTime:       startTime.Unix(),
            EndTime:         endTime.Unix(),
@@ -118,7 +118,7 @@
        }, {
            ProcedureID:     "ProcedureID 4",
            ProcedureName:   "ProcedureName 4",
            DeviceID:        "DeviceID1",
            DeviceID:        "DeviceID2",
            DeviceName:      "DeviceName 1",
            StartTime:       startTime.Unix(),
            EndTime:         endTime.Unix(),