leo
/
LAPP_Acura_MES_Backend
2
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 33 Wiki Activity
Browse Source

修复异步派工的bug

pull/216/head
zhangxin 2 years ago
parent
1cdcc5b5ba
commit
9d2997a2cb
5 changed files with 314 additions and 129 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -1
      common/ProjectChannel.go
  2. +96
    -107
      services/pln/implments/CustOrder.service.impl.go
  3. +192
    -16
      services/pln/implments/CustOrderLogic.service.impl.go
  4. +24
    -4
      services/pln/implments/CustOrderLogic.services.impl_test.go
  5. +1
    -1
      task/ApsRelease.go

+ 1
- 1
common/ProjectChannel.go View File

@ -2,4 +2,4 @@ package common
import plnModel "LAPP_ACURA_MOM_BACKEND/models/pln"
var ReleaseTaskChannel chan plnModel.CustOrder
var ReleaseTaskChannel map[int]chan plnModel.CustOrder

+ 96
- 107
services/pln/implments/CustOrder.service.impl.go View File

@ -758,8 +758,8 @@ func (impl *CustOrderServiceImplement) CancelCustOrderQty(user *global.User, cus
serialOrderStatusRecDao := omDal.NewSerialOrderStatusRecLstDAO(session, user.PlantNr, user.UserId)
productFamilyRelateDao := meDal.NewProductFamilyRelateDAO(session, user.PlantNr, user.UserId)
serialOrderPoDao := omDal.NewSerialOrderPOLstDAO(session, user.PlantNr, user.UserId)
serialOrderStepDao := omDal.NewSerialOrderStepLstDAO(session, user.PlantNr, user.UserId)
serialOrderOPDetailDao := omDal.NewSerialOrderOPDetailDAO(session, user.PlantNr, user.UserId)
//serialOrderStepDao := omDal.NewSerialOrderStepLstDAO(session, user.PlantNr, user.UserId)
//serialOrderOPDetailDao := omDal.NewSerialOrderOPDetailDAO(session, user.PlantNr, user.UserId)
// 校验客户订单数据及状态
custOrder, err := custOrderDao.SelectOne(custOrderId)
if err != nil {
@ -806,117 +806,106 @@ func (impl *CustOrderServiceImplement) CancelCustOrderQty(user *global.User, cus
return grmi.NewBusinessError("当前客户订单可取消数量小于需要取消数量")
}
if err = session.Begin(); err != nil {
return grmi.NewBusinessError("开启事务失败, error:" + err.Error())
}
impl.QuickSort(splitSyncKeyLi)
statusRecLi := make([]omModel.SerialOrderStatusRecLst, 0)
cancelSerialOrderIdLi := make([]interface{}, 0)
orderDataLi := make([]omModel.SerialOrder, 0)
for i := 0; i < cancelQty; i++ {
cancelSyncKey := splitSyncKeyLi[i]
orderDataLi, err := serialOrderDao.Select([]grmi.Predicate{omMeta.SerialOrder_SyncKey.NewPredicate(grmi.Equal, cancelSyncKey)}, nil)
innerOrderLi, err := serialOrderDao.Select([]grmi.Predicate{omMeta.SerialOrder_SyncKey.NewPredicate(grmi.Equal, cancelSyncKey)}, nil)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("查询工单数据失败, error:" + err.Error())
}
for _, serialOrderData := range orderDataLi {
serialOrderStatus := serialOrderData.SerialOrderStatus
statusRec := omModel.SerialOrderStatusRecLst{
SerialOrderId: serialOrderData.SerialOrderId,
PrevStatus: serialOrderStatus.Status,
Status: baseModel.WO_STATUS_CANCELED,
Remark1: "SPLIT",
}
err = serialOrderStatusRecDao.InsertOne(&statusRec)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("写入工单状态变更记录失败, error:" + err.Error())
}
serialOrderStatus.Status = baseModel.WO_STATUS_CANCELED
err = serialOrderStatusDao.UpdateOneWithStatus(&serialOrderStatus, baseModel.WO_STATUS_RELEASED)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单状态失败, error:" + err.Error())
}
poUpdateData := omModel.SerialOrderPOLst{
Status: baseModel.WO_STATUS_CANCELED,
}
err = serialOrderPoDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderData.SerialOrderId)}, &poUpdateData, []string{omMeta.SerialOrderPOLst_Status.Name}...)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单工序状态失败, error:" + err.Error())
}
stepUpdateData := omModel.SerialOrderStepLst{
Status: baseModel.WO_STATUS_CANCELED,
}
err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderData.SerialOrderId)}, &stepUpdateData, []string{omMeta.SerialOrderStepLst_Status.Name}...)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单工步状态失败, error:" + err.Error())
}
opDetailUpdateData := omModel.SerialOrderOPDetail{
Status: baseModel.WO_STATUS_CANCELED,
}
err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, serialOrderData.SerialOrderId)}, &opDetailUpdateData, []string{omMeta.SerialOrderOPDetail_Status.Name}...)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单详细操作状态失败, error:" + err.Error())
}
// 对拆分的预装工单做取消处理
//preSerialOrderLi, err := serialOrderDao.Select([]grmi.Predicate{
// omMeta.SerialOrder_OrderType.NewPredicate(grmi.Equal, baseModel.ORDER_TYPE_PRE),
// omMeta.SerialOrder_GenerateFlag.NewPredicate(grmi.Equal, 0),
// omMeta.SerialOrder_MainOrderId.NewPredicate(grmi.Equal, serialOrderData.SerialOrderId),
//}, nil)
//if err != nil {
// return grmi.NewBusinessError("查询工单下的预装工单失败, 错误：" + err.Error())
//}
//for _, preOrder := range preSerialOrderLi {
// if preOrder.SerialOrderStatus.Status > baseModel.WO_STATUS_RELEASED {
// return grmi.NewBusinessError("预装工单已经不允许取消, 工单ID:" + preOrder.SerialOrderId)
// }
// originStatus := preOrder.SerialOrderStatus.Status
// statusRec = omModel.SerialOrderStatusRecLst{
// SerialOrderId: preOrder.SerialOrderId,
// Status: baseModel.WO_STATUS_CANCELED,
// PrevStatus: preOrder.SerialOrderStatus.Status,
// }
// preOrder.SerialOrderStatus.Status = baseModel.WO_STATUS_CANCELED
// err = serialOrderStatusRecDao.InsertOne(&statusRec)
// if err != nil {
// _ = session.Rollback()
// return grmi.NewBusinessError("插入预装工单状态变更记录失败, error:" + err.Error())
// }
// err = serialOrderStatusDao.UpdateOneWithStatus(&preOrder.SerialOrderStatus, baseModel.WO_STATUS_RELEASED)
// if err != nil {
// _ = session.Rollback()
// return grmi.NewBusinessError("更新预装工单状态失败， error:" + err.Error())
// }
// if originStatus == baseModel.WO_STATUS_RELEASED {
// poUpdateData := &omModel.SerialOrderPOLst{
// Status: baseModel.WO_STATUS_CANCELED,
// }
// err = serialOrderPoDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, poUpdateData, omMeta.SerialOrderPOLst_Status.Name)
// if err != nil {
// _ = session.Rollback()
// return grmi.NewBusinessError("更新预装工单工序状态失败, error:" + err.Error())
// }
// stepUpdateData := &omModel.SerialOrderStepLst{
// Status: baseModel.WO_STATUS_CANCELED,
// }
// err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, stepUpdateData, omMeta.SerialOrderStepLst_Status.Name)
// if err != nil {
// _ = session.Rollback()
// return grmi.NewBusinessError("更新预装工单工步状态失败, error:" + err.Error())
// }
// opDetailUpdateData := &omModel.SerialOrderOPDetail{
// Status: baseModel.WO_STATUS_CANCELED,
// }
// err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, opDetailUpdateData, omMeta.SerialOrderOPDetail_Status.Name)
// if err != nil {
// _ = session.Rollback()
// return grmi.NewBusinessError("更新预装工单详细操作状态失败, error:" + err.Error())
// }
// }
//}
orderDataLi = append(orderDataLi, innerOrderLi...)
}
if err = session.Begin(); err != nil {
return grmi.NewBusinessError("开启事务失败, error:" + err.Error())
}
for _, serialOrderData := range orderDataLi {
cancelSerialOrderIdLi = append(cancelSerialOrderIdLi, serialOrderData.SerialOrderId)
serialOrderStatus := serialOrderData.SerialOrderStatus
statusRec := omModel.SerialOrderStatusRecLst{
SerialOrderId: serialOrderData.SerialOrderId,
PrevStatus: serialOrderStatus.Status,
Status: baseModel.WO_STATUS_CANCELED,
Remark1: "SPLIT",
}
statusRecLi = append(statusRecLi, statusRec)
serialOrderStatus.Status = baseModel.WO_STATUS_CANCELED
err = serialOrderStatusDao.UpdateOneWithStatus(&serialOrderStatus, baseModel.WO_STATUS_RELEASED)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单状态失败, error:" + err.Error())
}
//poUpdateData := omModel.SerialOrderPOLst{
// Status: baseModel.WO_STATUS_CANCELED,
//}
//err = serialOrderPoDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderData.SerialOrderId)}, &poUpdateData, []string{omMeta.SerialOrderPOLst_Status.Name}...)
//if err != nil {
// _ = session.Rollback()
// return grmi.NewBusinessError("更新工单工序状态失败, error:" + err.Error())
//}
//stepUpdateData := omModel.SerialOrderStepLst{
// Status: baseModel.WO_STATUS_CANCELED,
//}
//err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderData.SerialOrderId)}, &stepUpdateData, []string{omMeta.SerialOrderStepLst_Status.Name}...)
//if err != nil {
// _ = session.Rollback()
// return grmi.NewBusinessError("更新工单工步状态失败, error:" + err.Error())
//}
//opDetailUpdateData := omModel.SerialOrderOPDetail{
// Status: baseModel.WO_STATUS_CANCELED,
//}
//err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, serialOrderData.SerialOrderId)}, &opDetailUpdateData, []string{omMeta.SerialOrderOPDetail_Status.Name}...)
//if err != nil {
// _ = session.Rollback()
// return grmi.NewBusinessError("更新工单详细操作状态失败, error:" + err.Error())
//}
}
// 保存工单状态变更记录
num := len(statusRecLi) / 50
remainder := len(statusRecLi) % 50
for i := 0; i < num; i++ {
insertLi := statusRecLi[50*i : (i+1)*50]
err = serialOrderStatusRecDao.Insert(&insertLi)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("保存工单状态变更记录失败, 错误:" + err.Error())
}
}
if remainder != 0 {
insertLi := statusRecLi[num*50:]
err = serialOrderStatusRecDao.Insert(&insertLi)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("保存工单状态变更记录失败, 错误:" + err.Error())
}
}
// 更新工单工序状态
poUpdateData := omModel.SerialOrderPOLst{
Status: baseModel.WO_STATUS_CANCELED,
}
num = len(cancelSerialOrderIdLi) / 50
remainder = len(cancelSerialOrderIdLi) % 50
for i := 0; i < num; i++ {
updateLi := cancelSerialOrderIdLi[50*i : (i+1)*50]
err = serialOrderPoDao.UpdateWhere([]grmi.Predicate{
omMeta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Include, updateLi...),
}, &poUpdateData, omMeta.SerialOrderPOLst_Status.Name)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单工序状态变更记录失败, 错误:" + err.Error())
}
}
if remainder != 0 {
updateLi := cancelSerialOrderIdLi[num*50:]
err = serialOrderPoDao.UpdateWhere([]grmi.Predicate{
omMeta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Include, updateLi...),
}, &poUpdateData, omMeta.SerialOrderPOLst_Status.Name)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单工序状态变更记录失败, 错误:" + err.Error())
}
}
// 处理客户订单数量数据


+ 192
- 16
services/pln/implments/CustOrderLogic.service.impl.go View File

@ -11,12 +11,14 @@ import (
"LAPP_ACURA_MOM_BACKEND/grmi"
"LAPP_ACURA_MOM_BACKEND/infra/logger"
meMeta "LAPP_ACURA_MOM_BACKEND/meta/me"
omMeta "LAPP_ACURA_MOM_BACKEND/meta/om"
baseModel "LAPP_ACURA_MOM_BACKEND/models/base"
meModel "LAPP_ACURA_MOM_BACKEND/models/me"
omModel "LAPP_ACURA_MOM_BACKEND/models/om"
model "LAPP_ACURA_MOM_BACKEND/models/pln"
omSvr "LAPP_ACURA_MOM_BACKEND/services/om"
"LAPP_ACURA_MOM_BACKEND/utils"
"fmt"
"github.com/360EntSecGroup-Skylar/excelize/v2"
uuid "github.com/iris-contrib/go.uuid"
"sort"
@ -79,8 +81,14 @@ func (impl *CustOrderServiceImplement) LockCustOrder(user *global.User, custOrde
itemJ := custOrderLi[j]
return itemJ.PlanStartTime.Restore().Before(itemI.PlanStartTime.Restore())
})
plantNr := user.PlantNr
channel, exist := common.ReleaseTaskChannel[plantNr]
if !exist {
common.ReleaseTaskChannel[plantNr] = make(chan model.CustOrder, 50)
channel = common.ReleaseTaskChannel[plantNr]
}
for _, custOrder := range custOrderLi {
common.ReleaseTaskChannel <- custOrder
channel <- custOrder
}
return nil
}
@ -260,7 +268,7 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
if err != nil {
return grmi.NewBusinessError("生成任务id失败,错误:" + err.Error())
}
log, _ := logger.NewLogger("客户订单派工,id:" + releaseId.String(), "PLN")
log, _ := logger.NewLogger("客户订单派工,id:"+releaseId.String(), "PLN")
engine := db.Eloquent.Master()
session := engine.NewSession()
defer session.Close()
@ -281,12 +289,14 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
serialOrderPoDao := omDal.NewSerialOrderPOLstDAO(session, user.PlantNr, user.UserId)
serialOrderStepDao := omDal.NewSerialOrderStepLstDAO(session, user.PlantNr, user.UserId)
serialOrderOPDetailDao := omDal.NewSerialOrderOPDetailDAO(session, user.PlantNr, user.UserId)
serialOrderStatusRecDao := omDal.NewSerialOrderStatusRecLstDAO(session, user.PlantNr, user.UserId)
// 创建serialOrder service接口
serialOrderSvr := omSvr.NewSerialOrderService()
// 查询当前是否有需要派工的custOrder
needReleaseQty := custOrderData.OrderQty.PlanQty - custOrderData.OrderQty.ReleasedQty - custOrderData.OrderQty.CancelQty
log.Info("开始派工, 当前派工客户订单ID:" + custOrderData.CustOrderId + ", 需要派工数量:" + strconv.Itoa(needReleaseQty))
// 获取客户订单的车型配置下的所有座椅
fmt.Println("---------------------------custOrderId:", custOrderData.CustOrderId)
productLi, err := productFamilyRelateDao.SelectProductByFamilyIdForCreateSerialOrder(custOrderData.ProjectId, custOrderData.ProductFamilyId)
if err != nil {
return grmi.NewBusinessError("通过车型配置查询关联座椅产品失败, error:" + err.Error())
@ -305,6 +315,163 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
duration := custOrderData.PlanEndTime.Restore().Sub(custOrderData.PlanStartTime.Restore())
totalQty := custOrderData.PlanQty * len(productLi)
perDuration := duration.Seconds() / float64(totalQty)
if custOrderData.CtrlPara1 == 1 {
var current int
// 如果客户订单是拆分出来的客户订单 则只是重置所归属的工单及工艺状态
serialOrderDataLi, err := serialOrderDao.Select([]grmi.Predicate{
omMeta.SerialOrder_CustOrderId.NewPredicate(grmi.Equal, custOrderData.CustOrderId),
omMeta.SerialOrder_OrderType.NewPredicate(grmi.Equal, baseModel.ODER_TYPE_SEQ),
}, []grmi.Field{omMeta.SerialOrder_PlanStartTime})
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("查询客户订单下的工单失败， error:" + err.Error())
}
for _, serialOrder := range serialOrderDataLi {
planStartTime := custOrderData.PlanStartTime.Restore().Add(time.Duration(int(perDuration)*current) * time.Second)
planEndTime := custOrderData.PlanStartTime.Restore().Add(time.Duration(int(perDuration)*(current+1)) * time.Second)
current++
planStartDate := grmi.Date(planStartTime)
planEndDate := grmi.Date(planEndTime)
timeInt, err := strconv.Atoi(planStartTime.Format("060102150405"))
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("通过时间获取工单调度Key失败, error:" + err.Error())
}
//dealedSchedKey := int64(todayInt*1000000 + schedKey*100)
var dealedSchedKey = int64(timeInt * 100)
serialOrder.PlanStartTime = grmi.DateTime(planStartTime)
serialOrder.PlanEndTime = grmi.DateTime(planEndTime)
serialOrder.PlanStartDate = planStartDate
serialOrder.PlanEndDate = planEndDate
serialOrder.SchedKey = dealedSchedKey
err = serialOrderDao.UpdateOne(&serialOrder)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单数据失败， error:" + err.Error())
}
serialOrderStatusRec := omModel.SerialOrderStatusRecLst{
SerialOrderId: serialOrder.SerialOrderId,
PrevStatus: serialOrder.SerialOrderStatus.Status,
Status: baseModel.WO_STATUS_RELEASED,
}
err = serialOrderStatusRecDao.InsertOne(&serialOrderStatusRec)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("写入工单状态变更历史失败, error:" + err.Error())
}
serialOrder.SerialOrderStatus.Status = baseModel.WO_STATUS_RELEASED
err = serialOrderStatusDao.UpdateOne(&serialOrder.SerialOrderStatus)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单状态失败, error:" + err.Error())
}
poUpdateData := omModel.SerialOrderPOLst{
Status: baseModel.WO_STATUS_RELEASED,
}
err = serialOrderPoDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrder.SerialOrderId)}, &poUpdateData, []string{omMeta.SerialOrderPOLst_Status.Name}...)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单工序状态失败, error:" + err.Error())
}
stepUpdateData := omModel.SerialOrderStepLst{
Status: baseModel.WO_STATUS_RELEASED,
}
err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrder.SerialOrderId)}, &stepUpdateData, []string{omMeta.SerialOrderStepLst_Status.Name}...)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单工步状态失败, error:" + err.Error())
}
opDetailUpdateData := omModel.SerialOrderOPDetail{
Status: baseModel.WO_STATUS_RELEASED,
}
err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, serialOrder.SerialOrderId)}, &opDetailUpdateData, []string{omMeta.SerialOrderOPDetail_Status.Name}...)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新工单详细操作状态失败, error:" + err.Error())
}
// 对预装工单的处理
preSerialOrderLi, err := serialOrderDao.Select([]grmi.Predicate{
omMeta.SerialOrder_OrderType.NewPredicate(grmi.Equal, baseModel.ORDER_TYPE_PRE),
omMeta.SerialOrder_GenerateFlag.NewPredicate(grmi.Equal, 0),
omMeta.SerialOrder_MainOrderId.NewPredicate(grmi.Equal, serialOrder.SerialOrderId),
}, nil)
if err != nil {
return grmi.NewBusinessError("查询工单下的预装工单失败, 错误：" + err.Error())
}
for _, preOrder := range preSerialOrderLi {
preOrder.PlanStartTime = grmi.DateTime(planStartTime)
preOrder.PlanEndTime = grmi.DateTime(planEndTime)
preOrder.PlanStartDate = grmi.Date(planStartTime)
preOrder.PlanEndDate = grmi.Date(planEndTime)
preOrder.SchedKey = dealedSchedKey
err = serialOrderDao.UpdateOne(&preOrder)
if err != nil {
return grmi.NewBusinessError("更新预装工单数据失败, 错误：" + err.Error())
}
statusRec := omModel.SerialOrderStatusRecLst{
SerialOrderId: preOrder.SerialOrderId,
Status: baseModel.WO_STATUS_RELEASED,
PrevStatus: preOrder.SerialOrderStatus.Status,
}
preOrder.SerialOrderStatus.Status = baseModel.WO_STATUS_RELEASED
err = serialOrderStatusRecDao.InsertOne(&statusRec)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("插入预装工单状态变更记录失败, error:" + err.Error())
}
err = serialOrderStatusDao.UpdateOneWithStatus(&preOrder.SerialOrderStatus, baseModel.WO_STATUS_UNPLANNED)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新预装工单状态失败， error:" + err.Error())
}
poUpdateData := &omModel.SerialOrderPOLst{
Status: baseModel.WO_STATUS_RELEASED,
}
err = serialOrderPoDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, poUpdateData, omMeta.SerialOrderPOLst_Status.Name)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新预装工单工序状态失败, error:" + err.Error())
}
stepUpdateData := &omModel.SerialOrderStepLst{
Status: baseModel.WO_STATUS_RELEASED,
}
err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, stepUpdateData, omMeta.SerialOrderStepLst_Status.Name)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新预装工单工步状态失败, error:" + err.Error())
}
opDetailUpdateData := &omModel.SerialOrderOPDetail{
Status: baseModel.WO_STATUS_RELEASED,
}
err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{omMeta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, opDetailUpdateData, omMeta.SerialOrderOPDetail_Status.Name)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新预装工单详细操作状态失败, error:" + err.Error())
}
}
}
custOrderStatusRec := model.CustOrderStatusHistory{
CustOrderId: custOrderData.CustOrderId,
FromStatus: custOrderData.OrderStatus.Status,
ToStatus: baseModel.WO_STATUS_RELEASED,
ChangeTime: grmi.DateTime(time.Now()),
}
err = custOrderStatusRecDao.InsertOne(&custOrderStatusRec)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("插入客户订单状态变更历史失败, error:" + err.Error())
}
custOrderData.OrderStatus.Status = baseModel.WO_STATUS_RELEASED
err = custOrderStatusDao.UpdateOne(&custOrderData.OrderStatus)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("更新客户订单状态失败, error:" + err.Error())
}
_ = session.Commit()
return nil
}
// 产线组与所属产线的MAP数据结构
workLineGroupMap := make(map[string]map[string]interface{})
workLineMap := make(map[string]baseModel.WorkLine)
@ -371,7 +538,7 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
} else {
resourceId = product.DefaultWorkLineId
}
currentIndex := custOrderData.OrderQty.ReleasedQty * len(productLi) + index
currentIndex := custOrderData.OrderQty.ReleasedQty*len(productLi) + index
planStartTime := custOrderData.PlanStartTime.Restore().Add(time.Duration(int(perDuration)*currentIndex) * time.Second)
planEndTime := custOrderData.PlanStartTime.Restore().Add(time.Duration(int(perDuration)*(currentIndex+1)) * time.Second)
planStartDate := grmi.Date(planStartTime)
@ -442,7 +609,7 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
productCraftMap[serialOrder.ArtId] = orderCraft
} else {
serialOrder = orderCraft
currentIndex := custOrderData.OrderQty.ReleasedQty * len(productLi) + index
currentIndex := custOrderData.OrderQty.ReleasedQty*len(productLi) + index
planStartTime := custOrderData.PlanStartTime.Restore().Add(time.Duration(int(perDuration)*currentIndex) * time.Second)
planEndTime := custOrderData.PlanStartTime.Restore().Add(time.Duration(int(perDuration)*(currentIndex+1)) * time.Second)
planStartDate := grmi.Date(planStartTime)
@ -504,17 +671,16 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
_ = session.Rollback()
return grmi.NewBusinessError("生成工单流水号失败, error:" + err.Error())
}
preSerialNumber, err := snrDao.GetNextSnr(project.PreOrderSnr)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("获取流水号失败，错误:" + err.Error())
}
for _, serialOrder := range waitReleaseSerialOrderLi {
serialOrderSvr.ReplaceData(&serialOrder, serialNumber, false)
for index, preOrder := range serialOrder.PreOrderLi {
preOrder.MainOrderId = serialOrder.SerialOrderId
preSerialNumber, err := snrDao.GetNextSnr(project.PreOrderSnr)
if err != nil {
_ = session.Rollback()
return grmi.NewBusinessError("获取流水号失败，错误:" + err.Error())
}
serialOrderSvr.ReplaceData(&preOrder, preSerialNumber, true)
serialOrder.PreOrderLi[index] = preOrder
}
writeSerialOrderLi = append(writeSerialOrderLi, serialOrder)
@ -676,7 +842,7 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
}
_ = session.Commit()
}
if custOrderData.OrderQty.PlanQty == custOrderData.OrderQty.ReleasedQty + custOrderData.OrderQty.CancelQty {
if custOrderData.OrderQty.PlanQty == custOrderData.OrderQty.ReleasedQty+custOrderData.OrderQty.CancelQty {
if err = session.Begin(); err != nil {
return grmi.NewBusinessError("开启事务失败, 错误：" + err.Error())
}
@ -705,12 +871,17 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
return nil
}
func (impl *CustOrderServiceImplement) ReleasePlantTask(user *global.User) {
func (impl *CustOrderServiceImplement) ReleasePlantTask(user *global.User) {
log, _ := logger.NewLogger("派工任务", "PLN")
var err error
plantNr := user.PlantNr
channel, exist := common.ReleaseTaskChannel[plantNr]
if !exist {
common.ReleaseTaskChannel[plantNr] = make(chan model.CustOrder, 50)
}
for {
select {
case custOrder := <- common.ReleaseTaskChannel:
case custOrder := <-channel:
err = impl.ReleaseCustOrder(user, custOrder)
if err != nil {
log.Error("派工异常, 错误:" + err.Error())
@ -732,19 +903,24 @@ func (impl *CustOrderServiceImplement) ReleaseTask() error {
for _, plant := range plantLi {
user := &global.User{
PlantNr: plant.PlantNr,
UserId: userId,
UserId: userId,
}
custOrderDao := dal.NewCustOrderDAO(session, user.PlantNr, user.UserId)
custOrderLi, err := custOrderDao.SelectNeedReleaseCustOrder()
if err != nil {
return err
}
channel, exist := common.ReleaseTaskChannel[user.PlantNr]
if !exist {
common.ReleaseTaskChannel[user.PlantNr] = make(chan model.CustOrder, 50)
channel = common.ReleaseTaskChannel[user.PlantNr]
}
for _, custOrder := range custOrderLi {
common.ReleaseTaskChannel <- custOrder
channel <- custOrder
}
go func(user *global.User) {
impl.ReleasePlantTask(user)
}(user)
}
return nil
}
}

+ 24
- 4
services/pln/implments/CustOrderLogic.services.impl_test.go View File

@ -6,6 +6,8 @@ import (
"LAPP_ACURA_MOM_BACKEND/db"
"LAPP_ACURA_MOM_BACKEND/global"
"LAPP_ACURA_MOM_BACKEND/infra/logger"
model "LAPP_ACURA_MOM_BACKEND/models/pln"
"sort"
"time"
"LAPP_ACURA_MOM_BACKEND/utils"
@ -51,11 +53,29 @@ func TestCustOrderServiceImplement_ReleaseCustOrder(t *testing.T) {
session := engine.NewSession()
defer session.Close()
custOrderDao := dal.NewCustOrderDAO(session, user.PlantNr, user.UserId)
custOrder, err := custOrderDao.SelectOne("CO-00000573")
custOrder, err := custOrderDao.SelectOne("CO-00000592")
if err != nil {
log.Fatal("获取custOrder失败, ", err)
}
custSrv := NewCustOrderServiceImplement()
err = custSrv.ReleaseCustOrder(user, *custOrder)
fmt.Println("err:", err)
//custSrv := NewCustOrderServiceImplement()
//err = custSrv.ReleaseCustOrder(user, *custOrder)
//fmt.Println("err:", err)
custOrderLi := make([]model.CustOrder, 0, 3)
custOrderLi = append(custOrderLi, *custOrder)
custOrder, err = custOrderDao.SelectOne("CO-00000590")
if err != nil {
log.Fatal("获取custOrder失败, ", err)
}
custOrderLi = append(custOrderLi, *custOrder)
custOrder, err = custOrderDao.SelectOne("CO-00000589")
if err != nil {
log.Fatal("获取custOrder失败, ", err)
}
custOrderLi = append(custOrderLi, *custOrder)
sort.Slice(custOrderLi, func(i, j int) bool {
itemI := custOrderLi[i]
itemJ := custOrderLi[j]
return itemJ.PlanStartTime.Restore().After(itemI.PlanStartTime.Restore())
})
fmt.Println(custOrderLi)
}

+ 1
- 1
task/ApsRelease.go View File

@ -7,7 +7,7 @@ import (
)
func StartApsRelease() error {
common.ReleaseTaskChannel = make(chan plnModel.CustOrder, 50)
common.ReleaseTaskChannel = make(map[int]chan plnModel.CustOrder)
custSvr := pln.NewCustOrderService()
err := custSvr.ReleaseTask()
return err


Write Preview
Loading…
Cancel
Save