添加配置派工的逻辑

common/ProjectChannel.go

@@ -2,8 +2,11 @@ package common
 
 import (
 	"LAPP_ACURA_MOM_BACKEND/models/channel"
+	"sync"
 )
 
 var	ReleaseTaskChannel map[int]*channel.TaskChannel
 
-var CrossPlantTaskCustOrderChannel map[int]*channel.TaskChannel
+var CrossPlantTaskCustOrderChannel map[int]*channel.TaskChannel
+
+var ReleasingTaskMap sync.Map

models/pln/const.go

@@ -33,5 +33,6 @@ const (
 	DELIVERY_STATUS_PLAN = 0
 	DELIVERY_STATUS_DONE = 1
 
-
+	// 派工配置类型
+	CONFIG_TYPE_WORK_LINE = "WORK_LINE"
 )

services/me/implments/ShipableAUConfig.service.impl.go

@@ -350,7 +350,7 @@ func (impl *ShipableAUConfigServiceImplement) Save(user *global.User, entity *mo
 	if err != nil {
 		return grmi.NewBusinessError("查询配置数据失败, 错误:" + err.Error())
 	}
-	processDao := baseDal.NewProcessDAO(session, user.PlantNr, user.UserId)
+	processDao := baseDal.NewProcessDAO(session, entity.AuPlantNr, user.UserId)
 	if record == nil {
 		articleLi, err := articleDao.Select([]grmi.Predicate{
 			baseMeta.Article_ArtId.NewPredicate(grmi.Equal, entity.ArtId),

services/om/implments/SerialOrder.Craft.impl.go

@@ -291,7 +291,6 @@ func (impl *SerialOrderServiceImplement) GenerateProductCraft(user *global.User,
 	}
 	// 生成序列工单对应的工艺数据
 	allocateMap := make(map[string][]baseModel.ArtQtyAllocate)
-	checkRuleMap := make(map[string]baseModel.ArtCheckRule)
 	opcBasicMap := make(map[int][]baseModel.OPCBasicComInfo)
 	twMap := make(map[int][]baseModel.TightenWrenchInfo)
 	planDate := serialOrder.PlanStartDate.Restore().Format(grmi.DateOutFormat)
@@ -398,11 +397,11 @@ func (impl *SerialOrderServiceImplement) GenerateProductCraft(user *global.User,
 					return grmi.NewBusinessError("未获取到扫描校验详细规则, 工艺ID:" + strconv.Itoa(serialOrderStep.OperationId))
 				}
 
-				checkRuleMapPointer, allocateMapPointer, opLi, err := impl.ScanCodeCheck(user, session, checkRuleMap, allocateMap, orderOPData.ArtRelMap, &scanRule, &op, &serialOrderStep, op.Operation.ActivateInBKStation)
+				allocateMapPointer, opLi, err := impl.ScanCodeCheck(user, session, allocateMap, orderOPData.ArtRelMap, &scanRule, &op, &serialOrderStep, op.Operation.ActivateInBKStation)
 				if err != nil {
 					return err
 				}
-				checkRuleMap = *checkRuleMapPointer
+
 				allocateMap = *allocateMapPointer
 				usedSerialOrder.SerialOrderOPDetailLi = append(usedSerialOrder.SerialOrderOPDetailLi, opLi...)
 			} else if serialOrderStep.StepType == baseModel.STEP_OPC_RULE { // 生成OPC通讯的工艺数据

services/om/implments/SerialOrder.Operation.impl.go

@@ -12,31 +12,26 @@ import (
 )
 
 // ScanCodeCheck 生成扫码校验的工艺数据
-func (impl *SerialOrderServiceImplement) ScanCodeCheck(user *global.User, session *xorm.Session, checkRuleMap map[string]baseModel.ArtCheckRule, allocateMap map[string][]baseModel.ArtQtyAllocate, artRelMap map[string]int, scanRule *baseModel.ScanRuleInfo, op *baseModel.MeOperation, serialOrderStep *model.SerialOrderStepLst, bkFlag bool) (resCheckRuleMap *map[string]baseModel.ArtCheckRule, resAllocateMap *map[string][]baseModel.ArtQtyAllocate, opLi []model.SerialOrderOPDetail, err error) {
+func (impl *SerialOrderServiceImplement) ScanCodeCheck(user *global.User, session *xorm.Session,  allocateMap map[string][]baseModel.ArtQtyAllocate, artRelMap map[string]int, scanRule *baseModel.ScanRuleInfo, op *baseModel.MeOperation, serialOrderStep *model.SerialOrderStepLst, bkFlag bool) (resAllocateMap *map[string][]baseModel.ArtQtyAllocate, opLi []model.SerialOrderOPDetail, err error) {
 	opLi = make([]model.SerialOrderOPDetail, 0)
 	ruleDao := baseDal.NewArtCheckRuleDAO(session, user.PlantNr, user.UserId)
 	allocateDao := baseDal.NewArtQtyAllocateDAO(session, user.PlantNr, user.UserId)
 	if scanRule.RuleType == baseModel.SCAN_RULE_TYPE_ARTICLE {
 		if scanRule.SRCtrlPara1 == baseModel.SCAN_RULE_CHECK {
-			// 获取零件校验规则
-			rule, exist := checkRuleMap[op.ArticleAtcodLst.ArtId]
-			if !exist {
-				ruleLi, err := ruleDao.Select([]grmi.Predicate{baseMeta.ArtCheckRule_AttriCode.NewPredicate(grmi.Equal, op.ArticleAtcodLst.AttrCode), baseMeta.ArtCheckRule_SubObject.NewPredicate(grmi.Equal, serialOrderStep.SubArtId)}, nil)
+			ruleLi, err := ruleDao.Select([]grmi.Predicate{baseMeta.ArtCheckRule_AttriCode.NewPredicate(grmi.Equal, op.ArticleAtcodLst.AttrCode), baseMeta.ArtCheckRule_SubObject.NewPredicate(grmi.Equal, serialOrderStep.SubArtId)}, nil)
+			if err != nil {
+				return  nil, nil, grmi.NewBusinessError("获取零件检验规则失败, error:" + err.Error())
+			}
+			if len(ruleLi) == 0 {
+				ruleLi, err = ruleDao.Select([]grmi.Predicate{baseMeta.ArtCheckRule_AttriCode.NewPredicate(grmi.Equal, op.ArticleAtcodLst.AttrCode), baseMeta.ArtCheckRule_SubObject.NewPredicate(grmi.Equal, baseModel.MES_MATCH_ALL)}, nil)
 				if err != nil {
-					return nil, nil, nil, grmi.NewBusinessError("获取零件检验规则失败, error:" + err.Error())
+					return  nil, nil, grmi.NewBusinessError("获取零件检验规则失败, error:" + err.Error())
 				}
 				if len(ruleLi) == 0 {
-					ruleLi, err = ruleDao.Select([]grmi.Predicate{baseMeta.ArtCheckRule_AttriCode.NewPredicate(grmi.Equal, op.ArticleAtcodLst.AttrCode), baseMeta.ArtCheckRule_SubObject.NewPredicate(grmi.Equal, baseModel.MES_MATCH_ALL)}, nil)
-					if err != nil {
-						return nil, nil, nil, grmi.NewBusinessError("获取零件检验规则失败, error:" + err.Error())
-					}
-					if len(ruleLi) == 0 {
-						return nil, nil, nil, grmi.NewBusinessError("未获取到零件检验规则, artId:" + serialOrderStep.SubArtId)
-					}
+					return  nil, nil, grmi.NewBusinessError("未获取到零件检验规则, artId:" + serialOrderStep.SubArtId)
 				}
-				rule = ruleLi[0]
-				checkRuleMap[op.ArticleAtcodLst.ArtId] = rule
 			}
+			rule := ruleLi[0]
 			// 获取零件分配数量
 			var num int
 			// 零件BOM中两件组成父级零件的数量
@@ -45,7 +40,7 @@ func (impl *SerialOrderServiceImplement) ScanCodeCheck(user *global.User, sessio
 			if !exist {
 				allocateLi, err = allocateDao.Select([]grmi.Predicate{baseMeta.ArtQtyAllocate_AttriCode.NewPredicate(grmi.Equal, op.ArticleAtcodLst.AttrCode), baseMeta.ArtQtyAllocate_TotalPlanty.NewPredicate(grmi.Equal, composeQty)}, nil)
 				if err != nil {
-					return nil, nil, nil, grmi.NewBusinessError("获取特殊工位数量分配数据失败，错误:" + err.Error())
+					return  nil, nil, grmi.NewBusinessError("获取特殊工位数量分配数据失败，错误:" + err.Error())
 				}
 				allocateMap[op.ArticleAtcodLst.ArtId] = allocateLi
 			}
@@ -108,7 +103,7 @@ func (impl *SerialOrderServiceImplement) ScanCodeCheck(user *global.User, sessio
 				pos++
 				opLi = append(opLi, op)
 			}
-			return &checkRuleMap, &allocateMap, opLi, nil
+			return  &allocateMap, opLi, nil
 		} else if scanRule.SRCtrlPara1 == baseModel.SCAN_RULE_CRWAL {
 			op := model.SerialOrderOPDetail{
 				SerialOrderId: serialOrderStep.SerialOrderId,
@@ -122,9 +117,9 @@ func (impl *SerialOrderServiceImplement) ScanCodeCheck(user *global.User, sessio
 				IntPara5:      -1,
 			}
 			opLi = append(opLi, op)
-			return &checkRuleMap, &allocateMap, opLi, nil
+			return  &allocateMap, opLi, nil
 		} else {
-			return nil, nil, opLi, grmi.NewBusinessError("不支持的条码校验类型")
+			return  nil, opLi, grmi.NewBusinessError("不支持的条码校验类型")
 		}
 
 	} else if scanRule.RuleType == baseModel.SCAN_RULE_TYPE_OTHER {
@@ -144,12 +139,12 @@ func (impl *SerialOrderServiceImplement) ScanCodeCheck(user *global.User, sessio
 			CharPara5: "SerialOrderId",
 		}
 		opLi = append(opLi, op)
-		return &checkRuleMap, &allocateMap, opLi, nil
+		return  &allocateMap, opLi, nil
 		//} else {
 		//	return nil, nil, grmi.NewBusinessError("不支持的条码校验规则")
 		//}
 	} else {
-		return nil, nil, opLi, grmi.NewBusinessError("不支持的条码校验类型")
+		return  nil, opLi, grmi.NewBusinessError("不支持的条码校验类型")
 	}
 }
 
@@ -550,4 +545,3 @@ func (impl *SerialOrderServiceImplement) PrintRuleInfo(serialOrderStep *model.Se
 	}
 	return op, labelHeadLi, labelDetailLi
 }
-

services/pln/implments/CustOrderLogic.service.impl.go

@@ -42,12 +42,14 @@ func (impl *CustOrderServiceImplement) LockCustOrder(user *global.User, custOrde
 	custOrderStatusDao := dal.NewCustOrderStatusDAO(session, user.PlantNr, user.UserId)
 	custOrderStatusRecDao := dal.NewCustOrderStatusHistoryDAO(session, user.PlantNr, user.UserId)
 	productRelateDao := meDal.NewProductFamilyRelateDAO(session, user.PlantNr, user.UserId)
+	configDao := dal.NewReleaseTaskConfigDAO(session, user.PlantNr, user.UserId)
 	snrDao := baseDal.NewSnrDAO(session, user.PlantNr, user.UserId)
 	projectDao := meDal.NewProjectDAO(session, user.PlantNr, user.UserId)
 	custOrderStatusRecLi := make([]model.CustOrderStatusHistory, 0, len(custOrderIdLi))
 	custOrderStatusLi := make([]model.CustOrderStatus, 0, len(custOrderIdLi))
 	custOrderLi := make([]model.CustOrder, 0, len(custOrderIdLi))
 	projectMap := make(map[string]*meModel.Project)
+	workLineConfigMap := make(map[string]model.ReleaseTaskConfig)
 	for _, custOrderId := range custOrderIdLi {
 		// 校验客户订单是否存在及状态
 		orderData, err := custOrderDao.SelectOne(custOrderId)
@@ -60,7 +62,23 @@ func (impl *CustOrderServiceImplement) LockCustOrder(user *global.User, custOrde
 		if orderData.OrderStatus.Status != baseModel.WO_STATUS_PLANNED {
 			return grmi.NewBusinessError("客户订单当前状态不是已计划, 订单ID:" + custOrderId)
 		}
-		_, exist := projectMap[orderData.ProjectId]
+		_, exist := workLineConfigMap[orderData.WorkLineId]
+		if !exist {
+			configLi, err := configDao.Select([]grmi.Predicate{
+				meta.ReleaseTaskConfig_BusinessObjType.NewPredicate(grmi.Equal, model.CONFIG_TYPE_WORK_LINE),
+				meta.ReleaseTaskConfig_BusinessObjId.NewPredicate(grmi.Equal, orderData.WorkLineId),
+			}, nil)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError(fmt.Sprintf("查询产线%s的派工配置失败, 错误:%v", orderData.WorkLineId, err))
+			}
+			if len(configLi) == 0 {
+				_ = session.Rollback()
+				return grmi.NewBusinessError(fmt.Sprintf("产线%s的派工配置不存在", orderData.WorkLineId))
+			}
+			workLineConfigMap[orderData.WorkLineId] = configLi[0]
+		}
+		_, exist = projectMap[orderData.ProjectId]
 		if !exist {
 			project, err := projectDao.SelectOne(orderData.ProjectId)
 			if err != nil {
@@ -136,12 +154,20 @@ func (impl *CustOrderServiceImplement) LockCustOrder(user *global.User, custOrde
 		jUnix := itemJ.PlanStartTime.Restore().Unix()
 		return iUnix < jUnix
 	})
+	newReleaseTaskLi := make([]model.CustOrder, 0)
+	for _, custOrder := range custOrderLi {
+		config := workLineConfigMap[custOrder.WorkLineId]
+		duration := utils.CalcDurationByUom(float64(config.LeadTime), config.TimeUomId)
+		if custOrder.PlanStartTime.Restore().Add(-duration * time.Second).Unix() < time.Now().Unix() {
+			newReleaseTaskLi = append(newReleaseTaskLi, custOrder)
+		}
+	}
 	plantNr := user.PlantNr
 	channel, exist := common.ReleaseTaskChannel[plantNr]
 	if !exist {
 		return nil
 	}
-	for _, custOrder := range custOrderLi {
+	for _, custOrder := range newReleaseTaskLi {
 		err = channel.SendData(custOrder)
 		if err != nil {
 			return nil
@@ -163,6 +189,8 @@ func (impl *CustOrderServiceImplement) AnalysisPlanFromExcel(user *global.User,
 	productRelateDao := meDal.NewProductFamilyRelateDAO(session, user.PlantNr, user.UserId)
 	projectDao := meDal.NewProjectDAO(session, user.PlantNr, user.UserId)
 	snrDao := baseDal.NewSnrDAO(session, user.PlantNr, user.UserId)
+	configDao := dal.NewReleaseTaskConfigDAO(session, user.PlantNr, user.UserId)
+	workLineConfigMap := make(map[string]model.ReleaseTaskConfig)
 	file, err := excelize.OpenFile(filepath)
 	if err != nil {
 		return grmi.NewBusinessError("读取文件失败, error:" + err.Error())
@@ -318,6 +346,22 @@ func (impl *CustOrderServiceImplement) AnalysisPlanFromExcel(user *global.User,
 	}
 	// 占用流水号
 	for _, custOrder := range releaseCustOrderLi {
+		_, exist := workLineConfigMap[custOrder.WorkLineId]
+		if !exist {
+			configLi, err := configDao.Select([]grmi.Predicate{
+				meta.ReleaseTaskConfig_BusinessObjType.NewPredicate(grmi.Equal, model.CONFIG_TYPE_WORK_LINE),
+				meta.ReleaseTaskConfig_BusinessObjId.NewPredicate(grmi.Equal, custOrder.WorkLineId),
+			}, nil)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError(fmt.Sprintf("查询产线%s的派工配置失败, 错误:%v", custOrder.WorkLineId, err))
+			}
+			if len(configLi) == 0 {
+				_ = session.Rollback()
+				return grmi.NewBusinessError(fmt.Sprintf("产线%s的派工配置不存在", custOrder.WorkLineId))
+			}
+			workLineConfigMap[custOrder.WorkLineId] = configLi[0]
+		}
 		project := projectMap[custOrder.ProjectId]
 		productLi, err := productRelateDao.SelectProductByFamilyIdForCreateSerialOrder(custOrder.ProjectId, custOrder.ProductFamilyId)
 		if err != nil {
@@ -350,8 +394,6 @@ func (impl *CustOrderServiceImplement) AnalysisPlanFromExcel(user *global.User,
 		}
 	}
 	_ = session.Commit()
-	//newReleaseTaskLi := make([]model.CustOrder, 0)
-	//for _, custOrder := range
 	sort.Slice(releaseCustOrderLi, func(i, j int) bool {
 		itemI := releaseCustOrderLi[i]
 		itemJ := releaseCustOrderLi[j]
@@ -359,14 +401,21 @@ func (impl *CustOrderServiceImplement) AnalysisPlanFromExcel(user *global.User,
 		jUnix := itemJ.PlanStartTime.Restore().Unix()
 		return iUnix < jUnix
 	})
-
+	newReleaseTaskLi := make([]model.CustOrder, 0)
+	for _, custOrder := range releaseCustOrderLi {
+		config := workLineConfigMap[custOrder.WorkLineId]
+		duration := utils.CalcDurationByUom(float64(config.LeadTime), config.TimeUomId)
+		if custOrder.PlanStartTime.Restore().Add(-duration * time.Second).Unix() < time.Now().Unix() {
+			newReleaseTaskLi = append(newReleaseTaskLi, custOrder)
+		}
+	}
 	plantNr := user.PlantNr
 	channel, exist := common.ReleaseTaskChannel[plantNr]
 	if !exist {
 		fmt.Println(fmt.Sprintf("通道不存在, 工厂%d", plantNr))
 		return nil
 	}
-	for _, custOrder := range releaseCustOrderLi {
+	for _, custOrder := range newReleaseTaskLi {
 		err = channel.SendData(custOrder)
 		if err != nil {
 			fmt.Println("派工发送数据出错:" + err.Error())
@@ -415,7 +464,6 @@ func (impl *CustOrderServiceImplement) ReleaseSingleOrder(user *global.User, cus
 
 // ReleaseCustOrder 对客户订单进行派工
 func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custOrderData model.CustOrder, log logger.Log) error {
-
 	engine := db.Eloquent.Master()
 	session := engine.NewSession()
 	defer session.Close()
@@ -449,6 +497,13 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
 	if custOrderData.OrderStatus.Status == baseModel.WO_STATUS_RELEASED {
 		return nil
 	}
+	if custOrderData.OrderStatus.Status1 != baseModel.WO_STATUS_RUNNING {
+		custOrderData.OrderStatus.Status1 = baseModel.WO_STATUS_RUNNING
+		err = custOrderStatusDao.UpdateOne(&custOrderData.OrderStatus)
+		if err != nil {
+			return grmi.NewBusinessError("更新订单派工状态失败, 错误:" + err.Error())
+		}
+	}
 	// 创建serialOrder service接口
 	serialOrderSvr := omSvr.NewSerialOrderService()
 	// 查询当前是否有需要派工的custOrder
@@ -869,7 +924,7 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
 			}
 		}
 		if syncSnr {
-			serialNumber, err = snrDao.GetSnrFromOccupy(project.SerialOrderSnr, baseModel.SNR_OCCUPY_CUSTORDER, custOrderData.CustOrderId)
+			serialNumber, err = snrDao.GetNextSnrWithTime(project.SerialOrderSnr, waitReleaseSerialOrderLi[0].PlanStartTime.Restore())
 			if err != nil {
 				_ = session.Rollback()
 				return grmi.NewBusinessError("生成工单流水号失败, error:" + err.Error() + ", 流水号Id:" + project.SerialOrderSnr)
@@ -1066,14 +1121,6 @@ func (impl *CustOrderServiceImplement) ReleaseCustOrder(user *global.User, custO
 				return grmi.NewBusinessError("写入跨工厂任务失败, 错误:" + err.Error())
 			}
 		}
-		if custOrderData.OrderQty.ReleasedQty == 1 {
-			custOrderData.OrderStatus.Status1 = baseModel.WO_STATUS_RUNNING
-			err = custOrderStatusDao.UpdateOne(&custOrderData.OrderStatus)
-			if err != nil {
-				_ = session.Rollback()
-				return grmi.NewBusinessError("更新订单派工状态失败, 错误:" + err.Error())
-			}
-		}
 		_ = session.Commit()
 	}
 	if custOrderData.OrderQty.PlanQty == custOrderData.OrderQty.ReleasedQty+custOrderData.OrderQty.CancelQty {
@@ -1376,7 +1423,7 @@ func (impl *CustOrderServiceImplement) ManualReleaseCustOrder(user *global.User,
 		fmt.Println(fmt.Sprintf("通道不存在, 工厂%d", custOrder.PlantNr))
 		return nil
 	}
-	err = channel.SendData(custOrder)
+	err = channel.SendData(*custOrder)
 	if err != nil {
 		return grmi.NewBusinessError("派工发送数据出错:" + err.Error())
 	}

web/controllers/pln/ReleaseTaskConfig.rest.go

@@ -432,7 +432,7 @@ func RegisterSaveReleaseTaskConfig(party router.Party, path string, method func(
 
 func RegisterSelectConfig(party router.Party, path string, method func(user *global.User, objType, objId string) (*model.ReleaseTaskConfig, error)) {
 
-	party.Post(path, func(ctx iris.Context) {
+	party.Get(path, func(ctx iris.Context) {
 		user, ok := jwts.ParseToken(ctx)
 		if !ok {
 			supports.Error(ctx, iris.StatusBadRequest, supports.ParseParamsFailur, nil)