修改生成BOM的逻辑

services/om/implments/WorkOrder.service.impl.go

@@ -6,6 +6,7 @@ import (
 	baseDal "LAPP_LF_MOM_BACKEND/dao/base"
 	meDal "LAPP_LF_MOM_BACKEND/dao/me"
 	baseMeta "LAPP_LF_MOM_BACKEND/meta/base"
+	meModel "LAPP_LF_MOM_BACKEND/models/me"
 	"fmt"
 	"github.com/go-xorm/xorm"
 	"strings"
@@ -15,6 +16,7 @@ import (
 	"LAPP_LF_MOM_BACKEND/db"
 	"LAPP_LF_MOM_BACKEND/grmi"
 	"LAPP_LF_MOM_BACKEND/infra/logger"
+	meMeta "LAPP_LF_MOM_BACKEND/meta/me"
 	//logMeta "LAPP_LF_MOM_BACKEND/meta/log"
 	meta "LAPP_LF_MOM_BACKEND/meta/om"
 	baseModel "LAPP_LF_MOM_BACKEND/models/base"
@@ -865,314 +867,314 @@ func (impl WorkOrderServiceImplement) CancelWorkOrder(user *models.Usertab, work
 func (impl *WorkOrderServiceImplement) LockWorkOrder(user *models.Usertab, workOrderIds []string) ([]model.LockedResponseWorkOrder, error) {
 	grmi.Log(user, "/services/om/implments/WorkOrder.service.impl.go", "LockWorkOrder", "锁定workOrder")
 	result := make([]model.LockedResponseWorkOrder, 0, len(workOrderIds))
-	engine := db.Eloquent.Master()
-	session := engine.NewSession()
-	defer session.Close()
-	err := session.Begin()
-	if err != nil {
-		return nil, err
-	}
-	dao := dal.NewSerialOrderDAO(session, user.Pid, user.Userid)
-	workOrderDao := dal.NewWorkOrderDAO(session, user.Pid, user.Userid)
-	workOrderStatusDao := dal.NewWorkOrderStatusDAO(session, user.Pid, user.Userid)
-	workOrderStatusRecDao := dal.NewWorkOrderStatusRecLstDAO(session, user.Pid, user.Userid)
-	serialOrderStatusDao := dal.NewSerialOrderStatusDAO(session, user.Pid, user.Userid)
-	projectDao := meDal.NewProjectDAO(session, user.Pid, user.Userid)
-	operationDao := baseDal.NewOperationDAO(session, user.Pid, user.Userid)
-	PODao := dal.NewSerialOrderPOLstDAO(session, user.Pid, user.Userid)
-	stepDao := dal.NewSerialOrderStepLstDAO(session, user.Pid, user.Userid)
-	artRelDao := baseDal.NewArticleRelLstDAO(session, user.Pid, user.Userid)
-	articleWithAttrDao := baseDal.NewArticleAtcodLstDAO(session, user.Pid, user.Userid)
-	scanRuleDao := baseDal.NewScanRuleInfoDAO(session, user.Pid, user.Userid)
-	guideDao := baseDal.NewGuideRuleInfoDAO(session, user.Pid, user.Userid)
-	// 获取项目数据 用于获取流水号
-	project, err := projectDao.SelectOne(baseModel.ProjectId)
-	if err != nil {
-		_ = session.Rollback()
-		return nil, grmi.NewBusinessError("获取项目数据失败, error:" + err.Error())
-	}
-	if project == nil {
-		_ = session.Rollback()
-		return nil, grmi.NewBusinessError("不存在该项目数据")
-	}
-	attributeLi, err := articleWithAttrDao.SelectAllWithAttrValue()
-	if err != nil {
-		_ = session.Rollback()
-		return nil, grmi.NewBusinessError("查询零件属性失败,error:" + err.Error())
-	}
-	attributeMap := make(map[int][]baseModel.ArticleWithAttrValue)
-	for _, data := range attributeLi {
-		_, exist := attributeMap[data.ArticleAtcodLst.AttrCode]
-		if !exist {
-			attributeMap[data.ArticleAtcodLst.AttrCode] = make([]baseModel.ArticleWithAttrValue, 0)
-		}
-		attributeMap[data.ArticleAtcodLst.AttrCode] = append(attributeMap[data.ArticleAtcodLst.AttrCode], data)
-	}
-	scanRuleLi, err := scanRuleDao.Select(nil, nil)
-	if err != nil {
-		_ = session.Rollback()
-		return nil, grmi.NewBusinessError("查询扫码校验条码失败, error:" + err.Error())
-	}
-	scanRuleMap := make(map[int]baseModel.ScanRuleInfo)
-	for _, scanRule := range scanRuleLi {
-		scanRuleMap[scanRule.OperationId] = scanRule
-	}
-	guideRuleLi, err := guideDao.Select(nil, nil)
-	if err != nil {
-		_ = session.Rollback()
-		return nil, grmi.NewBusinessError("查询指导操作规则失败, error:" + err.Error())
-	}
-	guideRuleMap := make(map[int]baseModel.GuideRuleInfo, len(guideRuleLi))
-	for _, guideRule := range guideRuleLi {
-		guideRuleMap[guideRule.OperationId] = guideRule
-	}
-	// 进入业务处理逻辑
-	for _, workOrderId := range workOrderIds {
-		// 进行对应的批次工单数据校验
-		vomWorkOrder, err := workOrderDao.SelectOneJoin(workOrderId)
-		if err != nil {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("获取批次工单数据失败,error:" + err.Error())
-		}
-		if vomWorkOrder == nil {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("不存在对应的workOrder, workOrderId:" + workOrderId)
-		}
-
-		if vomWorkOrder.WorkOrderStatus.Status != baseModel.WO_STATUS_PLANNED {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("对应的workOrderStatus 不是 WO_STATUS_PLANNED，workOrderId:" + workOrderId)
-		}
-		// 检测在系统中对用的批次工单是否存在对应的序列工单
-		serialOrderLi, err := dao.Select([]grmi.Predicate{meta.SerialOrder_WorkOrderId.NewPredicate(grmi.Equal, workOrderId)}, nil)
-		if err != nil {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("查询原有序列工单数据失败, error:" + err.Error())
-		}
-		if len(serialOrderLi) > 0 {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("已存在对应的SerialOrder, workOrderId:" + workOrderId)
-		}
-		serialOrderLi = make([]model.SerialOrder, 0, int(vomWorkOrder.WorkOrder.PlanQty))
-		serialOrderStatusLi := make([]model.SerialOrderStatus, 0, int(vomWorkOrder.WorkOrder.PlanQty))
-		if vomWorkOrder.WorkOrder.PlanQty == 0 {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("订单的计划数量为0,workOrderID:" + workOrderId)
-		}
-		// 进行批次工单的时间拆解到序列工单的计划时间上
-		endTime := vomWorkOrder.WorkOrder.PlanEndTime.Restore()
-		now := time.Now()
-		var perDuration float64
-		if !now.Before(endTime) {
-			perDuration = 0
-		} else {
-			perDuration = endTime.Sub(now).Seconds() / vomWorkOrder.WorkOrder.PlanQty
-		}
-		// 生成序列工单
-		for i := 0; i < int(vomWorkOrder.WorkOrder.PlanQty); i++ {
-			snr := new(models.Snrtab)
-			snr.Finr = user.Pid
-			serialNum, err := snr.GetNextSnrWithSession(session, project.SerialOrderSnr)
-			if err != nil {
-				_ = session.Rollback()
-				return nil, grmi.NewBusinessError("获取序列工单流水号失败, error:" + err.Error())
-			}
-			planStartDate := vomWorkOrder.WorkOrder.PlanStartDate.Restore().Format("20060102")
-			prefix := vomWorkOrder.WorkOrder.ArtId + baseModel.PlantName + planStartDate
-			serialOrderId := strings.Replace(serialNum, "SO-", prefix, 1)
-			var planEndTime time.Time
-			if perDuration != 0 {
-				planEndTime = now.Add(time.Duration(perDuration*float64(i+1)) * time.Second)
-			} else {
-				planEndTime = vomWorkOrder.WorkOrder.PlanEndTime.Restore()
-			}
-			serialOrder := model.SerialOrder{
-				WorkOrderId:    workOrderId,
-				SerialOrderId:  serialOrderId,
-				ArtId:          vomWorkOrder.WorkOrder.ArtId,
-				OrderType1:     vomWorkOrder.WorkOrder.OrderType1,
-				OrderType2:     vomWorkOrder.WorkOrder.OrderType2,
-				PlanResourceId: vomWorkOrder.WorkOrder.PlanResourceId,
-				UsedResourceId: vomWorkOrder.WorkOrder.UsedResourceId,
-				PlanQty:        1,
-				QtyUomId:       vomWorkOrder.WorkOrder.QtyUomId,
-				OpTimePerItem:  vomWorkOrder.WorkOrder.OpTimePerItem,
-				TimeUomId:      vomWorkOrder.WorkOrder.TimeUomId,
-				PlanStartDate:  vomWorkOrder.WorkOrder.PlanStartDate,
-				PlanEndDate:    vomWorkOrder.WorkOrder.PlanEndDate,
-				SetupStartTime: vomWorkOrder.WorkOrder.SetupStartTime,
-				SetupEndTime:   vomWorkOrder.WorkOrder.SetupEndTime,
-				PlanStartTime:  vomWorkOrder.WorkOrder.PlanStartTime,
-				PlanEndTime:    grmi.DateTime(planEndTime),
-				ActStartTime:   vomWorkOrder.WorkOrder.ActStartTime,
-				ActEndTime:     vomWorkOrder.WorkOrder.ActEndTime,
-				ProjectId:      vomWorkOrder.WorkOrder.ProjectId,
-			}
-			serialOrderLi = append(serialOrderLi, serialOrder)
-			serialStatus := model.SerialOrderStatus{
-				Status:        baseModel.WO_STATUS_LOCKED,
-				SerialOrderId: serialOrderId,
-			}
-			serialOrderStatusLi = append(serialOrderStatusLi, serialStatus)
-		}
-		for _, serialOrder := range serialOrderLi {
-			err = dao.InsertOne(&serialOrder)
-			if err != nil {
-				_ = session.Rollback()
-				return nil, grmi.NewBusinessError("插入序列工单数据失败,error:" + err.Error())
-			}
-		}
-		for _, serialOrderStatus := range serialOrderStatusLi {
-			err = serialOrderStatusDao.InsertOne(&serialOrderStatus)
-			if err != nil {
-				_ = session.Rollback()
-				return nil, grmi.NewBusinessError("插入序列工单状态失败,error:" + err.Error())
-			}
-		}
-		// 修改批次工单状态 并记录状态变化
-		workOrderStatusRec := model.WorkOrderStatusRecLst{
-			WorkOrderId:        workOrderId,
-			PrevStatus:         vomWorkOrder.WorkOrderStatus.Status,
-			Status:             baseModel.WO_STATUS_LOCKED,
-			StartTime:          vomWorkOrder.WorkOrder.PlanStartTime,
-			EndTime:            vomWorkOrder.WorkOrder.PlanEndTime,
-			OutputEvent:        baseModel.BATORD_EVENT_LOCK,
-			OutputStatus:       baseModel.OUTPUT_TRIGGER_UNHANDLED,
-			TriggerObjectId:    vomWorkOrder.WorkOrderStatus.TriggerObjectId,
-			TriggerSubObjectId: vomWorkOrder.WorkOrderStatus.TriggerSubObjectId,
-		}
-		err = workOrderStatusRecDao.InsertOne(&workOrderStatusRec)
-		if err != nil {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("插入批次工单状态数据失败,error:" + err.Error())
-		}
-		vomWorkOrder.WorkOrderStatus.Status = baseModel.WO_STATUS_LOCKED
-		err = workOrderStatusDao.UpdateOne(&vomWorkOrder.WorkOrderStatus)
-		if err != nil {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("更新批次工单状态失败,error:" + err.Error())
-		}
-		artId := vomWorkOrder.WorkOrder.ArtId
-		// 生成序列工单对应的工艺数据
-		articleLi, err := artRelDao.Select([]grmi.Predicate{baseMeta.ArticleRelLst_PID.NewPredicate(grmi.Equal, artId)}, nil)
-		if err != nil {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("获取物料关联关系失败, error:" + err.Error())
-		}
-		if len(articleLi) == 0 {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("未获取到零件关联关系")
-		}
-		artIdLi := make([]string, 0, len(articleLi))
-		artRelMap := make(map[string]baseModel.ArticleRelLst)
-		for _, article := range articleLi {
-			artIdLi = append(artIdLi, article.ArtId)
-			artRelMap[article.ArtId] = article
-		}
-		subArtMap := make(map[string]interface{})
-		for _, artId := range artIdLi {
-			subArtMap[artId] = nil
-		}
-		opLi, err := operationDao.GetOperationRelData(artIdLi, vomWorkOrder.WorkOrder.PlanResourceId)
-		if err != nil {
-			_ = session.Rollback()
-			return nil, grmi.NewBusinessError("获取工艺操作失败,error:" + err.Error())
-		}
-		allocateMap := make(map[string][]baseModel.ArtQtyAllocate)
-		checkRuleMap := make(map[string]baseModel.ArtCheckRule)
-		opcBasicMap := make(map[int][]baseModel.OPCBasicComInfo)
-		twMap := make(map[int][]baseModel.TightenWrenchInfo)
-		for _, serialOrderStatus := range serialOrderStatusLi {
-			var PO int
-			processPos := 1
-			opPos := 1
-			for _, op := range opLi {
-
-				if PO != op.Process.PO {
-					PO = op.Process.PO
-					serialOrderWorkPlace := model.SerialOrderPOLst{
-						SerialOrderId: serialOrderStatus.SerialOrderId,
-						PO:            PO,
-						Status:        baseModel.WO_STATUS_LOCKED,
-						HasDependOn:   op.Process.HasDependOn,
-					}
-					err = PODao.InsertOne(&serialOrderWorkPlace)
-					if err != nil {
-						_ = session.Rollback()
-						return nil, grmi.NewBusinessError("插入serialOrder工序数据失败,error:" + err.Error())
-					}
-					processPos++
-
-				}
-				serialOrderStep := model.SerialOrderStepLst{
-					PO:            op.Process.PO,
-					OperationId:   op.OperationId,
-					SerialOrderId: serialOrderStatus.SerialOrderId,
-					StepNo:        op.Operation.StepNo,
-					Pos:           opPos,
-					SubArtId:      op.ArticleAtcodLst.ArtId,
-					StepDesc:      op.Operation.StepDesc,
-					AttrCode:      op.ArticleAtcodLst.AttrCode,
-					AttrValue:     op.ArticleAtcodLst.AttrValue,
-					StepType:      op.Operation.StepType,
-					Status:        baseModel.WO_STATUS_LOCKED,
-				}
-				opPos++
-				err = stepDao.InsertOne(&serialOrderStep)
-				if err != nil {
-					_ = session.Rollback()
-
-					return nil, grmi.NewBusinessError("插入序列工单工艺数据失败, error:" + err.Error())
-				}
-				if serialOrderStep.StepType == baseModel.STEP_CHECK_RULE { // 生成扫码校验的工艺数据
-					scanRule, exist := scanRuleMap[serialOrderStep.OperationId]
-					if !exist {
-						return nil, grmi.NewBusinessError("未获取到扫描校验详细规则")
-					}
-
-					checkRuleMapPointer, allocateMapPointer, err := impl.ScanCodeCheck(user, session, checkRuleMap, allocateMap, artRelMap, &scanRule, &op, &serialOrderStep)
-					if err != nil {
-						_ = session.Rollback()
-						return nil, err
-					}
-					checkRuleMap = *checkRuleMapPointer
-					allocateMap = *allocateMapPointer
-				} else if serialOrderStep.StepType == baseModel.STEP_OPC_RULE { // 生成OPC通讯的工艺数据
-					opcBasicMapPointer, err := impl.OPCCommunication(user, session, opcBasicMap, &serialOrderStep, attributeMap, workOrderId, subArtMap)
-					if err != nil {
-						_ = session.Rollback()
-						return nil, err
-					}
-					opcBasicMap = *opcBasicMapPointer
-				} else if serialOrderStep.StepType == baseModel.STEP_TW_RULE { // 生成开发协议的工艺数据
-					twMapPointer, err := impl.TightenWrenchInfo(user, session, twMap, &serialOrderStep)
-					if err != nil {
-						_ = session.Rollback()
-						return nil, err
-					}
-					twMap = *twMapPointer
-				} else if serialOrderStep.StepType == baseModel.STEP_GUIDE_RULE {
-					guideRule, exist := guideRuleMap[serialOrderStep.OperationId]
-					if !exist {
-						_ = session.Rollback()
-						return nil, grmi.NewBusinessError("未获取到指导操作的详细规则")
-					}
-					err = impl.GuideRuleInfo(user, session, &guideRule, &serialOrderStep)
-					if err != nil {
-						_ = session.Rollback()
-						return nil, err
-					}
-				} else {
-					_ = session.Rollback()
-					return nil, grmi.NewBusinessError("获取到的工艺数据系统暂不支持该操作类型:" + serialOrderStep.StepType)
-				}
-			}
-		}
-
-		lockedWorkOrder := model.LockedResponseWorkOrder{WorkOrderId: workOrderId, Status: baseModel.WO_STATUS_LOCKED}
-		result = append(result, lockedWorkOrder)
-	}
-	_ = session.Commit()
+	//engine := db.Eloquent.Master()
+	//session := engine.NewSession()
+	//defer session.Close()
+	//err := session.Begin()
+	//if err != nil {
+	//	return nil, err
+	//}
+	//dao := dal.NewSerialOrderDAO(session, user.Pid, user.Userid)
+	//workOrderDao := dal.NewWorkOrderDAO(session, user.Pid, user.Userid)
+	//workOrderStatusDao := dal.NewWorkOrderStatusDAO(session, user.Pid, user.Userid)
+	//workOrderStatusRecDao := dal.NewWorkOrderStatusRecLstDAO(session, user.Pid, user.Userid)
+	//serialOrderStatusDao := dal.NewSerialOrderStatusDAO(session, user.Pid, user.Userid)
+	//projectDao := meDal.NewProjectDAO(session, user.Pid, user.Userid)
+	//operationDao := baseDal.NewOperationDAO(session, user.Pid, user.Userid)
+	//PODao := dal.NewSerialOrderPOLstDAO(session, user.Pid, user.Userid)
+	//stepDao := dal.NewSerialOrderStepLstDAO(session, user.Pid, user.Userid)
+	//artRelDao := baseDal.NewArticleRelLstDAO(session, user.Pid, user.Userid)
+	//articleWithAttrDao := baseDal.NewArticleAtcodLstDAO(session, user.Pid, user.Userid)
+	//scanRuleDao := baseDal.NewScanRuleInfoDAO(session, user.Pid, user.Userid)
+	//guideDao := baseDal.NewGuideRuleInfoDAO(session, user.Pid, user.Userid)
+	//// 获取项目数据 用于获取流水号
+	//project, err := projectDao.SelectOne(baseModel.ProjectId)
+	//if err != nil {
+	//	_ = session.Rollback()
+	//	return nil, grmi.NewBusinessError("获取项目数据失败, error:" + err.Error())
+	//}
+	//if project == nil {
+	//	_ = session.Rollback()
+	//	return nil, grmi.NewBusinessError("不存在该项目数据")
+	//}
+	//attributeLi, err := articleWithAttrDao.SelectAllWithAttrValue()
+	//if err != nil {
+	//	_ = session.Rollback()
+	//	return nil, grmi.NewBusinessError("查询零件属性失败,error:" + err.Error())
+	//}
+	//attributeMap := make(map[int][]baseModel.ArticleWithAttrValue)
+	//for _, data := range attributeLi {
+	//	_, exist := attributeMap[data.ArticleAtcodLst.AttrCode]
+	//	if !exist {
+	//		attributeMap[data.ArticleAtcodLst.AttrCode] = make([]baseModel.ArticleWithAttrValue, 0)
+	//	}
+	//	attributeMap[data.ArticleAtcodLst.AttrCode] = append(attributeMap[data.ArticleAtcodLst.AttrCode], data)
+	//}
+	//scanRuleLi, err := scanRuleDao.Select(nil, nil)
+	//if err != nil {
+	//	_ = session.Rollback()
+	//	return nil, grmi.NewBusinessError("查询扫码校验条码失败, error:" + err.Error())
+	//}
+	//scanRuleMap := make(map[int]baseModel.ScanRuleInfo)
+	//for _, scanRule := range scanRuleLi {
+	//	scanRuleMap[scanRule.OperationId] = scanRule
+	//}
+	//guideRuleLi, err := guideDao.Select(nil, nil)
+	//if err != nil {
+	//	_ = session.Rollback()
+	//	return nil, grmi.NewBusinessError("查询指导操作规则失败, error:" + err.Error())
+	//}
+	//guideRuleMap := make(map[int]baseModel.GuideRuleInfo, len(guideRuleLi))
+	//for _, guideRule := range guideRuleLi {
+	//	guideRuleMap[guideRule.OperationId] = guideRule
+	//}
+	//// 进入业务处理逻辑
+	//for _, workOrderId := range workOrderIds {
+	//	// 进行对应的批次工单数据校验
+	//	vomWorkOrder, err := workOrderDao.SelectOneJoin(workOrderId)
+	//	if err != nil {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("获取批次工单数据失败,error:" + err.Error())
+	//	}
+	//	if vomWorkOrder == nil {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("不存在对应的workOrder, workOrderId:" + workOrderId)
+	//	}
+	//
+	//	if vomWorkOrder.WorkOrderStatus.Status != baseModel.WO_STATUS_PLANNED {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("对应的workOrderStatus 不是 WO_STATUS_PLANNED，workOrderId:" + workOrderId)
+	//	}
+	//	// 检测在系统中对用的批次工单是否存在对应的序列工单
+	//	serialOrderLi, err := dao.Select([]grmi.Predicate{meta.SerialOrder_WorkOrderId.NewPredicate(grmi.Equal, workOrderId)}, nil)
+	//	if err != nil {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("查询原有序列工单数据失败, error:" + err.Error())
+	//	}
+	//	if len(serialOrderLi) > 0 {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("已存在对应的SerialOrder, workOrderId:" + workOrderId)
+	//	}
+	//	serialOrderLi = make([]model.SerialOrder, 0, int(vomWorkOrder.WorkOrder.PlanQty))
+	//	serialOrderStatusLi := make([]model.SerialOrderStatus, 0, int(vomWorkOrder.WorkOrder.PlanQty))
+	//	if vomWorkOrder.WorkOrder.PlanQty == 0 {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("订单的计划数量为0,workOrderID:" + workOrderId)
+	//	}
+	//	// 进行批次工单的时间拆解到序列工单的计划时间上
+	//	endTime := vomWorkOrder.WorkOrder.PlanEndTime.Restore()
+	//	now := time.Now()
+	//	var perDuration float64
+	//	if !now.Before(endTime) {
+	//		perDuration = 0
+	//	} else {
+	//		perDuration = endTime.Sub(now).Seconds() / vomWorkOrder.WorkOrder.PlanQty
+	//	}
+	//	// 生成序列工单
+	//	for i := 0; i < int(vomWorkOrder.WorkOrder.PlanQty); i++ {
+	//		snr := new(models.Snrtab)
+	//		snr.Finr = user.Pid
+	//		serialNum, err := snr.GetNextSnrWithSession(session, project.SerialOrderSnr)
+	//		if err != nil {
+	//			_ = session.Rollback()
+	//			return nil, grmi.NewBusinessError("获取序列工单流水号失败, error:" + err.Error())
+	//		}
+	//		planStartDate := vomWorkOrder.WorkOrder.PlanStartDate.Restore().Format("20060102")
+	//		prefix := vomWorkOrder.WorkOrder.ArtId + baseModel.PlantName + planStartDate
+	//		serialOrderId := strings.Replace(serialNum, "SO-", prefix, 1)
+	//		var planEndTime time.Time
+	//		if perDuration != 0 {
+	//			planEndTime = now.Add(time.Duration(perDuration*float64(i+1)) * time.Second)
+	//		} else {
+	//			planEndTime = vomWorkOrder.WorkOrder.PlanEndTime.Restore()
+	//		}
+	//		serialOrder := model.SerialOrder{
+	//			WorkOrderId:    workOrderId,
+	//			SerialOrderId:  serialOrderId,
+	//			ArtId:          vomWorkOrder.WorkOrder.ArtId,
+	//			OrderType1:     vomWorkOrder.WorkOrder.OrderType1,
+	//			OrderType2:     vomWorkOrder.WorkOrder.OrderType2,
+	//			PlanResourceId: vomWorkOrder.WorkOrder.PlanResourceId,
+	//			UsedResourceId: vomWorkOrder.WorkOrder.UsedResourceId,
+	//			PlanQty:        1,
+	//			QtyUomId:       vomWorkOrder.WorkOrder.QtyUomId,
+	//			OpTimePerItem:  vomWorkOrder.WorkOrder.OpTimePerItem,
+	//			TimeUomId:      vomWorkOrder.WorkOrder.TimeUomId,
+	//			PlanStartDate:  vomWorkOrder.WorkOrder.PlanStartDate,
+	//			PlanEndDate:    vomWorkOrder.WorkOrder.PlanEndDate,
+	//			SetupStartTime: vomWorkOrder.WorkOrder.SetupStartTime,
+	//			SetupEndTime:   vomWorkOrder.WorkOrder.SetupEndTime,
+	//			PlanStartTime:  vomWorkOrder.WorkOrder.PlanStartTime,
+	//			PlanEndTime:    grmi.DateTime(planEndTime),
+	//			ActStartTime:   vomWorkOrder.WorkOrder.ActStartTime,
+	//			ActEndTime:     vomWorkOrder.WorkOrder.ActEndTime,
+	//			ProjectId:      vomWorkOrder.WorkOrder.ProjectId,
+	//		}
+	//		serialOrderLi = append(serialOrderLi, serialOrder)
+	//		serialStatus := model.SerialOrderStatus{
+	//			Status:        baseModel.WO_STATUS_LOCKED,
+	//			SerialOrderId: serialOrderId,
+	//		}
+	//		serialOrderStatusLi = append(serialOrderStatusLi, serialStatus)
+	//	}
+	//	for _, serialOrder := range serialOrderLi {
+	//		err = dao.InsertOne(&serialOrder)
+	//		if err != nil {
+	//			_ = session.Rollback()
+	//			return nil, grmi.NewBusinessError("插入序列工单数据失败,error:" + err.Error())
+	//		}
+	//	}
+	//	for _, serialOrderStatus := range serialOrderStatusLi {
+	//		err = serialOrderStatusDao.InsertOne(&serialOrderStatus)
+	//		if err != nil {
+	//			_ = session.Rollback()
+	//			return nil, grmi.NewBusinessError("插入序列工单状态失败,error:" + err.Error())
+	//		}
+	//	}
+	//	// 修改批次工单状态 并记录状态变化
+	//	workOrderStatusRec := model.WorkOrderStatusRecLst{
+	//		WorkOrderId:        workOrderId,
+	//		PrevStatus:         vomWorkOrder.WorkOrderStatus.Status,
+	//		Status:             baseModel.WO_STATUS_LOCKED,
+	//		StartTime:          vomWorkOrder.WorkOrder.PlanStartTime,
+	//		EndTime:            vomWorkOrder.WorkOrder.PlanEndTime,
+	//		OutputEvent:        baseModel.BATORD_EVENT_LOCK,
+	//		OutputStatus:       baseModel.OUTPUT_TRIGGER_UNHANDLED,
+	//		TriggerObjectId:    vomWorkOrder.WorkOrderStatus.TriggerObjectId,
+	//		TriggerSubObjectId: vomWorkOrder.WorkOrderStatus.TriggerSubObjectId,
+	//	}
+	//	err = workOrderStatusRecDao.InsertOne(&workOrderStatusRec)
+	//	if err != nil {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("插入批次工单状态数据失败,error:" + err.Error())
+	//	}
+	//	vomWorkOrder.WorkOrderStatus.Status = baseModel.WO_STATUS_LOCKED
+	//	err = workOrderStatusDao.UpdateOne(&vomWorkOrder.WorkOrderStatus)
+	//	if err != nil {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("更新批次工单状态失败,error:" + err.Error())
+	//	}
+	//	artId := vomWorkOrder.WorkOrder.ArtId
+	//	// 生成序列工单对应的工艺数据
+	//	articleLi, err := artRelDao.Select([]grmi.Predicate{baseMeta.ArticleRelLst_PID.NewPredicate(grmi.Equal, artId)}, nil)
+	//	if err != nil {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("获取物料关联关系失败, error:" + err.Error())
+	//	}
+	//	if len(articleLi) == 0 {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("未获取到零件关联关系")
+	//	}
+	//	artIdLi := make([]string, 0, len(articleLi))
+	//	artRelMap := make(map[string]baseModel.ArticleRelLst)
+	//	for _, article := range articleLi {
+	//		artIdLi = append(artIdLi, article.ArtId)
+	//		artRelMap[article.ArtId] = article
+	//	}
+	//	subArtMap := make(map[string]interface{})
+	//	for _, artId := range artIdLi {
+	//		subArtMap[artId] = nil
+	//	}
+	//	opLi, err := operationDao.GetOperationRelData(artIdLi, vomWorkOrder.WorkOrder.PlanResourceId)
+	//	if err != nil {
+	//		_ = session.Rollback()
+	//		return nil, grmi.NewBusinessError("获取工艺操作失败,error:" + err.Error())
+	//	}
+	//	allocateMap := make(map[string][]baseModel.ArtQtyAllocate)
+	//	checkRuleMap := make(map[string]baseModel.ArtCheckRule)
+	//	opcBasicMap := make(map[int][]baseModel.OPCBasicComInfo)
+	//	twMap := make(map[int][]baseModel.TightenWrenchInfo)
+	//	for _, serialOrderStatus := range serialOrderStatusLi {
+	//		var PO int
+	//		processPos := 1
+	//		opPos := 1
+	//		for _, op := range opLi {
+	//
+	//			if PO != op.Process.PO {
+	//				PO = op.Process.PO
+	//				serialOrderWorkPlace := model.SerialOrderPOLst{
+	//					SerialOrderId: serialOrderStatus.SerialOrderId,
+	//					PO:            PO,
+	//					Status:        baseModel.WO_STATUS_LOCKED,
+	//					HasDependOn:   op.Process.HasDependOn,
+	//				}
+	//				err = PODao.InsertOne(&serialOrderWorkPlace)
+	//				if err != nil {
+	//					_ = session.Rollback()
+	//					return nil, grmi.NewBusinessError("插入serialOrder工序数据失败,error:" + err.Error())
+	//				}
+	//				processPos++
+	//
+	//			}
+	//			serialOrderStep := model.SerialOrderStepLst{
+	//				PO:            op.Process.PO,
+	//				OperationId:   op.OperationId,
+	//				SerialOrderId: serialOrderStatus.SerialOrderId,
+	//				StepNo:        op.Operation.StepNo,
+	//				Pos:           opPos,
+	//				SubArtId:      op.ArticleAtcodLst.ArtId,
+	//				StepDesc:      op.Operation.StepDesc,
+	//				AttrCode:      op.ArticleAtcodLst.AttrCode,
+	//				AttrValue:     op.ArticleAtcodLst.AttrValue,
+	//				StepType:      op.Operation.StepType,
+	//				Status:        baseModel.WO_STATUS_LOCKED,
+	//			}
+	//			opPos++
+	//			err = stepDao.InsertOne(&serialOrderStep)
+	//			if err != nil {
+	//				_ = session.Rollback()
+	//
+	//				return nil, grmi.NewBusinessError("插入序列工单工艺数据失败, error:" + err.Error())
+	//			}
+	//			if serialOrderStep.StepType == baseModel.STEP_CHECK_RULE { // 生成扫码校验的工艺数据
+	//				scanRule, exist := scanRuleMap[serialOrderStep.OperationId]
+	//				if !exist {
+	//					return nil, grmi.NewBusinessError("未获取到扫描校验详细规则")
+	//				}
+	//
+	//				checkRuleMapPointer, allocateMapPointer, err := impl.ScanCodeCheck(user, session, checkRuleMap, allocateMap, artRelMap, &scanRule, &op, &serialOrderStep)
+	//				if err != nil {
+	//					_ = session.Rollback()
+	//					return nil, err
+	//				}
+	//				checkRuleMap = *checkRuleMapPointer
+	//				allocateMap = *allocateMapPointer
+	//			} else if serialOrderStep.StepType == baseModel.STEP_OPC_RULE { // 生成OPC通讯的工艺数据
+	//				opcBasicMapPointer, err := impl.OPCCommunication(user, session, opcBasicMap, &serialOrderStep, attributeMap, workOrderId, subArtMap)
+	//				if err != nil {
+	//					_ = session.Rollback()
+	//					return nil, err
+	//				}
+	//				opcBasicMap = *opcBasicMapPointer
+	//			} else if serialOrderStep.StepType == baseModel.STEP_TW_RULE { // 生成开发协议的工艺数据
+	//				twMapPointer, err := impl.TightenWrenchInfo(user, session, twMap, &serialOrderStep)
+	//				if err != nil {
+	//					_ = session.Rollback()
+	//					return nil, err
+	//				}
+	//				twMap = *twMapPointer
+	//			} else if serialOrderStep.StepType == baseModel.STEP_GUIDE_RULE {
+	//				guideRule, exist := guideRuleMap[serialOrderStep.OperationId]
+	//				if !exist {
+	//					_ = session.Rollback()
+	//					return nil, grmi.NewBusinessError("未获取到指导操作的详细规则")
+	//				}
+	//				err = impl.GuideRuleInfo(user, session, &guideRule, &serialOrderStep)
+	//				if err != nil {
+	//					_ = session.Rollback()
+	//					return nil, err
+	//				}
+	//			} else {
+	//				_ = session.Rollback()
+	//				return nil, grmi.NewBusinessError("获取到的工艺数据系统暂不支持该操作类型:" + serialOrderStep.StepType)
+	//			}
+	//		}
+	//	}
+	//
+	//	lockedWorkOrder := model.LockedResponseWorkOrder{WorkOrderId: workOrderId, Status: baseModel.WO_STATUS_LOCKED}
+	//	result = append(result, lockedWorkOrder)
+	//}
+	//_ = session.Commit()
 	return result, nil
 }
 
@@ -1181,7 +1183,7 @@ func (impl *WorkOrderServiceImplement) LockWorkOrder(user *models.Usertab, workO
 * @Reference LAPP_LF_MOM_BACKEND/services/om/WorkOrderService.ScanCodeCheck   生成扫码校验的工艺数据
 *
 ******************************************************************************/
-func (impl *WorkOrderServiceImplement) ScanCodeCheck(user *models.Usertab, session *xorm.Session, checkRuleMap map[string]baseModel.ArtCheckRule, allocateMap map[string][]baseModel.ArtQtyAllocate, artRelMap map[string]baseModel.ArticleRelLst, scanRule *baseModel.ScanRuleInfo, op *baseModel.OperationRelData, serialOrderStep *model.SerialOrderStepLst) (resCheckRuleMap *map[string]baseModel.ArtCheckRule, resAllocateMap *map[string][]baseModel.ArtQtyAllocate, err error) {
+func (impl *WorkOrderServiceImplement) ScanCodeCheck(user *models.Usertab, session *xorm.Session, checkRuleMap map[string]baseModel.ArtCheckRule, allocateMap map[string][]baseModel.ArtQtyAllocate, artRelMap map[string]int, scanRule *baseModel.ScanRuleInfo, op *baseModel.OperationRelData, serialOrderStep *model.SerialOrderStepLst) (resCheckRuleMap *map[string]baseModel.ArtCheckRule, resAllocateMap *map[string][]baseModel.ArtQtyAllocate, err error) {
 	ruleDao := baseDal.NewArtCheckRuleDAO(session, user.Pid, user.Userid)
 	allocateDao := baseDal.NewArtQtyAllocateDAO(session, user.Pid, user.Userid)
 	serialOrderDetailDao := dal.NewSerialOrderOPDetailDAO(session, user.Pid, user.Userid)
@@ -1209,7 +1211,7 @@ func (impl *WorkOrderServiceImplement) ScanCodeCheck(user *models.Usertab, sessi
 			// 获取零件分配数量
 			var num int
 			// 零件BOM中两件组成父级零件的数量
-			composeQty := int(artRelMap[serialOrderStep.SubArtId].ComposeQty)
+			composeQty := artRelMap[serialOrderStep.SubArtId]
 			allocateLi, exist := allocateMap[op.ArticleAtcodLst.ArtId]
 			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)
@@ -1284,8 +1286,7 @@ func (impl *WorkOrderServiceImplement) ScanCodeCheck(user *models.Usertab, sessi
 				StepNo:        serialOrderStep.StepNo,
 				StepType:      baseModel.STEP_CHECK_RULE,
 				Status:        baseModel.WO_STATUS_LOCKED,
-				IntPara5: -1,
-
+				IntPara5:      -1,
 			}
 			err = serialOrderDetailDao.InsertOne(&op)
 			if err != nil {
@@ -1330,7 +1331,7 @@ func (impl *WorkOrderServiceImplement) ScanCodeCheck(user *models.Usertab, sessi
 * @Reference LAPP_LF_MOM_BACKEND/services/om/WorkOrderService.ScanCodeCheck 生成OPC通信的工艺数据
 *
 ******************************************************************************/
-func (impl *WorkOrderServiceImplement) OPCCommunication(user *models.Usertab, session *xorm.Session, opcBasicMap map[int][]baseModel.OPCBasicComInfo, serialOrderStep *model.SerialOrderStepLst, attributeMap map[int][]baseModel.ArticleWithAttrValue, workOrderId string, subArtMap map[string]interface{}) (*map[int][]baseModel.OPCBasicComInfo, error) {
+func (impl *WorkOrderServiceImplement) OPCCommunication(user *models.Usertab, session *xorm.Session, opcBasicMap map[int][]baseModel.OPCBasicComInfo, serialOrderStep *model.SerialOrderStepLst, attributeMap map[int][]baseModel.ArticleWithAttrValue, workOrderId string, subArtMap map[string]int) (*map[int][]baseModel.OPCBasicComInfo, error) {
 	var err error
 	opcBasicDao := baseDal.NewOPCBasicComInfoDAO(session, user.Pid, user.Userid)
 	opcComRuleDao := baseDal.NewOPCComRuleDAO(session, user.Pid, user.Userid)
@@ -1379,8 +1380,6 @@ func (impl *WorkOrderServiceImplement) OPCCommunication(user *models.Usertab, se
 			if opc.DBlockValueType == baseModel.OPC_DBBLOCK_VALUE_TYPE_MAP {
 				for _, detail := range opc.OPCComDetailRuleLi {
 					if detail.BaseOnType == baseModel.BASE_ON_TYPE_ATTRNAME {
-						fmt.Printf("***************************")
-						fmt.Println("detail.DataType:", detail.DataType)
 						attrCode, err := strconv.Atoi(detail.BaseOnValue)
 						if err != nil {
 							return nil, grmi.NewBusinessError("OPC通讯规则映射值转换ATTRCODE失败, error:" + err.Error())
@@ -1395,7 +1394,7 @@ func (impl *WorkOrderServiceImplement) OPCCommunication(user *models.Usertab, se
 						} else if detail.DataType == baseModel.DATA_TYPE_SHORTCODE {
 							var sign bool
 							for _, data := range attrLi {
-								_,exist := subArtMap[data.ArticleAtcodLst.ArtId]
+								_, exist := subArtMap[data.ArticleAtcodLst.ArtId]
 								if !exist {
 									continue
 								} else {
@@ -1412,7 +1411,7 @@ func (impl *WorkOrderServiceImplement) OPCCommunication(user *models.Usertab, se
 						} else if detail.DataType == baseModel.DATA_TYPE_ATTRVALUE {
 							var sign bool
 							for _, data := range attrLi {
-								_,exist := subArtMap[data.ArticleAtcodLst.ArtId]
+								_, exist := subArtMap[data.ArticleAtcodLst.ArtId]
 								if !exist {
 									continue
 								} else {
@@ -1466,8 +1465,9 @@ func (impl *WorkOrderServiceImplement) OPCCommunication(user *models.Usertab, se
 				CharPara5: opc.DBlockAddress,
 				// OPC DBLOCK VALUE TYPE
 				CharPara6: opc.DBlockValueType,
-				// OPC DBLOCK VALUE
-				CharPara7: value,
+				CharPara7: opc.Formula,
+				CharPara8: opc.OperatorSimbol,
+				CharPara9: value,
 				// OPC WorkPlaceNr
 				IntPara1: opcBasic.WorkPlaceNr,
 				IntPara5: opc.RuleId,
@@ -1580,7 +1580,6 @@ func (impl *WorkOrderServiceImplement) GuideRuleInfo(user *models.Usertab, sessi
 	return nil
 }
 
-
 /******************************************************************************
 *
 * @Reference LAPP_LF_MOM_BACKEND/services/om/WorkOrderService.PrintRuleInfo 生成单据打印数据
@@ -1627,11 +1626,14 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 	operationDao := baseDal.NewOperationDAO(session, user.Pid, user.Userid)
 	PODao := dal.NewSerialOrderPOLstDAO(session, user.Pid, user.Userid)
 	stepDao := dal.NewSerialOrderStepLstDAO(session, user.Pid, user.Userid)
-	artRelDao := baseDal.NewArticleRelLstDAO(session, user.Pid, user.Userid)
 	articleWithAttrDao := baseDal.NewArticleAtcodLstDAO(session, user.Pid, user.Userid)
 	scanRuleDao := baseDal.NewScanRuleInfoDAO(session, user.Pid, user.Userid)
 	guideDao := baseDal.NewGuideRuleInfoDAO(session, user.Pid, user.Userid)
 	printDao := baseDal.NewPrintRuleInfoDAO(session, user.Pid, user.Userid)
+	bomHeadDao := meDal.NewBomHeadDAO(session, user.Pid, user.Userid)
+	bomLstDao := meDal.NewBomLstDAO(session, user.Pid, user.Userid)
+	artWorkLineDao := baseDal.NewArtWorkLineLstDAO(session, user.Pid, user.Userid)
+	// 校验物料属性
 	article, err := articleDao.SelectOne(entity.ArtId)
 	if err != nil {
 		_ = session.Rollback()
@@ -1641,9 +1643,122 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 		_ = session.Rollback()
 		return grmi.NewBusinessError("不存在对应的物料数据")
 	}
-	if article.ArtSpec1 != baseModel.ART_TYPE_FINISHED {
+	if article.ArtSpec1 != baseModel.ART_TYPE_FINISHED && article.ArtSpec1 != baseModel.ART_TYPE_VIRTUAL {
+		_ = session.Rollback()
+		return grmi.NewBusinessError("传递的物料不是成品或虚拟物料ID")
+	}
+	workLineLi, err := artWorkLineDao.Select([]grmi.Predicate{baseMeta.ArtWorkLineLst_ArtId.NewPredicate(grmi.Equal, article.ArtId)}, nil)
+	if err != nil {
 		_ = session.Rollback()
-		return grmi.NewBusinessError("传递的物料不是成品物料ID")
+		return grmi.NewBusinessError("查询物料关联产线失败, error:" + err.Error())
+	}
+	var workLineExist bool
+	for _, workLineData := range workLineLi {
+		if workLineData.WorkLineId == entity.WorkLineId {
+			workLineExist = true
+		}
+	}
+	if !workLineExist {
+		_ = session.Rollback()
+		return grmi.NewBusinessError("该总成不支持在该产线上生产")
+	}
+	fmt.Println("--------------------------------------")
+	// 虚拟件获取实际物料BOM及比例关系
+	var virtualArtMap map[string]int
+	var countMap map[string]int
+	if article.ArtSpec1 == baseModel.ART_TYPE_VIRTUAL {
+		virtualArtMap = make(map[string]int)
+		countMap = make(map[string]int)
+
+		var count int
+		if article.ArtSpec1 == baseModel.ART_TYPE_VIRTUAL {
+			bomHead, err := bomHeadDao.SelectOne(article.ArtId)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("获取物料BOM失败, error:" + err.Error())
+			}
+			if bomHead == nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("不存在对应的物料BOM，artId:" + article.ArtId)
+			}
+			bomLstLi, err := bomLstDao.Select([]grmi.Predicate{meMeta.BomLst_BomId.NewPredicate(grmi.Equal, bomHead.BomId)}, nil)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("获取BOM细则失败, error:" + err.Error())
+			}
+			if len(bomLstLi) == 0 {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("未获取到BOM细则, artId:" + bomHead.BomId)
+			}
+			for _, bomLst := range bomLstLi {
+				if int(bomLst.FmatQty) != 1 || bomLst.FmatNr != bomLst.BomId {
+					_ = session.Rollback()
+					return grmi.NewBusinessError("虚拟件BOM配置错误")
+				}
+				virtualArtMap[bomLst.CmatNr] = int(bomLst.CmatQty)
+				count += int(bomLst.CmatQty)
+			}
+		}
+		if entity.Qty%count != 0 {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("创建工单的生产数量不能匹配BOM分配关系")
+		}
+		for artId := range virtualArtMap {
+			countMap[artId] = 0
+		}
+	}
+	// 组装BOM切片
+	bomHeadMap := make(map[string]meModel.BomHead, 0)
+	if article.ArtSpec1 == baseModel.ART_TYPE_VIRTUAL {
+		for artId := range virtualArtMap {
+			bomHead, err := bomHeadDao.SelectOne(artId)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("查询物料BOM失败, error:" + err.Error())
+			}
+			if bomHead == nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("不存在对应的物料BOM, artId:" + artId)
+			}
+			var Me meModel.BomLst
+			Me.PlantNr = user.Pid
+			Me.BomId = bomHead.BomId
+			bomList, err := Me.SetMenu(bomHead.MatNr)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("获取BOM细则失败, error:" + err.Error())
+			}
+			if len(bomList) == 0 {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("未获取到BOM细则, artId:" + bomHead.BomId)
+			}
+			bomHead.BomLstLi = bomList
+			bomHeadMap[bomHead.MatNr] = *bomHead
+		}
+	} else {
+		bomHead, err := bomHeadDao.SelectOne(article.ArtId)
+		if err != nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("查询物料BOM失败, error:" + err.Error())
+		}
+		if bomHead == nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("不存在对应的物料BOM, artId:" + article.ArtId)
+		}
+		var Me meModel.BomLst
+		Me.PlantNr = user.Pid
+		Me.BomId = bomHead.BomId
+		bomList, err := Me.SetMenu(bomHead.MatNr)
+		if err != nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("获取BOM细则失败, error:" + err.Error())
+		}
+		if len(bomList) == 0 {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("未获取到BOM细则, artId:" + bomHead.BomId)
+		}
+		bomHead.BomLstLi = bomList
+		bomHeadMap[bomHead.MatNr] = *bomHead
 	}
 	// 获取项目数据 用于获取流水号
 	project, err := projectDao.SelectOne(baseModel.ProjectId)
@@ -1697,7 +1812,7 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 		OrderInfo:            article.Descr1,
 		PlanResourceGroupId:  article.PlanResourceGroupId,
 		PlanResourceId:       entity.WorkLineId,
-		UsedResourceId:        entity.WorkLineId,
+		UsedResourceId:       entity.WorkLineId,
 		PlanQty:              float64(entity.Qty),
 		QtyUomId:             article.UomId,
 		RatePerHourToggle:    article.RatePerHourToggle,
@@ -1755,7 +1870,6 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 	serialOrderStatusLi := make([]model.SerialOrderStatus, 0, entity.Qty)
 
 	// 进行批次工单的时间拆解到序列工单的计划时间上
-
 	// 生成序列工单
 	for i := 0; i < entity.Qty; i++ {
 		snr := new(models.Snrtab)
@@ -1768,10 +1882,34 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 		planStartDate := workOrder.PlanStartDate.Restore().Format("20060102")
 		prefix := workOrder.ArtId + baseModel.PlantName + planStartDate
 		serialOrderId := strings.Replace(serialNum, "SO-", prefix, 1)
+		// 根据虚拟件还是总成件 来获取ArtId
+		var artId string
+		if article.ArtSpec1 == baseModel.ART_TYPE_VIRTUAL {
+			accomplish := true
+			for innerArtId, qty := range virtualArtMap {
+				if countMap[innerArtId] < qty {
+					accomplish = false
+				}
+			}
+			if accomplish {
+				for artId := range countMap {
+					countMap[artId] = 0
+				}
+			}
+			for innerArtId, qty := range virtualArtMap {
+				if countMap[innerArtId] < qty {
+					artId = innerArtId
+					countMap[innerArtId] += 1
+					break
+				}
+			}
+		} else {
+			artId = article.ArtId
+		}
 		serialOrder := model.SerialOrder{
 			WorkOrderId:    workOrderId,
 			SerialOrderId:  serialOrderId,
-			ArtId:          workOrder.ArtId,
+			ArtId:          artId,
 			OrderType1:     workOrder.OrderType1,
 			OrderType2:     workOrder.OrderType2,
 			PlanResourceId: workOrder.PlanResourceId,
@@ -1810,35 +1948,34 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 		}
 	}
 	// 生成序列工单对应的工艺数据
-	articleLi, err := artRelDao.Select([]grmi.Predicate{baseMeta.ArticleRelLst_PID.NewPredicate(grmi.Equal, entity.ArtId)}, nil)
-	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("获取物料关联关系失败, error:" + err.Error())
-	}
-	if len(articleLi) == 0 {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("未获取到零件关联关系")
-	}
-	artIdLi := make([]string, 0, len(articleLi))
-	artRelMap := make(map[string]baseModel.ArticleRelLst)
-	for _, article := range articleLi {
-		artIdLi = append(artIdLi, article.ArtId)
-		artRelMap[article.ArtId] = article
-	}
-	subArtMap := make(map[string]interface{})
-	for _, artId := range artIdLi {
-		subArtMap[artId] = nil
-	}
-	opLi, err := operationDao.GetOperationRelData(artIdLi, workOrder.PlanResourceId)
-	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("获取工艺操作失败,error:" + err.Error())
+	opMap := make(map[string][]baseModel.OperationRelData)
+	totalArtMap := make(map[string]map[string]int)
+	for artId, bomHead := range bomHeadMap {
+		artMap := impl.ExtractArtId(&bomHead)
+		artIdLi := make([]string, 0, len(artMap))
+		for innerArtId := range artMap {
+			artIdLi = append(artIdLi, innerArtId)
+		}
+		opLi, err := operationDao.GetOperationRelData(artIdLi, workOrder.PlanResourceId, article.ProjectId)
+		if err != nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("获取工艺操作失败,error:" + err.Error())
+		}
+		if len(opLi) == 0 {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("未获取到工艺数据")
+		}
+		opMap[artId] = opLi
+		totalArtMap[artId] = artMap
 	}
+
 	allocateMap := make(map[string][]baseModel.ArtQtyAllocate)
 	checkRuleMap := make(map[string]baseModel.ArtCheckRule)
 	opcBasicMap := make(map[int][]baseModel.OPCBasicComInfo)
 	twMap := make(map[int][]baseModel.TightenWrenchInfo)
-	for _, serialOrderStatus := range serialOrderStatusLi {
+	for _, serialOrder := range serialOrderLi {
+		opLi := opMap[serialOrder.ArtId]
+		artRelMap := totalArtMap[serialOrder.ArtId]
 		var PO int
 		processPos := 1
 		opPos := 1
@@ -1846,7 +1983,7 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 			if PO != op.Process.PO {
 				PO = op.Process.PO
 				serialOrderWorkPlace := model.SerialOrderPOLst{
-					SerialOrderId: serialOrderStatus.SerialOrderId,
+					SerialOrderId: serialOrder.SerialOrderId,
 					PO:            PO,
 					Status:        baseModel.WO_STATUS_LOCKED,
 					HasDependOn:   op.Process.HasDependOn,
@@ -1862,7 +1999,7 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 			serialOrderStep := model.SerialOrderStepLst{
 				PO:            op.Process.PO,
 				OperationId:   op.OperationId,
-				SerialOrderId: serialOrderStatus.SerialOrderId,
+				SerialOrderId: serialOrder.SerialOrderId,
 				StepNo:        op.Operation.StepNo,
 				Pos:           opPos,
 				SubArtId:      op.ArticleAtcodLst.ArtId,
@@ -1893,7 +2030,7 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 				allocateMap = *allocateMapPointer
 			} else if serialOrderStep.StepType == baseModel.STEP_OPC_RULE { // 生成OPC通讯的工艺数据
 
-				opcBasicMapPointer, err := impl.OPCCommunication(user, session, opcBasicMap, &serialOrderStep, attributeMap, workOrderId, subArtMap)
+				opcBasicMapPointer, err := impl.OPCCommunication(user, session, opcBasicMap, &serialOrderStep, attributeMap, workOrderId, artRelMap)
 				if err != nil {
 					_ = session.Rollback()
 					return err
@@ -1937,3 +2074,17 @@ func (impl *WorkOrderServiceImplement) CreateLockWorkOrder(user *models.Usertab,
 	_ = session.Commit()
 	return nil
 }
+
+func (impl *WorkOrderServiceImplement) ExtractArtId(bomHead *meModel.BomHead) map[string]int {
+	artMap := make(map[string]int)
+	bomLstLi := bomHead.BomLstLi
+	for _, bomLst := range bomLstLi {
+		_, exist := artMap[bomLst.CmatNr]
+		if exist {
+			artMap[bomLst.CmatNr] += int(bomLst.CmatQty / bomLst.FmatQty)
+		} else {
+			artMap[bomLst.CmatNr] = int(bomLst.CmatQty / bomLst.FmatQty)
+		}
+	}
+	return artMap
+}