diff --git a/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMOInsertBP.java b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMOInsertBP.java new file mode 100644 index 0000000..82d3690 --- /dev/null +++ b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMOInsertBP.java @@ -0,0 +1,382 @@ +package nc.bs.mmpac.pmo.pac0002.bp; + +import java.util.ArrayList; +import java.util.List; +import nc.bs.mmpac.pmo.pac0002.pluginpoint.PMOPluginPoint; +import nc.bs.mmpac.pmo.pac0002.rule.PMOATOCheckRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOATPUpdateRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOCffileidInserAndUpdatetRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOCreatePickmWhenInsertRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOInsertSaveApproveRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOMarkWrSNWhenInsertRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOSNDupCheckRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOSaveSNWhenInsertRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOSplitByTaskDetailsRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOSyncSNWhenInsertRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.CheckMaterialIsEnableRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckCinwarehouseidRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckDMODuplicateRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckDateLogicRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckMaterialPermissionRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckNrwxisLogicRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckParentStatusRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckProcedureDateLogicRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckProcedureDupRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckProcedurePSCRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckProcedureratioRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckProdurepointRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckSCDuplicateRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckSNNumAndUnitRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckSaveNotNullRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOProcedureChkPntRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillBatchCodeRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillFirstMOInfoRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillInsertBatchValueRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillInsertDefaultValueRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillInsertPlanTimeByProcedureRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillMaterialRelationRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillPushDefaultValueRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillPushVersionRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillSNPkAndCodeRule; +import nc.bs.mmpac.pmo.pac0002.rule.grand.PMOCreatePlanOutputRule; +import nc.bs.mmpac.pmo.pac0002.rule.grand.PMOCreateProcedureRule; +import nc.bs.mmpac.pmo.pac0002.rule.grand.PMOSyncPlanmmNumRule; +import nc.bs.mmpac.pmo.pac0002.rule.rewrite.RewriteInsertNum4MPS; +import nc.bs.mmpac.pmo.pac0002.rule.rewrite.RewriteInsertNum4PMO; +import nc.bs.mmpac.pmo.pac0002.rule.rewrite.RewriteInsertNum4PSCRecive; +import nc.bs.mmpac.pmo.pac0002.rule.rewrite.RewriteInsertNum4PSM; +import nc.bs.mmpac.pmo.pac0002.rule.rewrite.RewriteInsertNum4Renovate; +import nc.bs.mmpac.pmo.pac0002.rule.rewrite.RewriteInsertNum4SFC; +import nc.bs.mmpac.pmo.pac0002.rule.rewrite.RewriteInsertNum4SO; +import nc.bs.mmpac.pmo.pac0002.rule.rewrite.RewriteInsertNum4TO; +import nc.bs.mmpac.pmo.pac0002.bp.rule.saveBeforeCheckRule; +import nc.bs.mmpub.rule.MMATOMaterialCheckRule; +import nc.bs.mmpub.rule.MMAutoMaterialAssignRule; +import nc.bs.mmpub.rule.MMBillTypeIsLockCheckRule; +import nc.bs.pubapp.pub.rule.FieldLengthCheckRule; +import nc.bs.pubapp.pub.rule.FillInsertDataRule; +import nc.bs.pubapp.pub.rule.OrgDisabledCheckRule; +import nc.impl.pubapp.bd.userdef.UserDefSaveRule; +import nc.impl.pubapp.pattern.rule.IRule; +import nc.impl.pubapp.pattern.rule.processer.AroundProcesser; +import nc.pubitf.sn.doc.param.SnDocParam; +import nc.util.mmf.busi.rule.MMBillCodeCheckAndTrantypeRule; +import nc.util.mmf.busi.rule.MMCheckMaterialProdModeRule; +import nc.util.mmf.busi.rule.MMCheckMaterialVirtualRule; +import nc.util.mmf.busi.rule.MMCreateBillcodeAndTrantypecodeRule; +import nc.util.mmf.busi.rule.MMRowNoCheckRule; +import nc.util.mmf.framework.gc.GCBillCloneUtil; +import nc.util.mmf.framework.gc.GCBillInsert; +import nc.util.mmf.framework.gc.GCInsertBPTemplate; +import nc.vo.mmpac.pmo.pac0002.entity.PMOAggVO; +import nc.vo.mmpac.pmo.pac0002.util.PmoSagaUtil; + +public class PMOInsertBP { + public PMOAggVO[] insert(PMOAggVO[] bills, boolean issub, boolean isPush) { + AroundProcesser processer = new AroundProcesser(PMOPluginPoint.INSERT); + List updateParams = new ArrayList(); + List saveParams = new ArrayList(); + + addBeforeRule(processer, issub, isPush, updateParams, saveParams); + + addAfterRule(processer, issub, isPush, updateParams, saveParams); + GCBillInsert bo = new GCBillInsert(); + PMOAggVO[] aggvos = (PMOAggVO[]) processer.before(bills); + PMOAggVO[] newvos = (PMOAggVO[]) bo.insert(aggvos); + + PmoSagaUtil.addSagaAndCompensate4Insert(newvos); + return (PMOAggVO[]) processer.after(newvos); + } + + public void insertSagasCheck(PMOAggVO[] bills, boolean issub, boolean isPush) { + GCInsertBPTemplate bp = new GCInsertBPTemplate(PMOPluginPoint.INSERT); + + addBeforeRuleSagasCheck(bp.getAroundProcesser(), issub, isPush); + bp.getAroundProcesser().before(bills); + } + + private void addBeforeRule(AroundProcesser processer, boolean issub, boolean isPush, + List updateParams, List saveParams) { + IRule materialIsEnableRule = new CheckMaterialIsEnableRule(); + processer.addBeforeRule(materialIsEnableRule); + + OrgDisabledCheckRule orgDisabledCheckRule = new OrgDisabledCheckRule("pk_org", "FACTORYTYPE000000000"); + processer.addBeforeRule(orgDisabledCheckRule); + + FillInsertDataRule fillInsertDataRule = new FillInsertDataRule(); + processer.addBeforeRule(fillInsertDataRule); + + MMBillTypeIsLockCheckRule mMBillTypeIsLockCheckRule = new MMBillTypeIsLockCheckRule("vtrantypecode"); + processer.addBeforeRule(mMBillTypeIsLockCheckRule); + + MMAutoMaterialAssignRule mMAutoMaterialAssignRule = new MMAutoMaterialAssignRule(null, "cmaterialvid", + new String[] { "pk_org", "cplanfactoryid" }, null); + + processer.addBeforeFinalRule(mMAutoMaterialAssignRule); + + MMATOMaterialCheckRule mMATOMaterialCheckRule = new MMATOMaterialCheckRule(null, "cmaterialvid", "cffileid"); + + processer.addBeforeRule(mMATOMaterialCheckRule); + + IRule marperrule = new PMOCheckMaterialPermissionRule(); + processer.addBeforeRule(marperrule); + + MMCheckMaterialVirtualRule mMCheckMaterialVirtualRule = new MMCheckMaterialVirtualRule(); + processer.addBeforeRule(mMCheckMaterialVirtualRule); + + IRule chkrwxisrule = new PMOCheckNrwxisLogicRule(); + processer.addBeforeRule(chkrwxisrule); + + IRule chkrule = new PMOCheckSaveNotNullRule(issub); + processer.addBeforeRule(chkrule); + + IRule fillvaluerule = new PMOFillInsertDefaultValueRule(); + processer.addBeforeRule(fillvaluerule); + + processer.addBeforeRule(new PMOSyncPlanmmNumRule()); + + MMRowNoCheckRule mMRowNoCheckRule = new MMRowNoCheckRule(); + processer.addBeforeRule(mMRowNoCheckRule); + + IRule scrapAddrule = new PMOCheckParentStatusRule(); + processer.addBeforeRule(scrapAddrule); + + IRule snDuprule = new PMOSNDupCheckRule(); + processer.addBeforeRule(snDuprule); + + IRule outputrule = new PMOCreatePlanOutputRule(); + processer.addBeforeRule(outputrule); + + IRule procedurerule = new PMOCreateProcedureRule(isPush); + processer.addBeforeRule(procedurerule); + + IRule filltimeprocedurerule = new PMOFillInsertPlanTimeByProcedureRule(); + processer.addBeforeRule(filltimeprocedurerule); + + IRule daterule = new PMOCheckDateLogicRule(); + processer.addBeforeRule(daterule); + + IRule chkPntRule = new PMOProcedureChkPntRule(); + processer.addBeforeRule(chkPntRule); + + processer.addBeforeRule(new PMOCheckProdurepointRule()); + + IRule procdatelogicrule = new PMOCheckProcedureDateLogicRule(true); + processer.addBeforeRule(procdatelogicrule); + + IRule proccoderule = new PMOCheckProcedureDupRule(); + processer.addBeforeRule(proccoderule); + + IRule procPscCheckRule = new PMOCheckProcedurePSCRule(); + processer.addBeforeRule(procPscCheckRule); + + FieldLengthCheckRule fieldLengthCheckRule = new FieldLengthCheckRule(); + processer.addBeforeRule(fieldLengthCheckRule); + + UserDefSaveRule defRule = new UserDefSaveRule( + new Class[] { nc.vo.mmpac.pmo.pac0002.entity.PMOItemVO.class }); + processer.addBeforeRule(defRule); + + MMCheckMaterialProdModeRule prodModeRule = new MMCheckMaterialProdModeRule(1, + nc.vo.mmpac.pmo.pac0002.entity.PMOItemVO.class); + + processer.addBeforeRule(prodModeRule); + + IRule rewriteReviceRule = new RewriteInsertNum4PSCRecive(); + processer.addBeforeRule(rewriteReviceRule); + + IRule wrMarkRule = new PMOMarkWrSNWhenInsertRule(); + processer.addBeforeRule(wrMarkRule); + + IRule atprule = new PMOATPUpdateRule(true, "55A2"); + processer.addBeforeRule(atprule); + + IRule rewritewr = new RewriteInsertNum4Renovate(); + processer.addBeforeRule(rewritewr); + + IRule rewritesfc = new RewriteInsertNum4SFC(); + processer.addBeforeRule(rewritesfc); + + MMCreateBillcodeAndTrantypecodeRule mMCreateBillcodeAndTrantypecodeRule = new MMCreateBillcodeAndTrantypecodeRule( + "55A2", "vbillcode", "pk_group", "pk_org", "vtrantypecode"); + + processer.addBeforeRule(mMCreateBillcodeAndTrantypecodeRule); + + IRule fillfirstInfo = new PMOFillFirstMOInfoRule(); + processer.addBeforeRule(fillfirstInfo); + + IRule fillbatchvaluerule = new PMOFillInsertBatchValueRule(); + processer.addBeforeRule(fillbatchvaluerule); + + IRule batchcodeRule = new PMOFillBatchCodeRule(); + processer.addBeforeRule(batchcodeRule); + + PMOCffileidInserAndUpdatetRule cffileidRule = new PMOCffileidInserAndUpdatetRule(); + processer.addBeforeRule(cffileidRule); + + IRule snCheckRule = new PMOCheckSNNumAndUnitRule(); + processer.addBeforeRule(snCheckRule); + + IRule snRule = new PMOFillSNPkAndCodeRule(); + processer.addBeforeRule(snRule); + + IRule snSyncRule = new PMOSyncSNWhenInsertRule(updateParams, saveParams); + processer.addBeforeRule(snSyncRule); + + IRule checkCinwarehouseidRule = new PMOCheckCinwarehouseidRule(); + processer.addBeforeRule(checkCinwarehouseidRule); + + IRule atoCheck = new PMOATOCheckRule(); + processer.addBeforeRule(atoCheck); + + IRule procedureIRule = new PMOCheckProcedureratioRule(); + processer.addBeforeRule(procedureIRule); + + IRule saveBeforeCheckRule = new saveBeforeCheckRule(); + processer.addBeforeRule(saveBeforeCheckRule); + } + + private void addBeforeRuleSagasCheck(AroundProcesser processer, boolean issub, boolean isPush) { + OrgDisabledCheckRule orgDisabledCheckRule = new OrgDisabledCheckRule("pk_org", "FACTORYTYPE000000000"); + processer.addBeforeRule(orgDisabledCheckRule); + + FillInsertDataRule fillInsertDataRule = new FillInsertDataRule(); + processer.addBeforeRule(fillInsertDataRule); + + MMBillTypeIsLockCheckRule mMBillTypeIsLockCheckRule = new MMBillTypeIsLockCheckRule("vtrantypecode"); + processer.addBeforeRule(mMBillTypeIsLockCheckRule); + + MMATOMaterialCheckRule mMATOMaterialCheckRule = new MMATOMaterialCheckRule(null, "cmaterialvid", "cffileid"); + + processer.addBeforeRule(mMATOMaterialCheckRule); + + IRule marperrule = new PMOCheckMaterialPermissionRule(); + processer.addBeforeRule(marperrule); + + MMCheckMaterialVirtualRule mMCheckMaterialVirtualRule = new MMCheckMaterialVirtualRule(); + processer.addBeforeRule(mMCheckMaterialVirtualRule); + + IRule chkrwxisrule = new PMOCheckNrwxisLogicRule(); + processer.addBeforeRule(chkrwxisrule); + + IRule chkrule = new PMOCheckSaveNotNullRule(issub); + processer.addBeforeRule(chkrule); + + IRule fillvaluerule = new PMOFillInsertDefaultValueRule(); + processer.addBeforeRule(fillvaluerule); + + processer.addBeforeRule(new PMOSyncPlanmmNumRule()); + + MMRowNoCheckRule mMRowNoCheckRule = new MMRowNoCheckRule(); + processer.addBeforeRule(mMRowNoCheckRule); + + IRule daterule = new PMOCheckDateLogicRule(); + processer.addBeforeRule(daterule); + + IRule chkPntRule = new PMOProcedureChkPntRule(); + processer.addBeforeRule(chkPntRule); + + processer.addBeforeRule(new PMOCheckProdurepointRule()); + + IRule procdatelogicrule = new PMOCheckProcedureDateLogicRule(true); + processer.addBeforeRule(procdatelogicrule); + + IRule proccoderule = new PMOCheckProcedureDupRule(); + processer.addBeforeRule(proccoderule); + + FieldLengthCheckRule fieldLengthCheckRule = new FieldLengthCheckRule(); + processer.addBeforeRule(fieldLengthCheckRule); + + UserDefSaveRule defRule = new UserDefSaveRule( + new Class[] { nc.vo.mmpac.pmo.pac0002.entity.PMOItemVO.class }); + processer.addBeforeRule(defRule); + + MMCheckMaterialProdModeRule prodModeRule = new MMCheckMaterialProdModeRule(1, + nc.vo.mmpac.pmo.pac0002.entity.PMOItemVO.class); + + processer.addBeforeRule(prodModeRule); + + IRule snCheckRule = new PMOCheckSNNumAndUnitRule(); + processer.addBeforeRule(snCheckRule); + + IRule atoCheck = new PMOATOCheckRule(); + processer.addBeforeRule(atoCheck); + } + + private void addAfterRule(AroundProcesser processer, boolean issub, boolean isPush, + List updateParams, List saveParams) { + MMBillCodeCheckAndTrantypeRule mMBillCodeCheckAndTrantypeRule = new MMBillCodeCheckAndTrantypeRule("55A2", + "vbillcode", "pk_group", "pk_org", "vtrantypecode"); + + processer.addAfterRule(mMBillCodeCheckAndTrantypeRule); + + IRule duprule = new PMOCheckSCDuplicateRule(); + processer.addAfterRule(duprule); + + IRule dmoduprule = new PMOCheckDMODuplicateRule(); + processer.addAfterRule(dmoduprule); + + IRule pmorule = new RewriteInsertNum4PMO(); + processer.addAfterRule(pmorule); + + IRule rewriteso = new RewriteInsertNum4SO(); + processer.addAfterRule(rewriteso); + + IRule rewritepsm = new RewriteInsertNum4PSM(); + processer.addAfterRule(rewritepsm); + + IRule rewritepo = new RewriteInsertNum4MPS(); + processer.addAfterRule(rewritepo); + + IRule rewriteto = new RewriteInsertNum4TO(); + processer.addAfterRule(rewriteto); + + IRule atprule = new PMOATPUpdateRule(false, "55A2"); + processer.addAfterRule(atprule); + + IRule snsaverule = new PMOSaveSNWhenInsertRule(updateParams, saveParams); + processer.addAfterRule(snsaverule); + + IRule createPickmRule = new PMOCreatePickmWhenInsertRule(); + processer.addAfterRule(createPickmRule); + + IRule saveapproverule = new PMOInsertSaveApproveRule(); + processer.addAfterRule(saveapproverule); + } + + public PMOAggVO[] pushInsert(PMOAggVO[] vos, boolean issub, String pushtype) { + AroundProcesser processer = new AroundProcesser(PMOPluginPoint.PUSHINSERT); + + addPushInsertBeforeRules(processer, pushtype); + processer.before(vos); + + PMOAggVO[] aggvos = insert(vos, issub, true); + if ("PSM".equals(pushtype)) { + PMOAggVO[] cloneVos = (PMOAggVO[]) (new GCBillCloneUtil()).cloneBills(aggvos); + + PMOSplitByTaskDetailsRule createPutPlan = new PMOSplitByTaskDetailsRule(false); + createPutPlan.process(cloneVos); + } + return aggvos; + } + + public void pushInsertSagasCheck(PMOAggVO[] vos, boolean issub, String pushtype) { + AroundProcesser processer = new AroundProcesser(PMOPluginPoint.PUSHINSERT); + + addPushInsertBeforeRules(processer, pushtype); + processer.before(vos); + + insertSagasCheck(vos, issub, true); + } + + private void addPushInsertBeforeRules(AroundProcesser processer, String pushtype) { + IRule versionrule = new PMOFillPushVersionRule(); + processer.addBeforeRule(versionrule); + + IRule defaultrule = new PMOFillPushDefaultValueRule(); + processer.addBeforeRule(defaultrule); + + IRule relationrule = new PMOFillMaterialRelationRule(pushtype); + processer.addBeforeRule(relationrule); + } +} diff --git a/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMOPutBP.java b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMOPutBP.java new file mode 100644 index 0000000..39b9819 --- /dev/null +++ b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMOPutBP.java @@ -0,0 +1,105 @@ +package nc.bs.mmpac.pmo.pac0002.bp; + +import nc.bs.mmpac.pmo.pac0002.pluginpoint.PMOPluginPoint; +import nc.bs.mmpac.pmo.pac0002.rule.PMOFilterBillStatusRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOPutAutoAuditPickmRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckDeptNotNullRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckPutCancelActApplyRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckPutCancelBatchBindRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckPutCancelDispatchNumRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckPutCancelHoldNumRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckPutCancelOperationRepRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckPutCancelWrNumRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOPutCancelCheckPutPlanStatusRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillBatchCodeRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillPutValueRule; +import nc.bs.mmpac.pmo.pac0002.bp.rule.putBeforeCheckRule; +import nc.bs.mmpub.rule.MMVOSagaFrozenValidateRule; +import nc.impl.pubapp.pattern.rule.IFilterRule; +import nc.impl.pubapp.pattern.rule.IRule; +import nc.impl.pubapp.pattern.rule.processer.CompareAroundProcesser; +import nc.util.mmf.framework.gc.GCUpdateBPTemplate; +import nc.vo.mmpac.pmo.pac0002.constant.PMOConstLang; +import nc.vo.mmpac.pmo.pac0002.entity.PMOAggVO; +import nc.vo.mmpac.pmo.pac0002.enumeration.PMOFBillstatusEnum; + +public class PMOPutBP { + public PMOAggVO[] put(PMOAggVO[] fullBills, PMOAggVO[] originBills) { + GCUpdateBPTemplate bp = new GCUpdateBPTemplate(PMOPluginPoint.PUT); + + addPutBeforeRule(bp.getAroundProcesser()); + + addPutAfterRule(bp.getAroundProcesser()); + + return (PMOAggVO[]) bp.update(fullBills, originBills); + } + + private void addPutBeforeRule(CompareAroundProcesser processer) { + MMVOSagaFrozenValidateRule mMVOSagaFrozenValidateRule = new MMVOSagaFrozenValidateRule(true); + processer.addBeforeRule(mMVOSagaFrozenValidateRule); + + IFilterRule filterStatusRule = new PMOFilterBillStatusRule(PMOConstLang.getMSG_ACTION_NO_AUDIT(), + PMOFBillstatusEnum.AUDIT); + processer.addBeforeRule(filterStatusRule); + + IRule checkDeptRule = new PMOCheckDeptNotNullRule(); + processer.addBeforeRule(checkDeptRule); + + IFilterRule pickmRule = new PMOPutAutoAuditPickmRule(); + processer.addBeforeRule(pickmRule); + + IRule fillValueRule = new PMOFillPutValueRule(false); + processer.addBeforeRule(fillValueRule); + + IRule batchcodeRule = new PMOFillBatchCodeRule(); + processer.addBeforeRule(batchcodeRule); + IRule putBeforeCheckRule = new putBeforeCheckRule(); + processer.addBeforeRule(putBeforeCheckRule); + } + + private void addPutAfterRule(CompareAroundProcesser processer) { + } + + public PMOAggVO[] putCancel(PMOAggVO[] fullBills, PMOAggVO[] originBills) { + GCUpdateBPTemplate bp = new GCUpdateBPTemplate(PMOPluginPoint.UNPUT); + + addPutCancelBeforeRule(bp.getAroundProcesser()); + + addPutCancelAfterRule(bp.getAroundProcesser()); + + return (PMOAggVO[]) bp.update(fullBills, originBills); + } + + private void addPutCancelBeforeRule(CompareAroundProcesser processer) { + IFilterRule filterStatusRule = new PMOFilterBillStatusRule(PMOConstLang.getMSG_ACTION_NO_AUDIT(), + PMOFBillstatusEnum.AUDIT); + processer.addBeforeRule(filterStatusRule); + + IRule checkWRNumRule = new PMOCheckPutCancelWrNumRule(); + processer.addBeforeRule(checkWRNumRule); + + IRule checkActApplyRule = new PMOCheckPutCancelActApplyRule(); + processer.addBeforeRule(checkActApplyRule); + + IRule checkHoldNumRule = new PMOCheckPutCancelHoldNumRule(); + processer.addBeforeRule(checkHoldNumRule); + + IRule checkBatchBindRule = new PMOCheckPutCancelBatchBindRule(); + processer.addBeforeRule(checkBatchBindRule); + + IRule fillValueRule = new PMOFillPutValueRule(true); + processer.addBeforeRule(fillValueRule); + + IRule checkDispatchNumRule = new PMOCheckPutCancelDispatchNumRule(); + processer.addBeforeRule(checkDispatchNumRule); + + IRule checkOperationRepRule = new PMOCheckPutCancelOperationRepRule(); + processer.addBeforeRule(checkOperationRepRule); + + IRule putCancelCheckPutPlanStatusRule = new PMOPutCancelCheckPutPlanStatusRule(); + processer.addBeforeRule(putCancelCheckPutPlanStatusRule); + } + + private void addPutCancelAfterRule(CompareAroundProcesser processer) { + } +} diff --git a/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMORowPutBP.java b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMORowPutBP.java new file mode 100644 index 0000000..b613ad0 --- /dev/null +++ b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/PMORowPutBP.java @@ -0,0 +1,122 @@ +package nc.bs.mmpac.pmo.pac0002.bp; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import nc.bs.mmpac.pmo.pac0002.bp.service.PMOBPService; +import nc.bs.mmpac.pmo.pac0002.bp.util.PMOBPUtil; +import nc.bs.mmpac.pmo.pac0002.pluginpoint.PMOPluginPoint; +import nc.bs.mmpac.pmo.pac0002.rule.PMOFilterBillStatusRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOFilterRowStatusRule; +import nc.bs.mmpac.pmo.pac0002.rule.PMOPutAutoAuditPickmRule; +import nc.bs.mmpac.pmo.pac0002.rule.check.PMOCheckDeptNotNullRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillBatchCodeRule; +import nc.bs.mmpac.pmo.pac0002.rule.fill.PMOFillPutValueRule; +import nc.bs.mmpac.pmo.pac0002.bp.rule.putBeforeCheckRule; +import nc.bs.mmpub.rule.MMVOSagaFrozenValidateRule; +import nc.impl.pubapp.pattern.data.vo.tool.VOConcurrentTool; +import nc.impl.pubapp.pattern.rule.processer.CompareAroundProcesser; +import nc.util.mmf.framework.gc.GCBillConcurrentTool; +import nc.util.mmf.framework.gc.GCBillTransferTool; +import nc.util.mmf.framework.gc.GCBillUpdate; +import nc.util.mmf.framework.gc.GCUpdateBPTemplate; +import nc.vo.mmpac.pmo.pac0002.constant.PMOConstLang; +import nc.vo.mmpac.pmo.pac0002.entity.PMOAggVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOItemVO; +import nc.vo.mmpac.pmo.pac0002.enumeration.PMOFBillstatusEnum; +import nc.vo.mmpac.pmo.pac0002.enumeration.PMOFItemStatusEnum; +import nc.vo.pub.CircularlyAccessibleValueObject; +import nc.vo.pubapp.pattern.exception.ExceptionUtils; + +public class PMORowPutBP { + public PMOAggVO[] rowput(PMOAggVO[] vos) { + try { + GCBillConcurrentTool lockTool = new GCBillConcurrentTool(); + lockTool.lockBill(vos); + + (new VOConcurrentTool()).checkTSWithDB(vos[0].getChildrenVO()); + + GCUpdateBPTemplate bp = new GCUpdateBPTemplate(PMOPluginPoint.ROWPUT); + CompareAroundProcesser processer = bp.getAroundProcesser(); + + addRowPutBeforeRule(processer); + + addRowPutAfterRule(processer); + + PMOAggVO[] returnvos = (PMOAggVO[]) processer.before(vos, vos); + + List upditemList = new ArrayList(); + Map upditemMap = new HashMap(); + for (PMOAggVO aggvo : returnvos) { + PMOItemVO[] items = aggvo.getChildrenVO(); + for (PMOItemVO item : items) { + upditemList.add(item); + upditemMap.put(item.getCmoid(), item); + } + } + PMOAggVO aggvo = PMOBPService.getIPMOQueryService().queryByPk(vos[0].getParentVO().getCpmohid()); + + PMOItemVO[] olditems = aggvo.getChildrenVO(); + List tempitems = new ArrayList(); + for (PMOItemVO item : olditems) { + if (!upditemMap.containsKey(item.getCmoid())) { + tempitems.add(item); + } else { + + ((PMOItemVO) upditemMap.get(item.getCmoid())).setStatus(1); + PMOBPUtil.setGrandVOStatusUpdate((PMOItemVO) upditemMap.get(item.getCmoid())); + tempitems.add((PMOItemVO) upditemMap.get(item.getCmoid())); + } + } + aggvo.setChildrenVO((CircularlyAccessibleValueObject[]) tempitems.toArray(new PMOItemVO[tempitems.size()])); + + PMOAggVO[] aggvos = { aggvo }; + + GCBillTransferTool transferTool = new GCBillTransferTool(aggvos); + PMOAggVO[] originBills = (PMOAggVO[]) transferTool.getOriginBills(); + GCBillUpdate billupdate = new GCBillUpdate(); + PMOAggVO[] newaggvos = (PMOAggVO[]) billupdate.update(aggvos, originBills); + + PMOItemVO[] totalitems = newaggvos[0].getChildrenVO(); + Map newitemMap = new HashMap(); + for (PMOItemVO item : totalitems) { + if (upditemMap.containsKey(item.getCmoid())) { + newitemMap.put(item.getCmoid(), item); + } + } + returnvos[0] + .setChildrenVO((CircularlyAccessibleValueObject[]) newitemMap.values().toArray(new PMOItemVO[0])); + + processer.after(returnvos, returnvos); + + PMOAggVO newaggvo = PMOBPService.getIPMOQueryService().queryByPk(vos[0].getParentVO().getCpmohid()); + + return new PMOAggVO[] { newaggvo }; + + } catch (Exception e) { + ExceptionUtils.wrappException(e); + + return null; + } + } + + private void addRowPutBeforeRule(CompareAroundProcesser processer) { + MMVOSagaFrozenValidateRule mMVOSagaFrozenValidateRule = new MMVOSagaFrozenValidateRule(true); + processer.addBeforeRule(mMVOSagaFrozenValidateRule); + processer.addBeforeRule( + new PMOFilterBillStatusRule(PMOConstLang.getMSG_ACTION_NO_AUDIT(), PMOFBillstatusEnum.AUDIT)); + + processer.addBeforeRule( + new PMOFilterRowStatusRule(PMOConstLang.getMSG_RULE_NO_ROWDATA(), PMOFItemStatusEnum.AUDIT)); + + processer.addBeforeRule(new PMOCheckDeptNotNullRule()); + processer.addBeforeRule(new PMOPutAutoAuditPickmRule()); + processer.addBeforeRule(new PMOFillPutValueRule(false)); + processer.addBeforeRule(new PMOFillBatchCodeRule()); + processer.addBeforeRule(new putBeforeCheckRule()); + } + + private void addRowPutAfterRule(CompareAroundProcesser processer) { + } +} diff --git a/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/rule/putBeforeCheckRule.java b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/rule/putBeforeCheckRule.java new file mode 100644 index 0000000..d1f1f11 --- /dev/null +++ b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/rule/putBeforeCheckRule.java @@ -0,0 +1,111 @@ +package nc.bs.mmpac.pmo.pac0002.bp.rule; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import nc.bs.framework.common.NCLocator; +import nc.impl.pubapp.pattern.rule.IRule; +import nc.itf.uap.IUAPQueryBS; +import nc.itf.uif.pub.IUifService; +import nc.jdbc.framework.processor.ColumnProcessor; +import nc.jdbc.framework.processor.MapProcessor; +import nc.vo.ic.m4c.entity.SaleOutHeadVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOAggVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOHeadVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOItemVO; +import nc.vo.pub.BusinessException; +import nc.vo.so.m30.entity.SaleOrderBVO; +//import nc.bs.rbac.bizlistener.BaseDocDataPermChangeEventListener; +//import nc.impl.mmpac.pmo.pac0002.PMOTransTypeQueryServiceImpl; +//import nc.impl.mmpac.bcrule.predata.BarCodeDataInitListener; +//import nc.ui.mmpub.setanalysis.action.SaAnalysisAction.actionPerformed;//流程生产订单齐套分析-分析 + +//import nc.impl.mmpub.setanalysis.SetAnalysisServiceImpl; +import nc.bs.mmpac.pmo.pac0002.bp.PMORowPutBP; +import nccloud.web.mmpac.pmo.action.PmoCardPutAction; + + +public class putBeforeCheckRule implements IRule { + + private static IUifService service = (IUifService) NCLocator.getInstance() + .lookup(IUifService.class.getName()); + + @Override + public void process(PMOAggVO[] vos) { + try { + // TODO Auto-generated method stub + List list = new ArrayList(); + for (PMOAggVO vo : vos) { + //判断是否是需要控制的业务单元 + PMOHeadVO pmoHeadVO = vo.getParentVO(); + String pkstockorgStr = getPk_stockorg(pmoHeadVO.getPk_org()); + if (pkstockorgStr == null || pkstockorgStr.equals("")) { + return; + } + PMOItemVO[] iSuperVOs = vo.getChildrenVO(); + for (int i = 0; i < iSuperVOs.length; i++) { + PMOItemVO itemvo = iSuperVOs[i]; + //判断是否类型是否为30 + if (itemvo.getVsrctype() == null || !itemvo.getVsrctype().equals("30")) { + return; + } + Map valMap = getVbdef6(itemvo.getVsrcbid()); + //销售发票表头pk_billtypecode=30-Cxx-12 + if (valMap.get("pk_billtypecode").equals("30-Cxx-12")||valMap.get("pk_billtypecode").equals("30-Cxx-02")||valMap.get("pk_billtypecode").equals("30-Cxx-08")||valMap.get("pk_billtypecode").equals("30-Cxx-13")) { + return; + } + //历史数据不考虑 + String storedDateStr = (String) valMap.get("creationtime"); + String targetDateStr = "2024-12-31 00:00:00"; + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + LocalDateTime storedDate = LocalDateTime.parse(storedDateStr, formatter); + LocalDateTime targetDate = LocalDateTime.parse(targetDateStr, formatter); + if (storedDate.isBefore(targetDate)) { + return; + } + String vdef4Str = itemvo.getVdef4();//齐套率 + String vdef4 = (vdef4Str != null) ? vdef4Str.toString() : ""; + double vdef4qty = (vdef4.isEmpty()) ? 0 : Double.parseDouble(vdef4);//齐套率 + String vdef10Str = itemvo.getVdef10();//齐套率标准 + String vdef10 = (vdef10Str != null) ? vdef10Str.toString() : ""; + double vdef10qty = (vdef10.isEmpty()) ? 0 : Double.parseDouble(vdef10);//齐套率标准 + if (vdef4qty < vdef10qty) { + throw new BusinessException( + "齐套率" + vdef4qty + "小于齐套率标准'" + vdef10qty + "'，无法保存！"); + } + + } + } + } catch (BusinessException e) { + throw new RuntimeException(e); + } + } + + private Map getVbdef6(String vsrcbidStr) throws BusinessException { + IUAPQueryBS queryBS = NCLocator.getInstance().lookup(IUAPQueryBS.class); + String sql = " SELECT bt.pk_billtypecode,s.creationtime,b.vbdef12,d.nastnum FROM so_saleorder_b b\n" + + "INNER JOIN so_saleorder s ON s.csaleorderid = b.csaleorderid\n" + + "left join (select mm_mo.Vsrcbid,sum(nastnum) as nastnum \n" + + "from mm_mo\n" + + "where mm_mo.dr=0\n" + + "group by mm_mo.Vsrcbid) d on b.csaleorderbid=d.Vsrcbid\n" + + "INNER JOIN bd_billtype bt on bt.pk_billtypeid=s.ctrantypeid\n" + + "where b.csaleorderbid='" + vsrcbidStr + "' "; + Map valList = (Map) queryBS.executeQuery(sql, new MapProcessor()); + return valList; + } + + private String getPk_stockorg(String pk_stockorg) throws BusinessException { + String sql = + " select pk_stockorg from org_stockorg where code in ('C018','C029','C033','C039','C020','C019') and pk_stockorg='" + + pk_stockorg + "' "; + String saleorderPK = (String) getQueryService().executeQuery(sql, new ColumnProcessor()); + return saleorderPK; + } + + public IUAPQueryBS getQueryService() { + return NCLocator.getInstance().lookup(IUAPQueryBS.class); + } +}