From 2e0e2af9c53705c8334821a0a7d05e271be8e6e2 Mon Sep 17 00:00:00 2001 From: lihao Date: Mon, 15 Sep 2025 18:03:57 +0800 Subject: [PATCH] =?UTF-8?q?=E5=AE=9E=E9=99=85=E7=8B=AC=E7=AB=8B=E9=9C=80?= =?UTF-8?q?=E6=B1=82=E9=94=80=E5=94=AE=E8=AE=A2=E5=8D=95=E6=8E=A8=E9=80=81?= =?UTF-8?q?=E7=94=9F=E4=BA=A7=E8=AE=A2=E5=8D=95=E6=BA=90=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../mmpac/pmo/pac0002/bp/util/PMOBPUtil.java | 911 ++++++++++++++++++ 1 file changed, 911 insertions(+) create mode 100644 mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/util/PMOBPUtil.java diff --git a/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/util/PMOBPUtil.java b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/util/PMOBPUtil.java new file mode 100644 index 0000000..bb68944 --- /dev/null +++ b/mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/util/PMOBPUtil.java @@ -0,0 +1,911 @@ +// +// Source code recreated from a .class file by IntelliJ IDEA +// (powered by FernFlower decompiler) +// + +package nc.bs.mmpac.pmo.pac0002.bp.util; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import nc.bs.dao.BaseDAO; +import nc.bs.dao.DAOException; +import nc.bs.framework.common.InvocationInfoProxy; +import nc.bs.framework.common.NCLocator; +import nc.bs.mmpac.pmo.pac0002.bp.query.PMOHeadVOQueryBP; +import nc.bs.mmpac.pmo.pac0002.bp.query.PMOItemVOQueryBP; +import nc.bs.mmpac.pmo.pac0002.bp.service.PMOBPService; +import nc.bs.pubapp.AppBsContext; +import nc.impl.pubapp.bd.userdef.UserDefSaveRule; +import nc.itf.uap.rbac.IUserManageQuery_C; +import nc.jdbc.framework.generator.SequenceGenerator; +import nc.jdbc.framework.processor.ColumnListProcessor; +import nc.mmbd.utils.factoryparam.OTDimensionSetUtil; +import nc.pubitf.initgroup.InitGroupQuery; +import nc.pubitf.sn.doc.param.ISnPkandCodeParam; +import nc.pubitf.sn.doc.param.SnDocParam; +import nc.pubitf.sn.doc.param.SnResult; +import nc.pubitf.uapbd.IMaterialPubService_C; +import nc.util.mmf.busi.measure.MeasureHelper; +import nc.util.mmf.busi.service.MaterialPubService; +import nc.util.mmf.busi.service.OrgUnitPubService; +import nc.util.mmf.framework.base.MMArrayUtil; +import nc.util.mmf.framework.base.MMCollectionUtil; +import nc.util.mmf.framework.base.MMMapUtil; +import nc.util.mmf.framework.base.MMNumberUtil; +import nc.util.mmf.framework.base.MMValueCheck; +import nc.util.mmf.framework.db.MMSqlBuilder; +import nc.vo.bd.material.prod.MaterialProdVO; +import nc.vo.bd.material.stock.MaterialStockVO; +import nc.vo.bd.vermatch.enumeration.MfgTypeEnum; +import nc.vo.bd.vermatch.param.ppac.PpacMaterialParamVO; +import nc.vo.mmbd.pub.TraceDimensionParaVO; +import nc.vo.mmpac.pickm.param.MOSubItemParam; +import nc.vo.mmpac.pickm.param.MoChangeParam; +import nc.vo.mmpac.pmo.pac0002.entity.PMOAggVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOHeadVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOItemMeasureParam; +import nc.vo.mmpac.pmo.pac0002.entity.PMOItemVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOMaterialRelationVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOMaterialViewVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOPlanOutputVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOProcedureVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOSerialNoVO; +import nc.vo.mmpac.pmo.pac0002.entity.PMOTaskDetailVO; +import nc.vo.mmpac.pmo.pac0002.enumeration.PMOFBillstatusEnum; +import nc.vo.mmpac.pmo.pac0002.util.PMOFillTransTypeUtil; +import nc.vo.mmpac.pmo.parameter.PMOMaterlKey; +import nc.vo.mmpac.pmo.parameter.PMORewriteParaVO; +import nc.vo.pub.BusinessException; +import nc.vo.pub.CircularlyAccessibleValueObject; +import nc.vo.pub.SuperVO; +import nc.vo.pub.lang.UFBoolean; +import nc.vo.pub.lang.UFDateTime; +import nc.vo.pub.lang.UFDouble; +import nc.vo.pubapp.AppContext; +import nc.vo.pubapp.pattern.exception.ExceptionUtils; +import nc.vo.pubapp.pattern.pub.MapList; + +public class PMOBPUtil { + public PMOBPUtil() { + } + + public static Map queryMaterProcManaged(PMOAggVO[] vos) { + Map> marvids = new HashMap(); + + for(PMOAggVO vo : vos) { + PMOHeadVO headvo = vo.getParentVO(); + Set set = (Set)marvids.get(headvo.getPk_org()); + if (MMValueCheck.isEmpty(set)) { + set = new HashSet(); + marvids.put(headvo.getPk_org(), set); + } + + for(PMOItemVO item : vo.getChildrenVO()) { + set.add(item.getCmaterialvid()); + } + } + + Map rets = new HashMap(); + + for(Map.Entry> entry : marvids.entrySet()) { + Map prodMap = MaterialPubService.queryMaterialProduceInfoByPks((String[])((Set)entry.getValue()).toArray(new String[0]), (String)entry.getKey(), new String[]{"workprocemanage", "pk_org"}); + + for(Map.Entry ret : prodMap.entrySet()) { + String cmatervid = (String)ret.getKey(); + MaterialProdVO prodVO = (MaterialProdVO)ret.getValue(); + UFBoolean isProcManage = UFBoolean.FALSE; + if (MMValueCheck.isTrue(prodVO.getWorkprocemanage())) { + isProcManage = UFBoolean.TRUE; + } + + rets.put(prodVO.getPk_org() + cmatervid, isProcManage); + } + } + + return rets; + } + + public static boolean isProcedureHasSCPlan(PMOAggVO vo) { + if (MMValueCheck.isEmpty(vo)) { + return false; + } else { + for(PMOItemVO itemvo : vo.getChildrenVO()) { + if (MMValueCheck.isEmpty(itemvo.getProcedures())) { + return false; + } + + for(PMOProcedureVO procvo : itemvo.getProcedures()) { + if (MMNumberUtil.isGtZero(procvo.getNscnum())) { + return true; + } + } + } + + return false; + } + } + + public static boolean isProcedureHasSCPlan(PMOItemVO itemvo) { + if (MMValueCheck.isEmpty(itemvo)) { + return false; + } else if (MMValueCheck.isEmpty(itemvo.getProcedures())) { + return false; + } else { + for(PMOProcedureVO procvo : itemvo.getProcedures()) { + if (MMNumberUtil.isGtZero(procvo.getNscnum())) { + return true; + } + } + + return false; + } + } + + public static PMOAggVO[] getApprovedVOs(PMOAggVO[] vos) { + if (MMValueCheck.isEmpty(vos)) { + return null; + } else { + List aggvos = new ArrayList(); + + for(PMOAggVO vo : vos) { + if (PMOFBillstatusEnum.AUDIT.toIntValue() == vo.getParentVO().getFbillstatus()) { + aggvos.add(vo); + } + } + + if (MMValueCheck.isEmpty(aggvos)) { + return null; + } else { + return (PMOAggVO[])aggvos.toArray(new PMOAggVO[aggvos.size()]); + } + } + } + + public static PMOAggVO[] refreshTS(PMOAggVO[] aggvos) { + if (MMArrayUtil.isEmpty(aggvos)) { + return aggvos; + } else { + List hidList = new ArrayList(); + List bidList = new ArrayList(); + + for(PMOAggVO aggvo : aggvos) { + PMOHeadVO head = aggvo.getParentVO(); + hidList.add(head.getCpmohid()); + PMOItemVO[] items = aggvo.getChildrenVO(); + if (!MMArrayUtil.isEmpty(items)) { + for(PMOItemVO item : items) { + bidList.add(item.getCmoid()); + } + } + } + + PMOHeadVO[] heads = PMOHeadVOQueryBP.getPMOHeadByids((String[])hidList.toArray(new String[hidList.size()])); + PMOItemVO[] items = PMOItemVOQueryBP.getPMOItemVOsByids((String[])bidList.toArray(new String[bidList.size()])); + MapList itemMapList = new MapList(); + + for(PMOItemVO item : items) { + itemMapList.put(item.getCpmohid(), item); + } + + List aggvoList = new ArrayList(); + + for(PMOHeadVO head : heads) { + List itemList = itemMapList.get(head.getCpmohid()); + if (itemList.size() > 0) { + PMOAggVO newaggvo = new PMOAggVO(); + newaggvo.setParentVO(head); + newaggvo.setChildrenVO((CircularlyAccessibleValueObject[])itemList.toArray(new PMOItemVO[itemList.size()])); + aggvoList.add(newaggvo); + } + } + + return (PMOAggVO[])aggvoList.toArray(new PMOAggVO[aggvoList.size()]); + } + } + + public static PMOAggVO[] refreshOnlyTS(PMOAggVO[] aggvos) { + if (MMArrayUtil.isEmpty(aggvos)) { + return aggvos; + } else { + List hidList = new ArrayList(); + List bidList = new ArrayList(); + + for(PMOAggVO aggvo : aggvos) { + PMOHeadVO head = aggvo.getParentVO(); + hidList.add(head.getCpmohid()); + PMOItemVO[] items = aggvo.getChildrenVO(); + if (!MMArrayUtil.isEmpty(items)) { + for(PMOItemVO item : items) { + bidList.add(item.getCmoid()); + } + } + } + + Map headMap = PMOHeadVOQueryBP.getPMOHeadMap((String[])hidList.toArray(new String[hidList.size()])); + Map itemMap = PMOItemVOQueryBP.getPMOItemVOMap((String[])bidList.toArray(new String[bidList.size()])); + + for(PMOAggVO aggvo : aggvos) { + PMOHeadVO head = aggvo.getParentVO(); + head.setTs(((PMOHeadVO)headMap.get(head.getCpmohid())).getTs()); + PMOItemVO[] items = aggvo.getChildrenVO(); + if (!MMArrayUtil.isEmpty(items)) { + for(PMOItemVO item : items) { + item.setTs(((PMOItemVO)itemMap.get(item.getCmoid())).getTs()); + } + } + } + + return aggvos; + } + } + + public static PMORewriteParaVO[] transferParam(PMORewriteParaVO[] paras) { + if (MMArrayUtil.isEmpty(paras)) { + return null; + } else { + List hidList = new ArrayList(); + List bidList = new ArrayList(); + + for(PMORewriteParaVO para : paras) { + if (!hidList.contains(para.getCpmohid())) { + hidList.add(para.getCpmohid()); + } + + if (!bidList.contains(para.getCpmobid())) { + bidList.add(para.getCpmobid()); + } + } + + if (hidList.size() > 0) { + try { + PMOAggVO[] aggvos = PMOBPService.getIPMOQueryService().queryByPks((String[])hidList.toArray(new String[hidList.size()])); + Map planoutMap = new HashMap(); + if (!MMArrayUtil.isEmpty(aggvos)) { + for(PMOAggVO aggvo : aggvos) { + PMOItemVO[] items = aggvo.getChildrenVO(); + if (!MMArrayUtil.isEmpty(items)) { + for(PMOItemVO item : items) { + PMOPlanOutputVO[] planoutvos = item.getPlanoutputs(); + if (!MMArrayUtil.isEmpty(planoutvos)) { + for(PMOPlanOutputVO planoutvo : planoutvos) { + planoutMap.put(planoutvo.getCplanoutputid(), planoutvo); + } + } + } + } + } + } + + new HashMap(); + Map var23 = PMOItemVOQueryBP.getPMOItemVOMap((String[])bidList.toArray(new String[bidList.size()])); + List newparaList = new ArrayList(); + + for(PMORewriteParaVO para : paras) { + String hid = para.getCpmohid(); + String bid = para.getCpmobid(); + UFDouble delNum = para.getDelNum(); + if (var23.containsKey(bid)) { + newparaList.add(para); + } + + if (planoutMap.containsKey(bid)) { + PMOPlanOutputVO planoutvo = (PMOPlanOutputVO)planoutMap.get(bid); + PMORewriteParaVO newpara = new PMORewriteParaVO(); + newpara.setCpmohid(hid); + newpara.setCpmobid(planoutvo.getCmoid()); + newpara.setDelNum(UFDouble.ZERO_DBL); + Map outMap = new HashMap(); + outMap.put(bid, delNum); + newpara.setPoutMap(outMap); + newparaList.add(newpara); + } + } + + return (PMORewriteParaVO[])newparaList.toArray(new PMORewriteParaVO[newparaList.size()]); + } catch (BusinessException e) { + ExceptionUtils.wrappException(e); + } + } + + return null; + } + } + + public static PpacMaterialParamVO getMaterialParamVO(PMOItemVO item) { + PpacMaterialParamVO materialParam = new PpacMaterialParamVO(); + String cmaterialvid = (String)item.getAttributeValue("cmaterialvid"); + String cmaterialoid = (String)item.getAttributeValue("cmaterialid"); + String ccustomerid = (String)item.getAttributeValue("ccustomerid"); + String cvendorid = (String)item.getAttributeValue("cvendorid"); + String cproductorid = (String)item.getAttributeValue("cproductorid"); + String cprojectid = (String)item.getAttributeValue("cprojectid"); + String ccustmarid = (String)item.getAttributeValue("ccustmaterialid"); + String vfree1 = (String)item.getAttributeValue("vfree1"); + String vfree2 = (String)item.getAttributeValue("vfree2"); + String vfree3 = (String)item.getAttributeValue("vfree3"); + String vfree4 = (String)item.getAttributeValue("vfree4"); + String vfree5 = (String)item.getAttributeValue("vfree5"); + String vfree6 = (String)item.getAttributeValue("vfree6"); + String vfree7 = (String)item.getAttributeValue("vfree7"); + String vfree8 = (String)item.getAttributeValue("vfree8"); + String vfree9 = (String)item.getAttributeValue("vfree9"); + String vfree10 = (String)item.getAttributeValue("vfree10"); + materialParam.setPk_group(item.getPk_group()); + materialParam.setPk_org(item.getPk_org()); + materialParam.setPk_org_v(item.getPk_org_v()); + materialParam.setCmaterialvid(cmaterialvid); + materialParam.setCmaterialoid(cmaterialoid); + materialParam.setCcustomerid(ccustomerid); + materialParam.setCvendorid(cvendorid); + materialParam.setCproductorid(cproductorid); + materialParam.setCprojectid(cprojectid); + materialParam.setCcustmaterialid(ccustmarid); + materialParam.setCffileid(item.getCffileid()); + materialParam.setVfree1(vfree1); + materialParam.setVfree2(vfree2); + materialParam.setVfree3(vfree3); + materialParam.setVfree4(vfree4); + materialParam.setVfree5(vfree5); + materialParam.setVfree6(vfree6); + materialParam.setVfree7(vfree7); + materialParam.setVfree8(vfree8); + materialParam.setVfree9(vfree9); + materialParam.setVfree10(vfree10); + materialParam.setMfgtype(MfgTypeEnum.PRODUCTION.toIntValue()); + SequenceGenerator gen = new SequenceGenerator(); + materialParam.setKey(gen.generate()); + UFDateTime tplanstarttime = item.getTplanstarttime(); + if (MMValueCheck.isNotEmpty(tplanstarttime)) { + materialParam.setDmatchdate(tplanstarttime.getDate()); + } else { + materialParam.setDmatchdate(AppBsContext.getInstance().getBusiDate()); + } + + List resultList = OTDimensionSetUtil.queryDimensionVOs(item.getPk_org()); + if (MMValueCheck.isNotEmpty(resultList)) { + for(TraceDimensionParaVO tdParaVO : resultList) { + if (tdParaVO.getSocode().booleanValue() && !tdParaVO.getSolinecode().booleanValue()) { + Object soRowCode = item.getAttributeValue(tdParaVO.getFieldCode()); + materialParam.setVbillcode((String)soRowCode); + } + + if (!tdParaVO.getSocode().booleanValue() && tdParaVO.getSolinecode().booleanValue()) { + Object soRowNo = item.getAttributeValue(tdParaVO.getFieldCode()); + materialParam.setVbillrowno((String)soRowNo); + } + } + } + + return materialParam; + } + + public static StringBuilder setFirstParamVal(StringBuilder sql, String val) { + int idx = sql.indexOf("?"); + if (idx == -1) { + return sql; + } else { + sql.replace(idx, idx + 1, val); + return sql; + } + } + + public static void setGrandVOStatusUpdate(PMOItemVO item) { + PMOPlanOutputVO[] plans = item.getPlanoutputs(); + if (!MMArrayUtil.isEmpty(plans)) { + for(PMOPlanOutputVO plan : plans) { + plan.setStatus(1); + } + } + + PMOTaskDetailVO[] tasks = item.getTaskdetails(); + if (!MMArrayUtil.isEmpty(tasks)) { + for(PMOTaskDetailVO task : tasks) { + task.setStatus(1); + } + } + + PMOProcedureVO[] procs = item.getProcedures(); + if (!MMArrayUtil.isEmpty(procs)) { + for(PMOProcedureVO proc : procs) { + proc.setStatus(1); + } + } + + } + + public static MoChangeParam constructParam(PMOItemVO newItemVO, PMOItemVO originItemVO, String vBillCOde) { + MoChangeParam param = new MoChangeParam(); + param.setParams(createMOSubItemParam(newItemVO, originItemVO)); + param.setProdmode(1); + param.setNoldplanputnum(originItemVO.getNplanputnum()); + param.setNoldplanputastnum(originItemVO.getNplanputastnum()); + param.setToldplanstarttime(originItemVO.getTplanstarttime()); + param.setNoldnmmnum(originItemVO.getNmmnum()); + param.setNoldnmmastnum(originItemVO.getNmmastnum()); + param.setColdbomversionid(originItemVO.getCbomversionid()); + param.setColdpackbomvid(originItemVO.getCpackbomid()); + param.setColdrtversionid(originItemVO.getCrtversionid()); + param.setCffileid(originItemVO.getCffileid()); + param.setNnewplanputnum(newItemVO.getNplanputnum()); + param.setNnewplanputastnum(newItemVO.getNplanputastnum()); + param.setNnewnmmnum(newItemVO.getNmmnum()); + param.setNnewnmmastnum(newItemVO.getNmmastnum()); + param.setTnewplanstarttime(newItemVO.getTplanstarttime()); + param.setCnewbomversionid(newItemVO.getCbomversionid()); + param.setCnewpackbomvid(newItemVO.getCpackbomid()); + param.setCnewrtversionid(newItemVO.getCrtversionid()); + param.setCffileid(newItemVO.getCffileid()); + param.setMoid(originItemVO.getCmoid()); + param.setCastunitid(newItemVO.getCastunitid()); + param.setVchangerate(newItemVO.getVchangerate()); + param.setCdeptid(newItemVO.getCdeptid()); + param.setCdeptvid(newItemVO.getCdeptvid()); + param.setCcustomerid(newItemVO.getCcustomerid()); + param.setCcustomervid(newItemVO.getCcustomervid()); + param.setCproductorid(newItemVO.getCproductorid()); + param.setCprojectid(newItemVO.getCprojectid()); + param.setCvendorid(newItemVO.getCvendorid()); + param.setCvendorvid(newItemVO.getCvendorvid()); + param.setVdef1(newItemVO.getVdef1()); + param.setVdef2(newItemVO.getVdef2()); + param.setVdef3(newItemVO.getVdef3()); + param.setVdef4(newItemVO.getVdef4()); + param.setVdef5(newItemVO.getVdef5()); + param.setVdef6(newItemVO.getVdef6()); + param.setVdef7(newItemVO.getVdef7()); + param.setVdef8(newItemVO.getVdef8()); + param.setVdef9(newItemVO.getVdef9()); + param.setVdef10(newItemVO.getVdef10()); + param.setVdef11(newItemVO.getVdef11()); + param.setVdef12(newItemVO.getVdef12()); + param.setVdef13(newItemVO.getVdef13()); + param.setVdef14(newItemVO.getVdef14()); + param.setVdef15(newItemVO.getVdef15()); + param.setVdef16(newItemVO.getVdef16()); + param.setVdef17(newItemVO.getVdef17()); + param.setVdef18(newItemVO.getVdef18()); + param.setVdef19(newItemVO.getVdef19()); + param.setVdef20(newItemVO.getVdef20()); + param.setVfree1(newItemVO.getVfree1()); + param.setVfree2(newItemVO.getVfree2()); + param.setVfree3(newItemVO.getVfree3()); + param.setVfree4(newItemVO.getVfree4()); + param.setVfree5(newItemVO.getVfree5()); + param.setVfree6(newItemVO.getVfree6()); + param.setVfree7(newItemVO.getVfree7()); + param.setVfree8(newItemVO.getVfree8()); + param.setVfree9(newItemVO.getVfree9()); + param.setVfree10(newItemVO.getVfree10()); + param.setMovbillcode(vBillCOde); + return param; + } + + private static MOSubItemParam[] createMOSubItemParam(PMOItemVO newItemVO, PMOItemVO originItemVO) { + PMOProcedureVO[] procedureVOs = newItemVO.getProcedures(); + if (MMArrayUtil.isEmpty(procedureVOs)) { + return null; + } else { + PMOProcedureVO[] originProcedureVOs = originItemVO.getProcedures(); + if (MMArrayUtil.isEmpty(originProcedureVOs)) { + return null; + } else { + Map originProcedureMap = new HashMap(); + + for(PMOProcedureVO pmoProcedureVO : originProcedureVOs) { + originProcedureMap.put(pmoProcedureVO.getCprocedureid(), pmoProcedureVO); + } + + List list = new ArrayList(); + + for(PMOProcedureVO pmoProcedureVO : procedureVOs) { + PMOProcedureVO originProcedure = (PMOProcedureVO)originProcedureMap.get(pmoProcedureVO.getCprocedureid()); + MOSubItemParam param = new MOSubItemParam(); + param.setMoprocessid(pmoProcedureVO.getCprocedureid()); + param.setNnewplanastnum(pmoProcedureVO.getNplanmmastnum()); + param.setNnewplannum(pmoProcedureVO.getNplanmmnum()); + param.setNewprocessno(pmoProcedureVO.getVrccode()); + param.setNewprocesstypeid(pmoProcedureVO.getCrctypeid()); + param.setTnewstarttime(pmoProcedureVO.getTstarttime()); + param.setProcedureratio(pmoProcedureVO.getProcedureratio()); + if (originProcedure != null) { + param.setNoldplanastnum(originProcedure.getNplanmmastnum()); + param.setNoldplannum(originProcedure.getNplanmmnum()); + param.setOldprocessno(originProcedure.getVrccode()); + param.setOldprocesstypeid(originProcedure.getCrctypeid()); + param.setToldstarttime(originProcedure.getTstarttime()); + } + + list.add(param); + } + + if (list.isEmpty()) { + return null; + } else { + return (MOSubItemParam[])list.toArray(new MOSubItemParam[list.size()]); + } + } + } + } + + public static boolean checkModelEnable(String moduleCode, String warningMsg) { + boolean isEnabled = false; + + try { + isEnabled = InitGroupQuery.isEnabled(InvocationInfoProxy.getInstance().getGroupId(), moduleCode); + if (!isEnabled) { + ExceptionUtils.wrappBusinessException(warningMsg); + } + } catch (BusinessException e) { + ExceptionUtils.wrappException(e); + } + + return isEnabled; + } + + public static void procedureSortByRcno(PMOProcedureVO[] procedureVOs) { + Comparator comparator = new Comparator() { + public int compare(PMOProcedureVO src, PMOProcedureVO dest) { + return (new Double(src.getVrccode())).compareTo(new Double(dest.getVrccode())); + } + }; + Arrays.sort(procedureVOs, comparator); + } + + public static Set getDeleteItemIDs(PMOAggVO[] vos, PMOAggVO[] originVOs) { + Map newItemMap = new HashMap(); + Set deleteItemSet = new HashSet(); + + for(PMOAggVO newpmoAggVO : vos) { + PMOItemVO[] itemVOs = newpmoAggVO.getChildrenVO(); + + for(PMOItemVO itemVO : itemVOs) { + newItemMap.put(itemVO.getCmoid(), itemVO); + } + } + + for(PMOAggVO oldpmoAggVO : originVOs) { + PMOItemVO[] itemVOs = oldpmoAggVO.getChildrenVO(); + + for(PMOItemVO itemVO : itemVOs) { + if (!newItemMap.containsKey(itemVO.getCmoid())) { + deleteItemSet.add(itemVO.getCmoid()); + } + } + } + + return deleteItemSet; + } + + public static SnDocParam getSnDocParam(PMOHeadVO headvo, PMOItemVO itemvo, PMOSerialNoVO snvo, Map snUnitMap) { + SnDocParam docParam = new SnDocParam(); + docParam.setPk_group(itemvo.getPk_group()); + docParam.setPk_org(itemvo.getPk_org()); + docParam.setPk_org_v(itemvo.getPk_org_v()); + docParam.setCmaterialoid(itemvo.getCmaterialid()); + docParam.setCmaterialvid(itemvo.getCmaterialvid()); + docParam.setVprodbatchcode(itemvo.getVbatchcode()); + docParam.setCproducteddept(itemvo.getCdeptid()); + docParam.setCproducteddept_v(itemvo.getCdeptvid()); + docParam.setCasscustid(itemvo.getCcustomerid()); + docParam.setCffileid(itemvo.getCffileid()); + docParam.setCprojectid(itemvo.getCprojectid()); + docParam.setCvendorid(itemvo.getCvendorid()); + docParam.setCproductorid(itemvo.getCproductorid()); + docParam.setVfree1(itemvo.getVfree1()); + docParam.setVfree2(itemvo.getVfree2()); + docParam.setVfree3(itemvo.getVfree3()); + docParam.setVfree4(itemvo.getVfree4()); + docParam.setVfree5(itemvo.getVfree5()); + docParam.setVfree6(itemvo.getVfree6()); + docParam.setVfree7(itemvo.getVfree7()); + docParam.setVfree8(itemvo.getVfree8()); + docParam.setVfree9(itemvo.getVfree9()); + docParam.setVfree10(itemvo.getVfree10()); + docParam.setDbilldate(headvo.getDbilldate()); + docParam.setCshiftid(itemvo.getCclassid()); + docParam.setCteamid(itemvo.getCteamid()); + docParam.setCworkcerterid(itemvo.getCwkid()); + docParam.setDproductdate(itemvo.getTplanstarttime().getDate()); + docParam.setVtrantypecode(headvo.getVtrantypecode()); + docParam.setCbilltype("55A2"); + docParam.setCtranstype(headvo.getCtrantypeid()); + docParam.setChid(itemvo.getCpmohid()); + docParam.setVbillcode(headvo.getVbillcode()); + docParam.setCrowno(itemvo.getVrowno()); + docParam.setCreator(headvo.getCreator()); + docParam.setCreationtime(headvo.getCreationtime().getDate()); + docParam.setCbid(itemvo.getCmoid()); + docParam.setVcode(snvo.getVsncode()); + docParam.setPk_serialno(snvo.getCserialnoid()); + if (MMValueCheck.isNotEmpty(snUnitMap)) { + String snUnit = (String)snUnitMap.get(new PMOMaterlKey(itemvo.getPk_org(), itemvo.getCmaterialvid())); + docParam.setCsnunitid(snUnit); + } + + docParam.setCunitid(snvo.getCsnunitid()); + docParam.setNnum(snvo.getNsnnum()); + docParam.setVdef1(snvo.getVsndef1()); + docParam.setVdef2(snvo.getVsndef2()); + docParam.setVdef3(snvo.getVsndef3()); + docParam.setVdef4(snvo.getVsndef4()); + docParam.setVdef5(snvo.getVsndef5()); + docParam.setVdef6(snvo.getVsndef6()); + docParam.setVdef7(snvo.getVsndef7()); + docParam.setVdef8(snvo.getVsndef8()); + docParam.setVdef9(snvo.getVsndef9()); + docParam.setVdef10(snvo.getVsndef10()); + docParam.setVdef11(snvo.getVsndef11()); + docParam.setVdef12(snvo.getVsndef10()); + docParam.setVdef13(snvo.getVsndef13()); + docParam.setVdef14(snvo.getVsndef14()); + docParam.setVdef15(snvo.getVsndef15()); + docParam.setVdef16(snvo.getVsndef13()); + docParam.setVdef17(snvo.getVsndef17()); + docParam.setVdef18(snvo.getVsndef18()); + docParam.setVdef19(snvo.getVsndef19()); + docParam.setVdef20(snvo.getVsndef20()); + docParam.setVdef21(snvo.getVsndef21()); + docParam.setVdef22(snvo.getVsndef22()); + docParam.setVdef23(snvo.getVsndef23()); + docParam.setVdef24(snvo.getVsndef24()); + docParam.setVdef25(snvo.getVsndef25()); + docParam.setVdef26(snvo.getVsndef26()); + docParam.setVdef27(snvo.getVsndef27()); + docParam.setVdef28(snvo.getVsndef28()); + docParam.setVdef29(snvo.getVsndef29()); + docParam.setVdef30(snvo.getVsndef30()); + docParam.setVdef31(snvo.getVsndef31()); + docParam.setVdef32(snvo.getVsndef32()); + docParam.setVdef33(snvo.getVsndef33()); + docParam.setVdef34(snvo.getVsndef34()); + docParam.setVdef35(snvo.getVsndef35()); + docParam.setVdef36(snvo.getVsndef36()); + docParam.setVdef37(snvo.getVsndef37()); + docParam.setVdef38(snvo.getVsndef38()); + docParam.setVdef39(snvo.getVsndef39()); + docParam.setVdef40(snvo.getVsndef40()); + docParam.setVnote(snvo.getVsnnote()); + docParam.setTs(snvo.getVsrcts()); + return docParam; + } + + public static List getSaveSnDocParams(PMOAggVO[] vos, SnResult rets, Map snUint) { + List saveDocParams = new ArrayList(); + if (MMValueCheck.isEmpty(vos)) { + return saveDocParams; + } else { + for(PMOAggVO vo : vos) { + if (!MMValueCheck.isEmpty(vo.getChildrenVO())) { + for(PMOItemVO itemvo : vo.getChildrenVO()) { + if (!MMValueCheck.isEmpty(itemvo.getSerialnos())) { + for(PMOSerialNoVO snvo : itemvo.getSerialnos()) { + String var10000 = itemvo.getCmoid(); + String key = var10000 + snvo.getVsncode(); + ISnPkandCodeParam[] ret = rets.getSnbyKey(key); + if (!MMValueCheck.isEmpty(ret)) { + snvo.setCserialnoid(ret[0].getPk_sndoc()); + new SnDocParam(); + SnDocParam docParam = getSnDocParam(vo.getParentVO(), itemvo, snvo, snUint); + saveDocParams.add(docParam); + } + } + } + } + } + } + + return saveDocParams; + } + } + + public PMOAggVO[] fillVOInfo4AID(PMOAggVO[] aggvos) throws BusinessException { + (new PMOFillTransTypeUtil()).fillTransTypeValues(aggvos); + String pk_user = AppContext.getInstance().getPkUser(); + String cemployeeid = null; + if (!MMValueCheck.isEmpty(pk_user)) { + try { + cemployeeid = ((IUserManageQuery_C)NCLocator.getInstance().lookup(IUserManageQuery_C.class)).queryPsndocByUserid(pk_user); + } catch (BusinessException ex) { + ExceptionUtils.wrappException(ex); + } + } + + try { + UserDefSaveRule userDefSaveRule = new UserDefSaveRule(new Class[]{PMOItemVO.class, PMOPlanOutputVO.class}); + userDefSaveRule.process(aggvos); + List itemList = new ArrayList(); + MapList orgMapList = new MapList(); + + for(PMOAggVO aggvo : aggvos) { + String pk_org = aggvo.getParentVO().getPk_org(); + orgMapList.put(pk_org, aggvo); + PMOItemVO[] items = aggvo.getChildrenVO(); + Map waterRateMap = PMOBPCalUtil.getWasterrate(aggvo); + if (!MMArrayUtil.isEmpty(items)) { + for(PMOItemVO item : items) { + if (MMValueCheck.isEmpty(item.getCemployeeid()) && MMValueCheck.isNotEmpty(cemployeeid)) { + item.setCemployeeid(cemployeeid); + } + + item.setNmmnum(item.getNnum()); + UFDouble wastrate = (UFDouble)waterRateMap.get(item.getCmaterialvid()); + UFDouble nNum = item.getNmmnum().div((new UFDouble(1)).sub(wastrate)); + item.setNplanputnum(nNum); + item.setNrwxis(wastrate); + itemList.add(item); + } + } + } + + MeasureHelper.fillMeasAndVchangerate((SuperVO[])itemList.toArray(new PMOItemVO[0]), "cmaterialvid", "vchangerate", "cunitid", "castunitid"); + PMOItemMeasureParam param = new PMOItemMeasureParam(); + MeasureHelper.fillAssNumber((SuperVO[])itemList.toArray(new PMOItemVO[itemList.size()]), param, "nmmnum", "nmmastnum"); + MeasureHelper.fillAssNumber((SuperVO[])itemList.toArray(new PMOItemVO[itemList.size()]), param, "nplanputnum", "nplanputastnum"); + MeasureHelper.fillAssNumber((SuperVO[])itemList.toArray(new PMOItemVO[itemList.size()]), param, "nnum", "nastnum"); + Set orgids = orgMapList.keySet(); + Map orgoid2Vid = new HashMap(); + if (orgids.size() > 0) { + orgoid2Vid = OrgUnitPubService.getNewVIDSByOrgIDS((String[])orgids.toArray(new String[orgids.size()])); + } + + if (MMMapUtil.isNotEmpty(orgoid2Vid)) { + for(PMOAggVO aggvo : aggvos) { + PMOHeadVO head = aggvo.getParentVO(); + String pk_org = head.getPk_org(); + String pk_org_v = head.getPk_org_v(); + String pk_group = head.getPk_group(); + if (orgoid2Vid.containsKey(pk_org)) { + head.setPk_org_v((String)orgoid2Vid.get(pk_org)); + pk_org_v = (String)orgoid2Vid.get(pk_org); + } + + if (MMValueCheck.isEmpty(head.getCplanfactoryid())) { + head.setCplanfactoryid(pk_org); + head.setCplanfactoryvid(pk_org_v); + } + + PMOItemVO[] items = aggvo.getChildrenVO(); + if (!MMArrayUtil.isEmpty(items)) { + for(PMOItemVO item : items) { + item.setPk_group(pk_group); + item.setPk_org(pk_org); + item.setPk_org_v(pk_org_v); + } + } + } + } + + for(String orgid : orgids) { + List moList = orgMapList.get(orgid); + MapList marMapList = new MapList(); + + for(PMOAggVO aggvo : moList) { + PMOItemVO[] items = aggvo.getChildrenVO(); + SequenceGenerator sgkey = new SequenceGenerator(); + String[] cmoids = sgkey.generate(items.length); + + for(int i = 0; i < items.length; ++i) { + if (null == items[i].getCmoid()) { + items[i].setCmoid(cmoids[i]); + } + + marMapList.put(items[i].getCmaterialvid(), items[i]); + } + } + + Set marSet = marMapList.keySet(); + String[] marPlanFields = new String[]{"prevahead", "endahead", "fixedahead", "aheadbatch", "aheadcoff", "planprop"}; + String[] marProdFields = new String[]{"pk_prodeptdoc", "pk_propsndoc"}; + Map infoMap = PMOBPService.getIPMOQueryService().queryMaterialRelationArray(marMapList, marPlanFields, marProdFields, orgid, ((PMOAggVO)orgMapList.get(orgid).get(0)).getParentVO().getPk_group()); + if (!MMMapUtil.isEmpty(infoMap)) { + for(String key : marSet) { + PMOItemVO[] hvos = (PMOItemVO[])marMapList.get(key).toArray(new PMOItemVO[0]); + if (!MMArrayUtil.isEmpty(hvos)) { + for(PMOItemVO hvo : hvos) { + PMOMaterialRelationVO infovo = (PMOMaterialRelationVO)infoMap.get(key + hvo.getCmoid()); + if (MMValueCheck.isEmpty(hvo.getCbomversionid())) { + hvo.setCbomversionid(infovo.getCbomversionid()); + hvo.setVbomversion(infovo.getVbomversion()); + } + + if (MMValueCheck.isEmpty(hvo.getCpackbomid())) { + hvo.setCpackbomid(infovo.getCpackbomid()); + hvo.setVpackbomversion(infovo.getVpackbomversion()); + } + + if (MMValueCheck.isEmpty(hvo.getCdeptvid())) { + hvo.setCdeptvid(infovo.getCdeptvid()); + hvo.setCdeptid(infovo.getCdeptid()); + } + + if (MMValueCheck.isEmpty(hvo.getCemployeeid())) { + hvo.setCemployeeid(infovo.getCemployeeid()); + } + + if (MMValueCheck.isEmpty(hvo.getCrtversionid())) { + hvo.setCrtversionid(infovo.getCrtversionid()); + hvo.setVrtversion(infovo.getVrtversion()); + } + + if (MMValueCheck.isEmpty(hvo.getCwkid())) { + hvo.setCwkid(infovo.getCwkid()); + } + + PMOMaterialViewVO materialvo = PMOBPCalUtil.getMaterialView(orgid, infovo); + PMOBPCalUtil.fillBeginAndEndDate(materialvo, hvo); + } + } + } + } + } + + return aggvos; + } catch (BusinessException e) { + ExceptionUtils.marsh(e); + return null; + } + } + + public Map getInwarehouseid(String[] cmaterialvids, String pk_org) { + Map stockMap = new HashMap(); + if (MMArrayUtil.isEmpty(cmaterialvids)) { + return stockMap; + } else { + IMaterialPubService_C serv = (IMaterialPubService_C)NCLocator.getInstance().lookup(IMaterialPubService_C.class); + + try { + stockMap = serv.queryMaterialStockInfoByPks(cmaterialvids, pk_org, new String[]{"pk_material", "pk_stordoc"}); + } catch (BusinessException e2) { + ExceptionUtils.wrappException(e2); + } + + Set stockids = new HashSet(); + + for(Map.Entry entry : stockMap.entrySet()) { + if (MMValueCheck.isNotEmpty(((MaterialStockVO)entry.getValue()).getPk_stordoc())) { + stockids.add(((MaterialStockVO)entry.getValue()).getPk_stordoc()); + } + } + + Set storeSet = new HashSet(); + if (MMCollectionUtil.isNotEmpty(stockids)) { + BaseDAO dao = new BaseDAO(); + MMSqlBuilder sql = new MMSqlBuilder(); + sql.append("select pk_stordoc from bd_stordoc where gubflag = 'N' and isdirectstore = 'N' and iscommissionout = 'N'"); + sql.and(); + sql.append("pk_stordoc", stockids); + List storedocList = new ArrayList(); + + try { + storedocList = (List)dao.executeQuery(sql.toString(), new ColumnListProcessor()); + } catch (DAOException e) { + ExceptionUtils.wrappException(e); + } + + if (MMCollectionUtil.isNotEmpty(storedocList)) { + for(Object storedoc : storedocList) { + if (MMValueCheck.isNotEmpty(storedoc)) { + storeSet.add(storedoc.toString()); + } + } + } + } + + if (MMValueCheck.isNotEmpty(stockMap)) { + for(Map.Entry entry : stockMap.entrySet()) { + if (MMValueCheck.isNotEmpty(((MaterialStockVO)entry.getValue()).getPk_stordoc()) && !storeSet.contains(((MaterialStockVO)entry.getValue()).getPk_stordoc())) { + stockMap.remove(entry.getKey()); + } + } + } + + return stockMap; + } + } +}