diff --git a/services/om/SerialOrder.service.go b/services/om/SerialOrder.service.go
index a118713..d7e0fb8 100644
--- a/services/om/SerialOrder.service.go
+++ b/services/om/SerialOrder.service.go
@@ -382,7 +382,7 @@ type SerialOrderService interface {
 	 * @Date                     : 2021-11-25
 	 *
 	 ******************************************************************************/
-	GenerateCraftData(user *global.User, serialOrderId string) error
+	//GenerateCraftData(user *global.User, serialOrderId string) error
 	/******************************************************************************
 	 *
 	 * @Function Name            : GenerateCraftDataByCustOrder
@@ -514,6 +514,7 @@ type SerialOrderService interface {
 	CreateBatchSerialOrder(user *global.User, productId string, projectId string, workLineId string, qty int, preSchKey int, priority int) error
 	TraceSubArticleBatch(user *global.User, barcode string, paging *grmi.Paging) (grmi.PagingResult, error)
 	ExportTraceSubArticleBatch(user *global.User, barcode string) (string, error)
+	CancelMultiSerialOrder(user *global.User, serialOrderIdLi []string) error
 }
 
 /******************************************************************************
diff --git a/services/om/implments/SerialOrder.service.impl.go b/services/om/implments/SerialOrder.service.impl.go
index 663ca0b..5646ce8 100644
--- a/services/om/implments/SerialOrder.service.impl.go
+++ b/services/om/implments/SerialOrder.service.impl.go
@@ -795,7 +795,7 @@ func (impl *SerialOrderServiceImplement) ReleaseSerialOrder(user *global.User, s
 		}
 		if sfpBomHead == nil {
 			_ = session.Rollback()
-			return grmi.NewBusinessError("不存在对应的物料BOM, 物料ID:" + serialOrder.ArtId)
+			return grmi.NewBusinessError("不存在对应的物料BOM, 物料ID:" + bomLst.CmatNr)
 		}
 		var sfpMe meModel.BomLst
 		sfpMe.PlantNr = user.PlantNr
@@ -2504,9 +2504,6 @@ func (impl *SerialOrderServiceImplement) GenerateCraftDataByCustOrder(user *glob
 						return grmi.NewBusinessError("插入序列工单工艺数据失败, error:" + err.Error())
 					}
 					if serialOrderStep.StepType == baseModel.STEP_CHECK_RULE { // 生成扫码校验的工艺数据
-						fmt.Println("111", serialOrderStep.SerialOrderId)
-						fmt.Println("222", serialOrderStep.OperationId)
-						fmt.Println("333", scanRuleMap)
 						scanRule, exist := scanRuleMap[serialOrderStep.OperationId]
 						if !exist {
 							return grmi.NewBusinessError("未获取到扫描校验详细规则, 工艺ID:" + strconv.Itoa(serialOrderStep.OperationId))
@@ -2594,17 +2591,10 @@ func (impl *SerialOrderServiceImplement) GenerateCraftDataByCustOrder(user *glob
 }
 
 // GenerateCraftData 生成工单的工艺数据
-func (impl *SerialOrderServiceImplement) GenerateCraftData(user *global.User, serialOrderId string) error {
-	grmi.Log(user, "/services/om/implments/WorkOrder.service.impl.go", "GenerateCraftData", "生成工单的工艺数据")
-	engine := db.Eloquent.Master()
-	session := engine.NewSession()
-	defer session.Close()
-	if err := session.Begin(); err != nil {
-		return err
-	}
-	serialOrderDao := dal.NewSerialOrderDAO(session, user.PlantNr, user.UserId)
+func (impl *SerialOrderServiceImplement) GenerateCraftData(user *global.User, session *xorm.Session, serialOrderLi []model.SerialOrder) error {
 	workLineProcessDao := baseDal.NewWorkLineProcessLstDAO(session, user.PlantNr, user.UserId)
-	projectDao := meDal.NewProjectDAO(session, user.PlantNr, user.UserId)
+	serialOrderDao := dal.NewSerialOrderDAO(session, user.PlantNr, user.UserId)
+	serialOrderStatusDao := dal.NewSerialOrderStatusDAO(session, user.PlantNr, user.UserId)
 	operationDao := baseDal.NewOperationDAO(session, user.PlantNr, user.UserId)
 	PODao := dal.NewSerialOrderPOLstDAO(session, user.PlantNr, user.UserId)
 	stepDao := dal.NewSerialOrderStepLstDAO(session, user.PlantNr, user.UserId)
@@ -2613,72 +2603,60 @@ func (impl *SerialOrderServiceImplement) GenerateCraftData(user *global.User, se
 	guideDao := baseDal.NewGuideRuleInfoDAO(session, user.PlantNr, user.UserId)
 	bomHeadDao := meDal.NewBomHeadDAO(session, user.PlantNr, user.UserId)
 	labelTemplateDetailDao := baseDal.NewLabelTemplateDetailDAO(session, user.PlantNr, user.UserId)
-	printRuleDao := baseDal.NewPrintBasicRuleInfoDAO(session, user.PlantNr, user.UserId)
 	articleDao := baseDal.NewArticleDAO(session, user.PlantNr, user.UserId)
+	printRuleDao := baseDal.NewPrintBasicRuleInfoDAO(session, user.PlantNr, user.UserId)
 	productDao := meDal.NewProductDAO(session, user.PlantNr, user.UserId)
-	// 组装BOM切片 获取关联的所有零件ID
-	//var serialOrder model.SerialOrder
-	//var err error
-	serialOrder, err := serialOrderDao.SelectOne(serialOrderId)
-	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("查询工单失败, error:" + err.Error())
-	}
-	if serialOrder == nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("不存在对应的工单, 工单ID:" + serialOrderId)
-	}
-	article, err := articleDao.SelectOne(serialOrder.ArtId, serialOrder.ProjectId)
+	shipableAUConfigDao := meDal.NewShipableAUConfigDAO(session, user.PlantNr, user.UserId)
+	snrDao := baseDal.NewSnrDAO(session, user.PlantNr, user.UserId)
+	projectDao := meDal.NewProjectDAO(session, user.PlantNr, user.UserId)
+	bomLstDao := meDal.NewBomLstDAO(session, user.PlantNr, user.UserId)
+	// 用于子工单物料临时存储
+	var project *meModel.Project
+	today := time.Now().Format("060102")
+	// 获取所有的标签打印模板 并组建MAP
+	labelTemplateLi, err := labelTemplateDetailDao.SelectAllTemplate()
 	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("查询工单总成失败, error:" + err.Error())
+		return grmi.NewBusinessError("查询标签模板失败,error:" + err.Error())
 	}
-	if article == nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("工单总成不存在, 总成ID:" + serialOrder.ArtId)
+	labelTemplateMap := make(map[string]*baseModel.LabelTemplateHead)
+	for _, template := range labelTemplateLi {
+		innerTemplate := template
+		labelTemplateMap[template.LabelTemplateId] = &innerTemplate
 	}
-	product, err := productDao.SelectOne(serialOrder.ArtId, serialOrder.ProjectId)
+	projectId := serialOrderLi[0].ProjectId
+	productId := serialOrderLi[0].ArtId
+	product, err := productDao.SelectOne(productId, projectId)
 	if err != nil {
-		_ = session.Rollback()
 		return grmi.NewBusinessError("查询产品总成数据失败, error:" + err.Error())
 	}
 	if product == nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("产品总成不存在, 总成ID:" + serialOrder.ArtId)
+		return grmi.NewBusinessError("产品总成不存在, 总成ID:" + productId)
 	}
-
-	// 获取所有的标签打印模板 并组建MAP
-	labelTemplateLi, err := labelTemplateDetailDao.SelectAllTemplate()
+	article, err := articleDao.SelectOne(productId, product.ProjectId)
 	if err != nil {
 		_ = session.Rollback()
-		return grmi.NewBusinessError("查询标签模板失败,error:" + err.Error())
+		return grmi.NewBusinessError("查询工单总成失败, error:" + err.Error())
 	}
-	labelTemplateMap := make(map[string]*baseModel.LabelTemplateHead)
-	for _, template := range labelTemplateLi {
-		innerTemplate := template
-		labelTemplateMap[template.LabelTemplateId] = &innerTemplate
+	if article == nil {
+		_ = session.Rollback()
+		return grmi.NewBusinessError("工单总成不存在, 总成ID:" + productId)
 	}
-
-	bomHead, err := bomHeadDao.SelectOne(serialOrder.ArtId)
+	bomHead, err := bomHeadDao.SelectOne(productId)
 	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("查询物料BOM失败, error:" + err.Error() + " 工单ID: " + serialOrderId)
+		return grmi.NewBusinessError("查询物料BOM失败, error:" + err.Error())
 	}
 	if bomHead == nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("不存在对应的物料BOM, 物料ID:" + serialOrder.ArtId + " 工单ID: " + serialOrderId)
+		return grmi.NewBusinessError("不存在对应的物料BOM, 物料ID:" + productId)
 	}
 	var Me meModel.BomLst
 	Me.PlantNr = user.PlantNr
 	Me.BomId = bomHead.BomId
 	bomList, err := Me.SetMenu(bomHead.MatNr)
 	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("获取BOM细则失败, error:" + err.Error() + " 工单ID: " + serialOrderId)
+		return grmi.NewBusinessError("获取BOM细则失败, error:" + err.Error())
 	}
 	if len(bomList) == 0 {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("未获取到BOM细则, 物料ID:" + bomHead.BomId + " 工单ID: " + serialOrderId)
+		return grmi.NewBusinessError("未获取到BOM细则, 物料ID:" + bomHead.BomId)
 	}
 	bomHead.BomLstLi = bomList
 	// 获取关联的所有零件ID
@@ -2687,41 +2665,162 @@ func (impl *SerialOrderServiceImplement) GenerateCraftData(user *global.User, se
 	for innerArtId := range artMap {
 		artIdLi = append(artIdLi, innerArtId)
 	}
+	artIdLi = append(artIdLi, productId)
+	workLineId := serialOrderLi[0].PlanResourceId
+	// 查询所有使用到的工序
+	usedPoLi, err := workLineProcessDao.SelectProcessByWorkLine(workLineId)
+	if err != nil {
+		return grmi.NewBusinessError("获取产线关联的工序失败, error:" + err.Error())
+	}
+	if len(usedPoLi) == 0 {
+		return grmi.NewBusinessError("该产线未关联工序, 产线ID:" + workLineId)
+	}
+	// 拆分预装子工单
+	// 1. 将所有工序数据生成MAP
+	// 2. 从后往前查 如果有shipableAU标识 代表需要生成工单 需要查询shipableAUConfig数据表中该po的配置
+	// 3. 生成工单有两种规则 一种是总装线 主工单 一种是预装线 子工单
+	bomLstLi, err := bomLstDao.Select([]grmi.Predicate{
+		meMeta.BomLst_BomId.NewPredicate(grmi.Equal, productId),
+		meMeta.BomLst_ShipableAU.NewPredicate(grmi.Equal, true),
+	}, nil)
+	if err != nil {
+		return grmi.NewBusinessError("查询BOM子项数据失败, 错误:" + err.Error())
+	}
+	poDataMap := make(map[string]*baseModel.Process)
+	allPoIdInterfaceLi := make([]interface{}, 0, len(usedPoLi))
 
-	// 获取项目数据 用于获取流水号
-	project, err := projectDao.SelectOne(serialOrder.ProjectId)
+	for _, po := range usedPoLi {
+		poDataMap[po.PO] = &po
+		allPoIdInterfaceLi = append(allPoIdInterfaceLi, po.PO)
+	}
+	sfpUsedPoMap := make(map[string]interface{})
+	orderPoMap := make(map[string]*model.OrderAUPoData)
+	for _, bomLst := range bomLstLi {
+		sfp, err := articleDao.SelectOne(bomLst.CmatNr, projectId)
+		if err != nil {
+			return grmi.NewBusinessError("查询物料失败, 错误:" + err.Error())
+		}
+		if sfp == nil {
+			return grmi.NewBusinessError("半成品物料不存在, 物料ID:" + bomLst.CmatNr)
+		}
+		auConfig, err := shipableAUConfigDao.SelectOne(bomLst.CmatNr)
+		if err != nil {
+			return grmi.NewBusinessError("查询半成品配置数据失败, 错误:" + err.Error())
+		}
+		if auConfig == nil {
+			return grmi.NewBusinessError("半成品配置不存在， 物料ID:" + bomLst.CmatNr)
+		}
+
+		sfpBomHead, err := bomHeadDao.SelectOne(bomLst.CmatNr)
+		if err != nil {
+			return grmi.NewBusinessError("查询物料BOM失败, error:" + err.Error())
+		}
+		if sfpBomHead == nil {
+			return grmi.NewBusinessError("不存在对应的物料BOM, 物料ID:" + bomLst.CmatNr)
+		}
+		var sfpMe meModel.BomLst
+		sfpMe.PlantNr = user.PlantNr
+		sfpMe.BomId = sfpBomHead.BomId
+		sfpBomLstLi, err := sfpMe.SetMenu(sfpBomHead.MatNr)
+		if err != nil {
+			return grmi.NewBusinessError("获取BOM细则失败, error:" + err.Error())
+		}
+		if len(sfpBomLstLi) == 0 {
+			return grmi.NewBusinessError("未获取到BOM细则, 物料ID:" + bomHead.BomId)
+		}
+		sfpBomHead.BomLstLi = sfpBomLstLi
+		// 获取关联的所有零件ID
+		sfpArtMap := impl.ExtractArtId(bomHead)
+		sfpArtIdLi := make([]string, 0, len(sfpArtMap))
+		for innerArtId := range sfpArtMap {
+			sfpArtIdLi = append(sfpArtIdLi, innerArtId)
+		}
+		sfpArtIdLi = append(sfpArtIdLi, sfp.ArtId)
+		auPoData, exist := poDataMap[auConfig.AuPo]
+		if !exist {
+			return grmi.NewBusinessError("半成品指定工序不存在于总工单的工序序列中, 半成品ID:" + sfp.ArtId)
+		}
+		// 根据该工序查询所有后序
+		poDataLi := impl.GetOrderPOLi(auPoData, poDataMap)
+		// 该工单用到的所有生产工序
+		poDataLi = append(poDataLi, auPoData)
+		// 查询这个工单需要用到的所有工艺数据
+		poIdLi := make([]string, 0, len(poDataLi))
+		for _, innerPoData := range poDataLi {
+			sfpUsedPoMap[innerPoData.PO] = nil
+			poIdLi = append(poIdLi, innerPoData.PO)
+		}
+		opLi, err := operationDao.GetMeOperation(sfpArtIdLi, projectId, poIdLi, workLineId)
+		if err != nil {
+			return grmi.NewBusinessError("获取工艺操作失败,error:" + err.Error())
+		}
+		if len(opLi) == 0 {
+			return grmi.NewBusinessError("未获取到工艺数据")
+		}
+		// 所有需要生成工单工序绑定的数据
+		orderPoMap[bomLst.CmatNr] = &model.OrderAUPoData{
+			Config:        auConfig,
+			MeOperationLi: opLi,
+			IsMainOrder:   false,
+			SFP:           sfp,
+		}
+	}
+	mainOrderPOIdLi := make([]string, 0)
+	for _, usedPoData := range usedPoLi {
+		_, exist := sfpUsedPoMap[usedPoData.PO]
+		if !exist {
+			mainOrderPOIdLi = append(mainOrderPOIdLi, usedPoData.PO)
+		}
+	}
+	if len(mainOrderPOIdLi) == 0 {
+		return grmi.NewBusinessError("主工单无生产所需工序")
+	}
+	opLi, err := operationDao.GetMeOperation(artIdLi, projectId, mainOrderPOIdLi, workLineId)
 	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("获取项目数据失败, error:" + err.Error() + " 工单ID: " + serialOrderId)
+		return grmi.NewBusinessError("获取工艺操作失败,error:" + err.Error())
 	}
-	if project == nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("不存在该项目数据, 项目ID: " + serialOrder.ProjectId + " 工单ID: " + serialOrderId)
+	if len(opLi) == 0 {
+		return grmi.NewBusinessError("未获取到工艺数据")
+	}
+	// 所有需要生成工单工序绑定的数据
+	orderPoMap[productId] = &model.OrderAUPoData{
+		Config:        nil,
+		MeOperationLi: opLi,
+		IsMainOrder:   true,
+		SFP:           nil,
 	}
-	// 获取所有的扫码校验规则 组建MAP数据结构
-	scanRuleLi, err := scanRuleDao.Select([]grmi.Predicate{baseMeta.ScanRuleInfo_ProjectId.NewPredicate(grmi.Equal, serialOrder.ProjectId)}, nil)
+
+	// 获取所有使用工序的扫码校验规则 组建MAP数据结构
+	scanRuleLi, err := scanRuleDao.Select([]grmi.Predicate{baseMeta.ScanRuleInfo_ProjectId.NewPredicate(grmi.Equal, projectId), baseMeta.ScanRuleInfo_PO.NewPredicate(grmi.Include, allPoIdInterfaceLi...)}, nil)
 	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("查询扫码校验条码失败, error:" + err.Error() + " 工单ID: " + serialOrderId)
+		return grmi.NewBusinessError("查询扫码校验条码失败, error:" + err.Error())
 	}
 	scanRuleMap := make(map[int]baseModel.ScanRuleInfo)
 	for _, scanRule := range scanRuleLi {
 		scanRuleMap[scanRule.OperationId] = scanRule
 	}
-	// 获取所有指导操作的规则 组建MAP数据结构
-	guideRuleLi, err := guideDao.Select([]grmi.Predicate{baseMeta.GuideRuleInfo_ProjectId.NewPredicate(grmi.Equal, serialOrder.ProjectId)}, nil)
+	// 获取所有使用工序指导操作的规则 组建MAP数据结构
+	guideRuleLi, err := guideDao.Select([]grmi.Predicate{baseMeta.GuideRuleInfo_ProjectId.NewPredicate(grmi.Equal, projectId), baseMeta.GuideRuleInfo_PO.NewPredicate(grmi.Include, allPoIdInterfaceLi...)}, nil)
 	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("查询指导操作规则失败, error:" + err.Error() + " 工单ID: " + serialOrderId)
+		return grmi.NewBusinessError("查询指导操作规则失败, error:" + err.Error())
 	}
 	guideRuleMap := make(map[int]baseModel.GuideRuleInfo, len(guideRuleLi))
 	for _, guideRule := range guideRuleLi {
 		guideRuleMap[guideRule.OperationId] = guideRule
 	}
+	// 获取所有使用工序扫码校验规则 组建MAP数据结构
+	printRuleLi, err := printRuleDao.Select([]grmi.Predicate{baseMeta.PrintBasicRuleInfo_ProjectId.NewPredicate(grmi.Equal, projectId), baseMeta.PrintBasicRuleInfo_PO.NewPredicate(grmi.Include, allPoIdInterfaceLi...)}, []grmi.Field{baseMeta.PrintBasicRuleInfo_OperationId})
+	printRuleMap := make(map[int][]baseModel.PrintBasicRuleInfo)
+	for _, data := range printRuleLi {
+		_, exist := printRuleMap[data.OperationId]
+		if !exist {
+			printRuleMap[data.OperationId] = make([]baseModel.PrintBasicRuleInfo, 0)
+		}
+		printRuleMap[data.OperationId] = append(printRuleMap[data.OperationId], data)
+	}
 	// 获取所有物料属性关联关系
 	attributeLi, err := articleWithAttrDao.SelectAllWithAttrValue()
 	if err != nil {
-		_ = session.Rollback()
 		return grmi.NewBusinessError("查询零件属性失败,error:" + err.Error())
 	}
 	attributeMap := make(map[int][]baseModel.ArticleWithAttrValue)
@@ -2732,164 +2831,188 @@ func (impl *SerialOrderServiceImplement) GenerateCraftData(user *global.User, se
 		}
 		attributeMap[data.ArticleAtcodLst.AttrCode] = append(attributeMap[data.ArticleAtcodLst.AttrCode], data)
 	}
-
 	// 生成序列工单对应的工艺数据
-	usedPoLi, err := workLineProcessDao.SelectProcessByWorkLine(serialOrder.PlanResourceId)
-	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("获取产线关联的工序失败, error:" + err.Error())
-	}
-	if len(usedPoLi) == 0 {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("该产线未关联工序, 产线ID:" + serialOrder.PlanResourceId)
-	}
-	poIdLi := make([]string, 0, len(usedPoLi))
-	poIdLiInterface := make([]interface{}, 0, len(usedPoLi))
-	for _, poData := range usedPoLi {
-		poIdLi = append(poIdLi, poData.PO)
-		poIdLiInterface = append(poIdLiInterface, poData.PO)
-	}
-	opLi, err := operationDao.GetMeOperation(artIdLi, serialOrder.ProjectId, poIdLi, serialOrder.PlanResourceId)
-	if err != nil {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("获取工艺操作失败,error:" + err.Error())
-	}
-	if len(opLi) == 0 {
-		_ = session.Rollback()
-		return grmi.NewBusinessError("未获取到工艺数据")
-	}
-	// 获取所有使用工序扫码校验规则 组建MAP数据结构
-	printRuleLi, err := printRuleDao.Select([]grmi.Predicate{baseMeta.PrintBasicRuleInfo_ProjectId.NewPredicate(grmi.Equal, serialOrder.ProjectId), baseMeta.PrintBasicRuleInfo_PO.NewPredicate(grmi.Include, poIdLiInterface...)}, []grmi.Field{baseMeta.PrintBasicRuleInfo_OperationId})
-	printRuleMap := make(map[int][]baseModel.PrintBasicRuleInfo)
-	for _, data := range printRuleLi {
-		_, exist := printRuleMap[data.OperationId]
-		if !exist {
-			printRuleMap[data.OperationId] = make([]baseModel.PrintBasicRuleInfo, 0)
-		}
-		printRuleMap[data.OperationId] = append(printRuleMap[data.OperationId], data)
-	}
-
 	allocateMap := make(map[string][]baseModel.ArtQtyAllocate)
 	checkRuleMap := make(map[string]baseModel.ArtCheckRule)
 	opcBasicMap := make(map[int][]baseModel.OPCBasicComInfo)
 	twMap := make(map[int][]baseModel.TightenWrenchInfo)
-	var PO string
-	processPos := 1
-	opPos := 1
-	for _, op := range opLi {
-		// 生成工序操作状态表
-		if PO != op.Process.PO {
-			PO = op.Process.PO
-			serialOrderWorkPlace := model.SerialOrderPOLst{
-				SerialOrderId: serialOrder.SerialOrderId,
-				PO:            PO,
-				Status:        baseModel.WO_STATUS_RELEASED,
-				HasDependOn:   op.Process.HasDependOn,
-			}
-			err = PODao.InsertOne(&serialOrderWorkPlace)
-			if err != nil {
-				_ = session.Rollback()
-				return grmi.NewBusinessError("插入serialOrder工序数据失败,error:" + err.Error())
-			}
-			processPos++
-		}
-		serialOrderStep := model.SerialOrderStepLst{
-			PO:            op.Process.PO,
-			OperationId:   op.OperationId,
-			SerialOrderId: serialOrder.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_RELEASED,
-		}
-		opPos++
-		err = stepDao.InsertOne(&serialOrderStep)
-		if err != nil {
-			_ = session.Rollback()
-			return grmi.NewBusinessError("插入序列工单工艺数据失败, error:" + err.Error())
-		}
-		if serialOrderStep.StepType == baseModel.STEP_CHECK_RULE { // 生成扫码校验的工艺数据
-			fmt.Println("serialOrderStep.SerialOrderId:", serialOrderStep.SerialOrderId)
-			fmt.Println("serialOrderStep.SerialOrderId:", serialOrderStep.OperationId)
-			scanRule, exist := scanRuleMap[serialOrderStep.OperationId]
-			if !exist {
-				return grmi.NewBusinessError("未获取到扫描校验详细规则, 工艺ID:" + strconv.Itoa(serialOrderStep.OperationId))
-			}
+	for _, serialOrder := range serialOrderLi {
+		schedKey := serialOrder.SchedKey
+		var usedArticle *baseModel.Article
+		for _, orderOPData := range orderPoMap {
+			var serialOrderId string
+			if !orderOPData.IsMainOrder {
+				usedArticle = orderOPData.SFP
+				if project == nil {
+					project, err = projectDao.SelectOne(projectId)
+					if err != nil {
+						return grmi.NewBusinessError("查询项目失败, 错误:" + err.Error())
+					}
+				}
+				if orderOPData.Config.BarCodeRule == baseModel.BARCODE_RULE_ACURA_PRE {
 
-			checkRuleMapPointer, allocateMapPointer, err := impl.ScanCodeCheck(user, session, checkRuleMap, allocateMap, artMap, &scanRule, &op, &serialOrderStep, op.Operation.ActivateInBKStation)
-			if err != nil {
-				_ = session.Rollback()
-				return err
-			}
-			checkRuleMap = *checkRuleMapPointer
-			allocateMap = *allocateMapPointer
-		} else if serialOrderStep.StepType == baseModel.STEP_OPC_RULE { // 生成OPC通讯的工艺数据
-			opcBasicMapPointer, err := impl.OPCCommunication(user, session, opcBasicMap, &serialOrderStep, attributeMap, artMap, op.Operation.ActivateInBKStation)
-			if err != nil {
-				_ = session.Rollback()
-				return err
-			}
-			opcBasicMap = *opcBasicMapPointer
-		} else if serialOrderStep.StepType == baseModel.STEP_TW_RULE { // 生成开发协议的工艺数据
-			twMapPointer, err := impl.TightenWrenchInfo(user, session, twMap, &serialOrderStep, op.Operation.ActivateInBKStation, article)
-			if err != nil {
-				_ = session.Rollback()
-				return err
-			}
-			twMap = *twMapPointer
-		} else if serialOrderStep.StepType == baseModel.STEP_GUIDE_RULE {
-			guideRule, exist := guideRuleMap[serialOrderStep.OperationId]
-			if !exist {
-				_ = session.Rollback()
-				return grmi.NewBusinessError("未获取到指导操作的详细规则")
-			}
-			err = impl.GuideRuleInfo(user, session, &guideRule, &serialOrderStep, op.Operation.ActivateInBKStation)
-			if err != nil {
-				_ = session.Rollback()
-				return err
-			}
-		} else if serialOrderStep.StepType == baseModel.STEP_PRINT_RULE {
-			ruleLi, exist := printRuleMap[serialOrderStep.OperationId]
-			if !exist {
-				_ = session.Rollback()
-				return grmi.NewBusinessError("未获取到打印规则, 工艺ID:" + strconv.Itoa(serialOrderStep.OperationId))
-			}
-			generateRuleLi := make([]baseModel.PrintBasicRuleInfo, 0)
-			for _, rule := range ruleLi {
-				if rule.Action == baseModel.PRINT_RULE_ACTION_UPDATE {
-					generateRuleLi = append(generateRuleLi, rule)
+						number, err := snrDao.GetNextSnr(project.PreOrderSnr)
+						if err != nil {
+							return grmi.NewBusinessError("获取流水号失败，错误:" + err.Error())
+						}
+
+					serialOrderId = strings.Replace(orderOPData.SFP.ArtId, "-", "", -1) + today + number
+				} else {
+					return grmi.NewBusinessError("不支持的子工单条码生成规则，物料Id:" + orderOPData.SFP.ArtId)
 				}
-			}
-			if len(generateRuleLi) > 1 {
-				_ = session.Rollback()
-				return grmi.NewBusinessError("改工步匹配到超过1条生成打印标识的打印规则")
-			}
-			var generateRule *baseModel.PrintBasicRuleInfo
-			var printTemplate *baseModel.LabelTemplateHead
-			if len(generateRuleLi) == 1 {
-				generateRule = &generateRuleLi[0]
-				printTemplate, exist = labelTemplateMap[product.PrintTemplateId]
-				if !exist {
-					_ = session.Rollback()
-					return grmi.NewBusinessError("存在单据打印规则中配置的标签模板, 模板ID:" + generateRule.TemplateId)
+				sfpSerialOrder := model.SerialOrder{
+					SerialOrderId:    serialOrderId,
+					ArtId:            orderOPData.SFP.ArtId,
+					ProjectId:        projectId,
+					Descr:            orderOPData.SFP.Descr1,
+					CustOrderId:      serialOrder.CustOrderId,
+					LastPieceInBatch: serialOrder.LastPieceInBatch,
+					PreSchedKey:      schedKey,
+					SchedKey:         schedKey,
+					OrderType:        baseModel.ORDER_TYPE_PRE,
+					OrderType1:       serialOrder.OrderType1,
+					OrderType2:       serialOrder.OrderType2,
+					PlanResourceId:   serialOrder.PlanResourceId,
+					UsedResourceId:   serialOrder.UsedResourceId,
+					PlanQty:          1,
+					QtyUomId:         serialOrder.QtyUomId,
+					OpTimePerItem:    serialOrder.OpTimePerItem,
+					TimeUomId:        serialOrder.TimeUomId,
+					PlanStartDate:    serialOrder.PlanStartDate,
+					PlanEndDate:      serialOrder.PlanEndDate,
+					SetupStartTime:   serialOrder.SetupStartTime,
+					SetupEndTime:     serialOrder.SetupEndTime,
+					PlanStartTime:    serialOrder.PlanStartTime,
+					PlanEndTime:      serialOrder.PlanEndTime,
+					PickingFlag:      orderOPData.SFP.PickingFlag,
+					MainOrderId:      serialOrder.SerialOrderId,
+				}
+				err = serialOrderDao.InsertOne(&sfpSerialOrder)
+				if err != nil {
+					return grmi.NewBusinessError("写入预装工单失败， 错误:" + err.Error())
+				}
+				sfpSerialOrderStatus := model.SerialOrderStatus{
+					SerialOrderId: serialOrderId,
+					Status:        baseModel.WO_STATUS_RELEASED,
 				}
+				err = serialOrderStatusDao.InsertOne(&sfpSerialOrderStatus)
+				if err != nil {
+					return grmi.NewBusinessError("写入预装工单状态数据失败, 错误:" + err.Error())
+				}
+				//schedKey++
+			} else {
+				usedArticle = article
+				serialOrderId = serialOrder.SerialOrderId
 			}
+			var PO string
+			processPos := 1
+			opPos := 1
+			for _, op := range orderOPData.MeOperationLi {
+				// 生成工序操作状态表
+				if PO != op.Process.PO {
+					PO = op.Process.PO
+					serialOrderWorkPlace := model.SerialOrderPOLst{
+						SerialOrderId: serialOrderId,
+						PO:            PO,
+						Status:        baseModel.WO_STATUS_RELEASED,
+						HasDependOn:   op.Process.HasDependOn,
+					}
+					err = PODao.InsertOne(&serialOrderWorkPlace)
+					if err != nil {
+						return grmi.NewBusinessError("插入serialOrder工序数据失败,error:" + err.Error())
+					}
+					processPos++
+				}
+				serialOrderStep := model.SerialOrderStepLst{
+					PO:            op.Process.PO,
+					OperationId:   op.OperationId,
+					SerialOrderId: 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_RELEASED,
+				}
+				opPos++
+				err = stepDao.InsertOne(&serialOrderStep)
+				if err != nil {
+					return grmi.NewBusinessError("插入序列工单工艺数据失败, error:" + err.Error())
+				}
+				if serialOrderStep.StepType == baseModel.STEP_CHECK_RULE { // 生成扫码校验的工艺数据
+					scanRule, exist := scanRuleMap[serialOrderStep.OperationId]
+					if !exist {
+						return grmi.NewBusinessError("未获取到扫描校验详细规则, 工艺ID:" + strconv.Itoa(serialOrderStep.OperationId))
+					}
 
-			err = impl.PrintRuleInfo(user, session, &serialOrderStep, generateRule, printTemplate, article, op.Operation.ActivateInBKStation)
-			if err != nil {
-				_ = session.Rollback()
-				return err
+					checkRuleMapPointer, allocateMapPointer, err := impl.ScanCodeCheck(user, session, checkRuleMap, allocateMap, artMap, &scanRule, &op, &serialOrderStep, op.Operation.ActivateInBKStation)
+					if err != nil {
+						return err
+					}
+					checkRuleMap = *checkRuleMapPointer
+					allocateMap = *allocateMapPointer
+				} else if serialOrderStep.StepType == baseModel.STEP_OPC_RULE { // 生成OPC通讯的工艺数据
+					opcBasicMapPointer, err := impl.OPCCommunication(user, session, opcBasicMap, &serialOrderStep, attributeMap, artMap, op.Operation.ActivateInBKStation)
+					if err != nil {
+						return err
+					}
+					opcBasicMap = *opcBasicMapPointer
+				} else if serialOrderStep.StepType == baseModel.STEP_TW_RULE { // 生成开发协议的工艺数据
+					twMapPointer, err := impl.TightenWrenchInfo(user, session, twMap, &serialOrderStep, op.Operation.ActivateInBKStation, usedArticle)
+					if err != nil {
+						return err
+					}
+					twMap = *twMapPointer
+				} else if serialOrderStep.StepType == baseModel.STEP_GUIDE_RULE {
+					guideRule, exist := guideRuleMap[serialOrderStep.OperationId]
+					if !exist {
+						return grmi.NewBusinessError("未获取到指导操作的详细规则")
+					}
+					err = impl.GuideRuleInfo(user, session, &guideRule, &serialOrderStep, op.Operation.ActivateInBKStation)
+					if err != nil {
+						return err
+					}
+				} else if serialOrderStep.StepType == baseModel.STEP_PRINT_RULE {
+					ruleLi, exist := printRuleMap[serialOrderStep.OperationId]
+					if !exist {
+						return grmi.NewBusinessError("未获取到打印规则, 工艺ID:" + strconv.Itoa(serialOrderStep.OperationId))
+					}
+					generateRuleLi := make([]baseModel.PrintBasicRuleInfo, 0)
+					for _, rule := range ruleLi {
+						if rule.Action == baseModel.PRINT_RULE_ACTION_UPDATE {
+							generateRuleLi = append(generateRuleLi, rule)
+						}
+					}
+					if len(generateRuleLi) > 1 {
+						return grmi.NewBusinessError("改工步匹配到超过1条生成打印标识的打印规则")
+					}
+					var generateRule *baseModel.PrintBasicRuleInfo
+					var printTemplate *baseModel.LabelTemplateHead
+					if len(generateRuleLi) == 1 {
+						generateRule = &generateRuleLi[0]
+						var templateId string
+						if generateRule.MainCodeName == "Pre" {
+							templateId = generateRule.TemplateId
+						} else {
+							templateId = product.PrintTemplateId
+						}
+						printTemplate, exist = labelTemplateMap[templateId]
+						if !exist {
+							return grmi.NewBusinessError("存在单据打印规则中配置的标签模板, 模板ID:" + generateRule.TemplateId)
+						}
+					}
+					err = impl.PrintRuleInfo(user, session, &serialOrderStep, generateRule, printTemplate, usedArticle, op.Operation.ActivateInBKStation)
+					if err != nil {
+						return err
+					}
+				} else {
+					return grmi.NewBusinessError("获取到的工艺数据系统暂不支持该操作类型:" + serialOrderStep.StepType)
+				}
 			}
-		} else {
-			_ = session.Rollback()
-			return grmi.NewBusinessError("获取到的工艺数据系统暂不支持该操作类型:" + serialOrderStep.StepType)
 		}
 	}
-	_ = session.Commit()
 	return nil
 }
 
@@ -3648,6 +3771,10 @@ func (impl *SerialOrderServiceImplement) CreateBatchSerialOrder(user *global.Use
 	if err != nil {
 		return grmi.NewBusinessError("查询项目数据失败, error:" + err.Error())
 	}
+	insertSerialOrderLi := make([]model.SerialOrder, 0, qty)
+	if err = session.Begin(); err != nil {
+		return grmi.NewBusinessError("开启事务失败, 错误:" + err.Error())
+	}
 	if priority != 0 {
 		now := time.Now()
 		for i := 1; i <= qty; i++ {
@@ -3680,9 +3807,10 @@ func (impl *SerialOrderServiceImplement) CreateBatchSerialOrder(user *global.Use
 				_ = session.Rollback()
 				return grmi.NewBusinessError("写入工单数据失败, error:" + err.Error())
 			}
+			insertSerialOrderLi = append(insertSerialOrderLi, insertOrder)
 			insertOrderStatus := model.SerialOrderStatus{
 				SerialOrderId: serialOrderId,
-				Status:        baseModel.WO_STATUS_LOCKED,
+				Status:        baseModel.WO_STATUS_RELEASED,
 			}
 			err = serialOrderStatusDao.InsertOne(&insertOrderStatus)
 			if err != nil {
@@ -3693,9 +3821,11 @@ func (impl *SerialOrderServiceImplement) CreateBatchSerialOrder(user *global.Use
 	} else {
 		serialOrder, err := serialOrderDao.Select([]grmi.Predicate{meta.SerialOrder_SchedKey.NewPredicate(grmi.Equal, preSchKey)}, nil)
 		if err != nil {
+			_ = session.Rollback()
 			return grmi.NewBusinessError("查询工单数据失败, error:" + err.Error())
 		}
 		if serialOrder == nil {
+			_ = session.Rollback()
 			return grmi.NewBusinessError("指定前序的工单不存在")
 		}
 		schedKeyLi := make([]interface{}, 0, qty)
@@ -3704,9 +3834,12 @@ func (impl *SerialOrderServiceImplement) CreateBatchSerialOrder(user *global.Use
 		}
 		serialOrderLi, err := serialOrderDao.Select([]grmi.Predicate{meta.SerialOrder_SchedKey.NewPredicate(grmi.Include, schedKeyLi...)}, nil)
 		if err != nil {
+			_ = session.Rollback()
 			return grmi.NewBusinessError("查询工单数据失败, error:" + err.Error())
 		}
 		if len(serialOrderLi) > 0 {
+			_ = session.Rollback()
+			fmt.Println("schedKeyLi:", schedKeyLi)
 			return grmi.NewBusinessError("生成的排序Key已存在工单")
 		}
 		now := time.Now()
@@ -3743,9 +3876,10 @@ func (impl *SerialOrderServiceImplement) CreateBatchSerialOrder(user *global.Use
 				_ = session.Rollback()
 				return grmi.NewBusinessError("写入工单数据失败, error:" + err.Error())
 			}
+			insertSerialOrderLi = append(insertSerialOrderLi, insertOrder)
 			insertOrderStatus := model.SerialOrderStatus{
 				SerialOrderId: serialOrderId,
-				Status:        baseModel.WO_STATUS_LOCKED,
+				Status:        baseModel.WO_STATUS_RELEASED,
 			}
 			err = serialOrderStatusDao.InsertOne(&insertOrderStatus)
 			if err != nil {
@@ -3754,152 +3888,159 @@ func (impl *SerialOrderServiceImplement) CreateBatchSerialOrder(user *global.Use
 			}
 		}
 	}
+	err = impl.GenerateCraftData(user, session, insertSerialOrderLi)
+	if err != nil {
+		_ = session.Rollback()
+		return err
+	}
 	_ = session.Commit()
 	return nil
 }
 
-//func (impl *SerialOrderServiceImplement) CancelBatchSerialOrder(user *global.User, serialOrderIdLi []string) error {
-//	engine := db.Eloquent.Master()
-//	session := engine.NewSession()
-//	defer session.Close()
-//	dao := dal.NewSerialOrderDAO(session, user.PlantNr, user.UserId)
-//	statusRecDao := dal.NewSerialOrderStatusRecLstDAO(session, user.PlantNr, user.UserId)
-//	serialOrderPOLstDao := dal.NewSerialOrderPOLstDAO(session, user.PlantNr, user.UserId)
-//	serialOrderStepDao := dal.NewSerialOrderStepLstDAO(session, user.PlantNr, user.UserId)
-//	serialOrderOPDetailDao := dal.NewSerialOrderOPDetailDAO(session, user.PlantNr, user.UserId)
-//	for _, serialOrderId := range serialOrderIdLi {
-//		record, err := dao.SelectOne(serialOrderId)
-//		if err != nil {
-//			return err
-//		}
-//		if record == nil {
-//			return grmi.NewBusinessError("不存在指定记录!")
-//		}
-//		if record.OrderType != baseModel.ODER_TYPE_INTERVAL {
-//			return grmi.NewBusinessError("工单不是内部工单，不允许取消, 工单ID:" + serialOrderId)
-//		}
-//		statusDao := dal.NewSerialOrderStatusDAO(session, user.PlantNr, user.UserId)
-//		status, err := statusDao.SelectOne(serialOrderId)
-//		if err != nil {
-//			return grmi.NewBusinessError("查询工单状态数据失败, error:" + err.Error())
-//		}
-//		if status == nil {
-//			return grmi.NewBusinessError("工单状态数据不存在, 工单ID:" + serialOrderId)
-//		}
-//		originStatus := status.Status
-//		if status.Status > baseModel.WO_STATUS_RELEASED {
-//			return grmi.NewBusinessError("工单已经进行不允许取消, 工单ID：" + serialOrderId)
-//		}
-//		preSerialOrderLi, err := dao.Select([]grmi.Predicate{
-//			meta.SerialOrder_OrderType.NewPredicate(grmi.Equal, baseModel.ORDER_TYPE_PRE),
-//			meta.SerialOrder_GenerateFlag.NewPredicate(grmi.Equal, 0),
-//			meta.SerialOrder_MainOrderId.NewPredicate(grmi.Equal, 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)
-//			}
-//		}
-//		if err := session.Begin(); err != nil {
-//			return err
-//		}
-//
-//		statusRec := model.SerialOrderStatusRecLst{
-//			SerialOrderId: serialOrderId,
-//			Status:        baseModel.WO_STATUS_CANCELED,
-//			PrevStatus:    status.Status,
-//		}
-//		status.Status = baseModel.WO_STATUS_CANCELED
-//		err = statusRecDao.InsertOne(&statusRec)
-//		if err != nil {
-//			_ = session.Rollback()
-//			return grmi.NewBusinessError("插入工单状态变更记录失败, error:" + err.Error())
-//		}
-//		err = statusDao.UpdateOne(status)
-//		if err != nil {
-//			_ = session.Rollback()
-//			return grmi.NewBusinessError("更新工单状态失败， error:" + err.Error())
-//		}
-//		if originStatus == baseModel.WO_STATUS_RELEASED {
-//			poUpdateData := &model.SerialOrderPOLst{
-//				Status: baseModel.WO_STATUS_CANCELED,
-//			}
-//			err = serialOrderPOLstDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderId)}, poUpdateData, meta.SerialOrderPOLst_Status.Name)
-//			if err != nil {
-//				_ = session.Rollback()
-//				return grmi.NewBusinessError("更新工单工序状态失败, error:" + err.Error())
-//			}
-//			stepUpdateData := &model.SerialOrderStepLst{
-//				Status: baseModel.WO_STATUS_CANCELED,
-//			}
-//			err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderId)}, stepUpdateData, meta.SerialOrderStepLst_Status.Name)
-//			if err != nil {
-//				_ = session.Rollback()
-//				return grmi.NewBusinessError("更新工单工步状态失败, error:" + err.Error())
-//			}
-//			opDetailUpdateData := &model.SerialOrderOPDetail{
-//				Status: baseModel.WO_STATUS_CANCELED,
-//			}
-//			err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, serialOrderId)}, opDetailUpdateData, meta.SerialOrderOPDetail_Status.Name)
-//			if err != nil {
-//				_ = session.Rollback()
-//				return grmi.NewBusinessError("更新工单详细操作状态失败, error:" + err.Error())
-//			}
-//		}
-//		// 取消预装工单
-//		for _, preOrder := range preSerialOrderLi {
-//			originStatus = preOrder.SerialOrderStatus.Status
-//			statusRec = model.SerialOrderStatusRecLst{
-//				SerialOrderId: preOrder.SerialOrderId,
-//				Status:        baseModel.WO_STATUS_CANCELED,
-//				PrevStatus:    preOrder.SerialOrderStatus.Status,
-//			}
-//			preOrder.SerialOrderStatus.Status = baseModel.WO_STATUS_CANCELED
-//			err = statusRecDao.InsertOne(&statusRec)
-//			if err != nil {
-//				_ = session.Rollback()
-//				return grmi.NewBusinessError("插入预装工单状态变更记录失败, error:" + err.Error())
-//			}
-//			err = statusDao.UpdateOne(&preOrder.SerialOrderStatus)
-//			if err != nil {
-//				_ = session.Rollback()
-//				return grmi.NewBusinessError("更新预装工单状态失败， error:" + err.Error())
-//			}
-//			if originStatus == baseModel.WO_STATUS_RELEASED {
-//				poUpdateData := &model.SerialOrderPOLst{
-//					Status: baseModel.WO_STATUS_CANCELED,
-//				}
-//				err = serialOrderPOLstDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, poUpdateData, meta.SerialOrderPOLst_Status.Name)
-//				if err != nil {
-//					_ = session.Rollback()
-//					return grmi.NewBusinessError("更新预装工单工序状态失败, error:" + err.Error())
-//				}
-//				stepUpdateData := &model.SerialOrderStepLst{
-//					Status: baseModel.WO_STATUS_CANCELED,
-//				}
-//				err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, stepUpdateData, meta.SerialOrderStepLst_Status.Name)
-//				if err != nil {
-//					_ = session.Rollback()
-//					return grmi.NewBusinessError("更新预装工单工步状态失败, error:" + err.Error())
-//				}
-//				opDetailUpdateData := &model.SerialOrderOPDetail{
-//					Status: baseModel.WO_STATUS_CANCELED,
-//				}
-//				err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, opDetailUpdateData, meta.SerialOrderOPDetail_Status.Name)
-//				if err != nil {
-//					_ = session.Rollback()
-//					return grmi.NewBusinessError("更新预装工单详细操作状态失败, error:" + err.Error())
-//				}
-//			}
-//		}
-//	}
-//	_ = session.Commit()
-//	return nil
-//}
+// CancelMultiSerialOrder 批量取消工单
+func (impl *SerialOrderServiceImplement) CancelMultiSerialOrder(user *global.User, serialOrderIdLi []string) error {
+	engine := db.Eloquent.Master()
+	session := engine.NewSession()
+	defer session.Close()
+	dao := dal.NewSerialOrderDAO(session, user.PlantNr, user.UserId)
+	statusRecDao := dal.NewSerialOrderStatusRecLstDAO(session, user.PlantNr, user.UserId)
+	serialOrderPOLstDao := dal.NewSerialOrderPOLstDAO(session, user.PlantNr, user.UserId)
+	serialOrderStepDao := dal.NewSerialOrderStepLstDAO(session, user.PlantNr, user.UserId)
+	serialOrderOPDetailDao := dal.NewSerialOrderOPDetailDAO(session, user.PlantNr, user.UserId)
+	for _, serialOrderId := range serialOrderIdLi {
+		record, err := dao.SelectOne(serialOrderId)
+		if err != nil {
+			return err
+		}
+		if record == nil {
+			return grmi.NewBusinessError("不存在指定记录!")
+		}
+		if record.OrderType != baseModel.ODER_TYPE_INTERVAL {
+			return grmi.NewBusinessError("工单不是内部工单，不允许取消, 工单ID:" + serialOrderId)
+		}
+		statusDao := dal.NewSerialOrderStatusDAO(session, user.PlantNr, user.UserId)
+		status, err := statusDao.SelectOne(serialOrderId)
+		if err != nil {
+			return grmi.NewBusinessError("查询工单状态数据失败, error:" + err.Error())
+		}
+		if status == nil {
+			return grmi.NewBusinessError("工单状态数据不存在, 工单ID:" + serialOrderId)
+		}
+		originStatus := status.Status
+		if status.Status > baseModel.WO_STATUS_RELEASED {
+			return grmi.NewBusinessError("工单已经进行不允许取消, 工单ID：" + serialOrderId)
+		}
+		preSerialOrderLi, err := dao.Select([]grmi.Predicate{
+			meta.SerialOrder_OrderType.NewPredicate(grmi.Equal, baseModel.ORDER_TYPE_PRE),
+			meta.SerialOrder_GenerateFlag.NewPredicate(grmi.Equal, 0),
+			meta.SerialOrder_MainOrderId.NewPredicate(grmi.Equal, 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)
+			}
+		}
+		if err := session.Begin(); err != nil {
+			return grmi.NewBusinessError("开启事务失败, 错误：" + err.Error())
+		}
+
+		statusRec := model.SerialOrderStatusRecLst{
+			SerialOrderId: serialOrderId,
+			Status:        baseModel.WO_STATUS_CANCELED,
+			PrevStatus:    status.Status,
+		}
+		status.Status = baseModel.WO_STATUS_CANCELED
+		err = statusRecDao.InsertOne(&statusRec)
+		if err != nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("插入工单状态变更记录失败, error:" + err.Error())
+		}
+		err = statusDao.UpdateOne(status)
+		if err != nil {
+			_ = session.Rollback()
+			return grmi.NewBusinessError("更新工单状态失败， error:" + err.Error())
+		}
+		if originStatus == baseModel.WO_STATUS_RELEASED {
+			poUpdateData := &model.SerialOrderPOLst{
+				Status: baseModel.WO_STATUS_CANCELED,
+			}
+			err = serialOrderPOLstDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderId)}, poUpdateData, meta.SerialOrderPOLst_Status.Name)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("更新工单工序状态失败, error:" + err.Error())
+			}
+			stepUpdateData := &model.SerialOrderStepLst{
+				Status: baseModel.WO_STATUS_CANCELED,
+			}
+			err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderId)}, stepUpdateData, meta.SerialOrderStepLst_Status.Name)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("更新工单工步状态失败, error:" + err.Error())
+			}
+			opDetailUpdateData := &model.SerialOrderOPDetail{
+				Status: baseModel.WO_STATUS_CANCELED,
+			}
+			err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, serialOrderId)}, opDetailUpdateData, meta.SerialOrderOPDetail_Status.Name)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("更新工单详细操作状态失败, error:" + err.Error())
+			}
+		}
+		// 取消预装工单
+		for _, preOrder := range preSerialOrderLi {
+			originStatus = preOrder.SerialOrderStatus.Status
+			statusRec = model.SerialOrderStatusRecLst{
+				SerialOrderId: preOrder.SerialOrderId,
+				Status:        baseModel.WO_STATUS_CANCELED,
+				PrevStatus:    preOrder.SerialOrderStatus.Status,
+			}
+			preOrder.SerialOrderStatus.Status = baseModel.WO_STATUS_CANCELED
+			err = statusRecDao.InsertOne(&statusRec)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("插入预装工单状态变更记录失败, error:" + err.Error())
+			}
+			err = statusDao.UpdateOne(&preOrder.SerialOrderStatus)
+			if err != nil {
+				_ = session.Rollback()
+				return grmi.NewBusinessError("更新预装工单状态失败， error:" + err.Error())
+			}
+			if originStatus == baseModel.WO_STATUS_RELEASED {
+				poUpdateData := &model.SerialOrderPOLst{
+					Status: baseModel.WO_STATUS_CANCELED,
+				}
+				err = serialOrderPOLstDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, poUpdateData, meta.SerialOrderPOLst_Status.Name)
+				if err != nil {
+					_ = session.Rollback()
+					return grmi.NewBusinessError("更新预装工单工序状态失败, error:" + err.Error())
+				}
+				stepUpdateData := &model.SerialOrderStepLst{
+					Status: baseModel.WO_STATUS_CANCELED,
+				}
+				err = serialOrderStepDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, stepUpdateData, meta.SerialOrderStepLst_Status.Name)
+				if err != nil {
+					_ = session.Rollback()
+					return grmi.NewBusinessError("更新预装工单工步状态失败, error:" + err.Error())
+				}
+				opDetailUpdateData := &model.SerialOrderOPDetail{
+					Status: baseModel.WO_STATUS_CANCELED,
+				}
+				err = serialOrderOPDetailDao.UpdateWhere([]grmi.Predicate{meta.SerialOrderOPDetail_SerialOrderId.NewPredicate(grmi.Equal, preOrder.SerialOrderId)}, opDetailUpdateData, meta.SerialOrderOPDetail_Status.Name)
+				if err != nil {
+					_ = session.Rollback()
+					return grmi.NewBusinessError("更新预装工单详细操作状态失败, error:" + err.Error())
+				}
+			}
+		}
+	}
+	_ = session.Commit()
+	return nil
+}
 
+// TraceSubArticleBatch 根据物料批次查询mes数据
 func (impl *SerialOrderServiceImplement) TraceSubArticleBatch(user *global.User, barcode string, paging *grmi.Paging) (grmi.PagingResult, error) {
 	engine := db.Eloquent.Master()
 	session := engine.NewSession()
diff --git a/web/controllers/om/SerialOrder.rest.go b/web/controllers/om/SerialOrder.rest.go
index d5b725d..8858dd3 100644
--- a/web/controllers/om/SerialOrder.rest.go
+++ b/web/controllers/om/SerialOrder.rest.go
@@ -1241,4 +1241,33 @@ func RegisterExportTraceArticleBatch(party router.Party, path string, method fun
 		}
 		supports.Ok(ctx, supports.OptionSuccess, result)
 	})
-}
\ No newline at end of file
+}
+
+// RegisterCancelMultiSerialOrder 批量取消工单
+func RegisterCancelMultiSerialOrder(party router.Party, path string, method func(user *global.User, serialOrderIdLi []string) error) {
+
+	party.Post(path, func(ctx iris.Context) {
+		user, ok := jwts.ParseToken(ctx)
+		if !ok {
+			return
+		}
+		type Req struct {
+			SerialOrderIdLi []string `json:"serialOrderIdLi"`
+		}
+		var data Req
+		if err := ctx.ReadJSON(&data); err != nil {
+			supports.Error(ctx, iris.StatusBadRequest, err.Error(), nil)
+			return
+		}
+		if len(data.SerialOrderIdLi) == 0 {
+			supports.Error(ctx, iris.StatusBadRequest, "未获取到工单条码", nil)
+			return
+		}
+		err := method(user, data.SerialOrderIdLi)
+		if err != nil {
+			supports.Error(ctx, iris.StatusBadRequest, err.Error(), nil)
+			return
+		}
+		supports.Ok(ctx, supports.OptionSuccess, nil)
+	})
+}
diff --git a/web/controllers/om/om.go b/web/controllers/om/om.go
index c4f4859..c68aca1 100644
--- a/web/controllers/om/om.go
+++ b/web/controllers/om/om.go
@@ -212,7 +212,7 @@ func RegisterRoutes() {
 		// SerialOrder 修改排序队列中内部订单的调用Key
 		RegisterChangeOrderSchedKey(serialorder, "/changeschedkey", serviceOfSerialOrder.ChangeOrderSchedKey)
 		// SerialOrder 生成serialOrder工艺数据
-		RegisterGenerateSerialOrderCraft(serialorder, "/generatecraft", serviceOfSerialOrder.GenerateCraftData)
+		//RegisterGenerateSerialOrderCraft(serialorder, "/generatecraft", serviceOfSerialOrder.GenerateCraftData)
 		// SerialOrder 派工已锁定的内部订单
 		RegisterReleaseSerialOrder(serialorder, "/release", serviceOfSerialOrder.ReleaseSerialOrder)
 		// SerialOrder 查询工单操作数据
@@ -229,6 +229,8 @@ func RegisterRoutes() {
 		RegisterTraceArticleBatch(serialorder, "/tracebatch", serviceOfSerialOrder.TraceSubArticleBatch)
 		// serialOrder 导出物料批次查询结果
 		RegisterExportTraceArticleBatch(serialorder, "/exporttracebatch", serviceOfSerialOrder.ExportTraceSubArticleBatch)
+		// serialOrder 批量取消工单
+		RegisterCancelMultiSerialOrder(serialorder, "/multicancel", serviceOfSerialOrder.CancelMultiSerialOrder)
 
 		// SerialOrderStatus的路由组
 		serialorderstatus := party.Party("/serialorderstatus")