yonyou
/
taikai2312
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main'

This commit is contained in:
张明 2025-06-17 10:09:47 +08:00
parent 5795f4b5be d08a4b955f
commit 5a869f91ab
31 changed files with 2672 additions and 647 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.classpath
View File

@ -100,6 +100,11 @@
<classpathentry kind="src" output="bin" path="imag/src/private"/>
<classpathentry kind="src" output="bin" path="imag/src/test"/>
<classpathentry kind="src" output="bin" path="imag/resources"/>
<classpathentry kind="src" output="bin" path="mmpsc/src/public"/>
<classpathentry kind="src" output="bin" path="mmpsc/src/client"/>
<classpathentry kind="src" output="bin" path="mmpsc/src/private"/>
<classpathentry kind="src" output="bin" path="mmpsc/src/test"/>
<classpathentry kind="src" output="bin" path="mmpsc/resources"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">
<attributes>
<attribute name="module" value="true"/>

62
arap/src/private/nc/bs/pub/action/N_F2_DELETE.java Normal file
View File

@ -0,0 +1,62 @@
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package nc.bs.pub.action;
import nc.bs.arap.actions.N_BASE_ACTION;
import nc.bs.arap.util.GatheringBillAfter;
import nc.bs.framework.common.NCLocator;
import nc.vo.arap.gathering.AggGatheringBillVO;
import nc.vo.arap.pub.ArapConstant;
import nc.vo.fipub.exception.ExceptionHandler;
import nc.vo.pub.BusinessException;
import nc.vo.pub.compiler.PfParameterVO;
import nccloud.pubitf.arap.arappub.IArapBillPubUtilService;
import java.util.Hashtable;
public class N_F2_DELETE extends N_BASE_ACTION {
private Hashtable<String, Object> m_keyHas = null;
public N_F2_DELETE() {
}
public Object runComClass(PfParameterVO paraVo) throws BusinessException {
try {
if (paraVo.m_preValueVos == null) {
return null;
} else {
Object obj = null;
super.m_tmpVo = paraVo;
String actionCode = ArapConstant.DELETE;
((IArapBillPubUtilService) NCLocator.getInstance().lookup(IArapBillPubUtilService.class)).interceptorVaildator(paraVo.m_preValueVos, actionCode);
this.setParameter("context", paraVo.m_preValueVos);
obj = this.runClass("nc.bs.arap.actions.GatheringbillDeleteBatchBSAction", "deleteVOs", "&context:nc.vo.pub.AggregatedValueObject[]", paraVo, this.m_keyHas);
this.afterCheck();
// 收款单删除后将对应的到账通知cmp_informer的生成状态generateflag修改为已生成hasnogenerate
AggGatheringBillVO[] aggVos = (AggGatheringBillVO[]) paraVo.m_preValueVos;
GatheringBillAfter.updateInformerGenerateFlag(aggVos, "hasnogenerate");
return obj;
}
} catch (Exception ex) {
throw ExceptionHandler.handleException(this.getClass(), ex);
}
}
public String getCodeRemark() {
return " arap action script not allowed to modify ,all rights reserved!";
}
protected void setParameter(String key, Object val) {
if (this.m_keyHas == null) {
this.m_keyHas = new Hashtable();
}
if (val != null) {
this.m_keyHas.put(key, val);
}
}
}

186
arap/src/private/nc/bs/pub/action/N_F2_SAVE.java Normal file
View File

@ -0,0 +1,186 @@
package nc.bs.pub.action;
import nc.bs.arap.actions.N_BASE_ACTION;
import nc.bs.arap.gatheringbp.GatherBillBO;
import nc.bs.arap.util.GatheringBillAfter;
import nc.bs.dao.BaseDAO;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.bs.framework.common.NCLocator;
import nc.bs.logging.Logger;
import nc.impl.pubapp.env.BSContext;
import nc.pubitf.so.m30.sobalance.ISoBalance4VerifyQryBill;
import nc.vo.arap.gathering.AggGatheringBillVO;
import nc.vo.arap.pub.ArapConstant;
import nc.vo.arap.pub.BillEnumCollection;
import nc.vo.arap.receivable.ReceivableBillItemVO;
import nc.vo.arap.utils.StringUtil;
import nc.vo.fi.pub.SqlUtils;
import nc.vo.fipub.exception.ExceptionHandler;
import nc.vo.ml.NCLangRes4VoTransl;
import nc.vo.pub.AggregatedValueObject;
import nc.vo.pub.BusinessException;
import nc.vo.pub.compiler.PfParameterVO;
import nc.vo.pub.lang.UFBoolean;
import nc.vo.pub.lang.UFDouble;
import nccloud.bs.arap.util.commit.ArapCommitUtil;
import nccloud.impl.platform.common.util.StringUtils;
import nccloud.pubitf.arap.arappub.IArapBillPubUtilService;
import java.util.*;
public class N_F2_SAVE extends N_BASE_ACTION {
private Hashtable<String, Object> m_keyHas = null;
public String getCodeRemark() {
return " arap action script not allowed to modify ,all rights reserved!";
}
public Object runComClass(PfParameterVO paraVo) throws BusinessException {
try {
super.m_tmpVo = paraVo;
Object obj = null;
setParameter("context", paraVo.m_preValueVos);
if (paraVo.isCloudEntry) {
String actionCode = ArapConstant.SAVE;
((IArapBillPubUtilService) NCLocator.getInstance().lookup(IArapBillPubUtilService.class)).interceptorVaildator(paraVo.m_preValueVos, actionCode);
}
String code = InvocationInfoProxy.getInstance().getProperty(ArapConstant.NCCFlOW_PARAMTER);
if (!StringUtils.isEmpty(code)) {
String[] codes = code.split(",");
for (int i = 0; i < codes.length; i++) {
BSContext.getInstance().setSession(codes[i], UFBoolean.FALSE);
}
}
this.beforeCheck();
AggregatedValueObject bill = (paraVo.m_preValueVo == null) ? paraVo.m_preValueVos[0] : paraVo.m_preValueVo;
if (bill != null && bill.getChildrenVO() != null && bill.getChildrenVO().length > 0 && bill.getChildrenVO()[0] != null) {
String pk_billtype = (String) bill.getChildrenVO()[0].getAttributeValue("pk_billtype");
String top_billtype = (String) bill.getChildrenVO()[0].getAttributeValue("top_billtype");
String src_billtype = (String) bill.getChildrenVO()[0].getAttributeValue("src_billtype");
if ("F2".equals(pk_billtype) && "30".equals(src_billtype) && "F0".equals(top_billtype)) {
Map<String, UFDouble> f2mnyMap = new HashMap<>();
Map<String, UFDouble> f0mnyMap = new HashMap<>();
List<String> orderIds = new ArrayList<>();
List<String> f0pks = new ArrayList<>();
for (int i = 0; i < bill.getChildrenVO().length; i++) {
String src_billid = (String) bill.getChildrenVO()[i].getAttributeValue("src_billid");
UFDouble money_bal = (UFDouble) bill.getChildrenVO()[i].getAttributeValue("money_bal");
if (!StringUtil.isEmpty(src_billid)) {
orderIds.add((String) bill.getChildrenVO()[i].getAttributeValue("src_billid"));
}
if (f2mnyMap.get(src_billid) == null) {
f2mnyMap.put(src_billid, money_bal);
} else {
f2mnyMap.put(src_billid, ((UFDouble) f2mnyMap.get(src_billid)).add(money_bal));
}
f0pks.add((String) bill.getChildrenVO()[i].getAttributeValue("top_billid"));
}
String f0sql = SqlUtils.getInStr("pk_recbill", (String[]) f0pks.toArray(new String[0]), true);
Collection<ReceivableBillItemVO> foItemvos = (new BaseDAO()).retrieveByClause(ReceivableBillItemVO.class, f0sql);
for (ReceivableBillItemVO vo : foItemvos) {
String src_billid = (String) vo.getAttributeValue("src_billid");
UFDouble money_bal = (UFDouble) vo.getAttributeValue("money_bal");
if (f0mnyMap.get(src_billid) == null) {
f0mnyMap.put(src_billid, money_bal);
continue;
}
f0mnyMap.put(src_billid, ((UFDouble) f0mnyMap.get(src_billid)).add(money_bal));
}
Map<String, Map<String, UFDouble>> soOrderIdTOF2ItemMnyMap = ((ISoBalance4VerifyQryBill) NCLocator.getInstance().lookup(ISoBalance4VerifyQryBill.class)).querySobalanceAccVerifyMnyMap((String[]) orderIds.toArray(new String[0]));
if (soOrderIdTOF2ItemMnyMap != null && soOrderIdTOF2ItemMnyMap.size() > 0) {
for (String order : orderIds) {
Map<String, UFDouble> mnys = (Map) soOrderIdTOF2ItemMnyMap.get(order);
UFDouble summny = UFDouble.ZERO_DBL;
if (mnys == null || mnys.size() == 0) {
continue;
}
for (String key : mnys.keySet()) {
UFDouble mny = (mnys.get(key) == null) ? UFDouble.ZERO_DBL : (UFDouble) mnys.get(key);
summny = summny.add(mny);
}
if (f2mnyMap.get(order) == null) {
f2mnyMap.put(order, summny);
continue;
}
f2mnyMap.put(order, ((UFDouble) f2mnyMap.get(order)).add(summny));
}
for (String order : orderIds) {
if (f0mnyMap.get(order) != null && f2mnyMap.get(order) != null && ((UFDouble) f2mnyMap.get(order)).abs().compareTo(((UFDouble) f0mnyMap.get(order)).abs()) > 0) {
throw new BusinessException(NCLangRes4VoTransl.getNCLangRes().getStrByID("2006pub_0", "02006pub-1678"));
}
}
}
}
}
String primaryKey = paraVo.m_preValueVos[0].getParentVO().getPrimaryKey();
if (hasBill(primaryKey)) {
obj = runClass("nc.bs.arap.actions.GatheringbillEditSaveBatchBSAction", "updateVOs", "&context:nc.vo.pub.AggregatedValueObject[]", paraVo, this.m_keyHas);
} else {
paraVo = approveStatusChange(paraVo);
obj = runClass("nc.bs.arap.actions.GatheringbillSaveBatchBSAction", "insertVOs", "&context:nc.vo.pub.AggregatedValueObject[]", paraVo, this.m_keyHas);
}
// 生成收款单后将对应的到账通知cmp_informer的生成状态generateflag修改为已生成hasgenerate
AggGatheringBillVO[] aggVos = (AggGatheringBillVO[]) paraVo.m_preValueVos;
GatheringBillAfter.updateInformerGenerateFlag(aggVos, "hasgenerate");
return (new ArapCommitUtil()).autoCommit(obj);
} catch (Exception exception) {
throw ExceptionHandler.handleException(getClass(), exception);
}
}
private boolean hasBill(String primaryKey) throws BusinessException {
boolean hasBill = false;
if (primaryKey != null) {
AggGatheringBillVO[] bvos = null;
try {
GatherBillBO payableBO = new GatherBillBO();
bvos = payableBO.findBillByPrimaryKey(new String[]{primaryKey});
} catch (Exception e) {
Logger.error(e.getMessage(), e);
}
if (bvos != null && bvos.length != 0 && bvos[0] != null) {
hasBill = true;
}
}
return hasBill;
}
protected void setParameter(String key, Object val) {
if (this.m_keyHas == null) {
this.m_keyHas = new Hashtable();
}
if (val != null)
this.m_keyHas.put(key, val);
}
private PfParameterVO approveStatusChange(PfParameterVO paraVo) {
for (AggregatedValueObject vo : paraVo.m_preValueVos) {
vo.getParentVO().setAttributeValue("approvestatus", BillEnumCollection.ApproveStatus.NOSTATE.VALUE);
}
return paraVo;
}
}

58
arap/src/public/nc/bs/arap/util/GatheringBillAfter.java Normal file
View File

@ -0,0 +1,58 @@
package nc.bs.arap.util;
import nc.bs.dao.BaseDAO;
import nc.bs.logging.Logger;
import nc.jdbc.framework.SQLParameter;
import nc.vo.arap.gathering.AggGatheringBillVO;
import nc.vo.arap.gathering.GatheringBillItemVO;
import nccloud.commons.lang.StringUtils;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
/**
* 更新到账通知的收款生成状态
*
* @author mzr
* @date 2025/6/13
*/
public class GatheringBillAfter {
/**
* 更新收款单对应的到账通知 cmp_informer 的 generateflag 生成状态
*
* @param aggVos 收款单vo数组
* @param generateFlag 目标状态（例如 "hasgenerate" 或 "hasnogenerate"）
*/
public static void updateInformerGenerateFlag(AggGatheringBillVO[] aggVos, String generateFlag) {
if (aggVos == null || aggVos.length == 0) {
return; // 参数为空时直接返回
}
try {
Set<String> codeSet = new LinkedHashSet<>();
for (AggGatheringBillVO aggVo : aggVos) {
GatheringBillItemVO[] bvos = aggVo.getBodyVOs();
for (GatheringBillItemVO bvo : bvos) {
String bankrelatedCode = bvo.getBankrelated_code();
if (StringUtils.isNotEmpty(bankrelatedCode) && !"~".equals(bankrelatedCode)) {
codeSet.add(bankrelatedCode);
}
}
}
String[] codes = codeSet.toArray(new String[0]);
Logger.error("updateInformerGenerateFlag-codes = " + Arrays.toString(codes));
if (codes.length == 0) {
return;
}
BaseDAO baseDAO = new BaseDAO();
String inStr = SqlUtils.getInStr("bankrelated_code", codes, true);
String sql = "UPDATE cmp_informer SET generateflag = ? WHERE " + inStr;
SQLParameter params = new SQLParameter();
params.addParam(generateFlag);
baseDAO.executeUpdate(sql, params);
} catch (Exception e) {
Logger.error("updateInformerGenerateFlag-exp:", e);
}
}
}

128
ic/src/private/nc/bs/ic/m45/insert/InsertBP.java Normal file
View File

@ -0,0 +1,128 @@
package nc.bs.ic.m45.insert;
import nc.bs.ic.general.insert.IInsertBP;
import nc.bs.ic.general.insert.InsertBPTemplate;
import nc.bs.ic.general.insert.rule.before.CheckCliabilityValue;
import nc.bs.ic.general.rule.after.AtpAfterUpdate;
import nc.bs.ic.general.rule.before.CtplcustomeridCheck;
import nc.bs.ic.m45.base.BPPlugInPoint;
import nc.bs.ic.m45.base.rule.FillCostOrgRule;
import nc.bs.ic.m45.base.rule.PurchaseBillCheckRule;
import nc.bs.ic.m45.base.rule.PurchaseInAssetWarehouseCheck;
import nc.bs.ic.m45.base.rule.PurchaseInVOScaleCheckRule;
import nc.bs.ic.m45.base.rule.PurchaseinRetMarginProcess;
import nc.bs.ic.m45.base.rule.PurchaseinRetMarginProcessFor5805;
import nc.bs.ic.m45.base.rule.ReturnSnIsExistInEquipcardCheck;
import nc.bs.ic.m45.base.rule.VmiCheckRule;
import nc.bs.ic.m45.insert.rule.*;
import nc.bs.ic.pub.base.ICAroundProcesser;
import nc.bs.ic.pub.base.IInsertRuleProvider;
import nc.impl.pubapp.pattern.rule.processer.AroundProcesser;
import nc.vo.bd.payment.IPaymentUtil;
import nc.vo.ic.general.define.MetaNameConst;
import nc.vo.ic.m45.entity.PurchaseInBodyVO;
import nc.vo.ic.m45.entity.PurchaseInVO;
import nc.vo.ic.pub.util.StringUtil;
import nccloud.bs.ic.mobile.inbound.operation.rewrite.MobAfterPurchaseInSave;
/**
* 采购入库单后台新增BP
*
* @author songhy
*/
public class InsertBP implements IInsertBP<PurchaseInVO>,
IInsertRuleProvider<PurchaseInVO> {
@Override
public void addAfterRule(PurchaseInVO[] vos,
AroundProcesser<PurchaseInVO> processor) {
//红字采购入库单保存的时候，增加判断逻辑，如果表头仓库是直运仓，不检查物料的现存量 放在前面设置session
processor.addAfterRule(new IsRedBookThrough());
/**
* 放在现存量更新规则（OnhandAfterUpdate）之后，因为现存量更新时会调用预留接口，预留接口会回写采购订单，
* 如果入库数量=订单数量，订单会自动入库关闭，入库关闭会解除预留，导致后续操作错误
*/
((ICAroundProcesser<PurchaseInVO>) processor).addAfterRuleAt(
new InsertRewritePORule(), AtpAfterUpdate.class);
processor.addAfterRule(new InsReWritePIM());
processor.addAfterRule(new InsertRewriteITRule());
processor.addAfterRule(new MobAfterPurchaseInSave());
processor.addAfterRule(new FeeDetailInsert());
//红字采购入库单原单退回保存回写累计入库退回主数量，由于预留处理需要查询蓝字采购入库单，回写操作应放在现存量更新规则（OnhandAfterUpdate）之后
((ICAroundProcesser<PurchaseInVO>) processor).addAfterRuleAt(new InsertRedReturnInRewriteRule(), AtpAfterUpdate.class);
((ICAroundProcesser<PurchaseInVO>) processor).addAfterRuleAt(new InsertRedReturnInRewriteSORule(), InsertRedReturnInRewriteRule.class);
// 回写付款计划
processor.addAfterRule(new InsertRewritePayPlanConfirmDataRule());
// 回写付款计划子孙开票数据 先票后入库 入库日期时点，
processor.addAfterRule(new InsertOrSignRewritePayPlanInvoiceRule(IPaymentUtil.STORE_RECEIPT_DATE));
// 入库单保存回写采购合同付款计划
processor.addAfterRule(new M45SaveAndRewriteCTPayPlan());
// processor.addAfterRule(new InsertRewritePORule());
}
@Override
public void addBeforeRule(PurchaseInVO[] vos,
AroundProcesser<PurchaseInVO> processor) {
// 检查是否可以生成入库单
processor.addBeforeRule(new InsertCheckCanInRule());
processor.addBeforeRule(new FillCostOrgRule());
// processor.addBeforeRule(new SaveCheckFeeMnyRule());
processor.addBeforeRule(new PurchaseBillCheckRule());
processor.addBeforeRule(new PurchaseInAssetWarehouseCheck());
// 当数量（主数量，数量，报价数量）与采购订单一致时，使采购入库单表体价格和单价与采购订单一致
//下面的规则处理会使入库单的改价不生效 hujieh
// processor.addBeforeRule(new AdjustPriceAndMnyWhenSameNumRule());
processor.addBeforeRule(new CtplcustomeridCheck<PurchaseInVO>());
processor.addBeforeRule(new VmiCheckRule());
processor.addBeforeRule(new ReturnSnIsExistInEquipcardCheck());
// 红蓝字入库单倒挤，跟订单倒挤
processor.addBeforeRule(new PurchaseinRetMarginProcess());
processor.addBeforeRule(new PurchaseinRetMarginProcessFor5805());
processor.addBeforeRule(new PurchaseInVOScaleCheckRule());
processor.addBeforeRule(new InsertCheckMaterialUnit());
// 利润中心校验规则
processor.addBeforeRule(new CheckCliabilityValue<PurchaseInVO>(MetaNameConst.CLIABILITYOID,MetaNameConst.CIOLIABILITYOID));
// 来源于进口模块--流向单，填充报价单位、报价换算率
processor.addBeforeRule(new FillInVqtunitRule());
//2025年6月13日09点38分 -- 物料档案基本页签启用项目辅助属性+库存组织未启用项目，采购入库单保存时（包含接口导入）清除行项目，材料出库单保存时（包含接口导入）清除行项目
processor.addBeforeRule(new PurchaseInProjectRule());
}
@Override
public PurchaseInVO[] insert(PurchaseInVO[] bills) {
// 应该在“物理自由辅助属性检查”规则执行前补充供应商
this.fillCvendorid(bills);
InsertBPTemplate<PurchaseInVO> insertBP =
new InsertBPTemplate<PurchaseInVO>(BPPlugInPoint.InsertBP, this);
return insertBP.insert(bills);
}
/**
* 补表体的供应商，供应商已经挪到表头，表体的供应商要跟表头供应商一样
*
* @param vos
*/
private void fillCvendorid(PurchaseInVO[] vos) {
String cvendor = null;
String cvendorvid = null;
for (PurchaseInVO vo : vos) {
// 取表头供应商
cvendor = vo.getHead().getCvendorid();
cvendorvid = vo.getHead().getCvendorvid();
if (StringUtil.isSEmptyOrNull(cvendor)) {
continue;
}
// 为表体供应商赋值
for (PurchaseInBodyVO body : vo.getBodys()) {
body.setCvendorid(cvendor);
body.setCvendorvid(cvendorvid);
}
}
}
}

77
ic/src/private/nc/bs/ic/m45/insert/rule/PurchaseInProjectRule.java Normal file
View File

@ -0,0 +1,77 @@
package nc.bs.ic.m45.insert.rule;
import nc.bs.dao.BaseDAO;
import nc.bs.ic.pub.base.ICRule;
import nc.jdbc.framework.processor.MapListProcessor;
import nc.vo.ic.general.define.ICBillBodyVO;
import nc.vo.ic.general.define.ICBillVO;
import nc.vo.ic.m45.entity.PurchaseInVO;
import nc.vo.pub.BusinessException;
import nc.vo.pubapp.pattern.exception.ExceptionUtils;
import nc.vo.pubapp.pattern.pub.SqlBuilder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @Classname PurchaseInProjectRule
* @Description TODO
* @Version 1.0.0
* @Date 2025/6/13 14:19
* @Created by ame
*/
public class PurchaseInProjectRule extends ICRule<PurchaseInVO> {
private static BaseDAO dao=new BaseDAO();
@Override
public void process(PurchaseInVO[] vos) {
if(vos==null || vos.length<1){
return;
}
try {
//获取表头计划组织及表体行物料
for (ICBillVO vo : vos) {
String pk_org = (String) vo.getParentVO().getAttributeValue("pk_org");
ICBillBodyVO[] bodys = vo.getBodys();
Map<String,String> material_construct = new HashMap<>();
Map<String,String> material_stock = new HashMap<>();
queryFix2ByMaterial(bodys,material_construct,material_stock,pk_org);
for(ICBillBodyVO body:bodys){
String cmaterialvid = body.getCmaterialvid();
if(material_construct.containsKey(cmaterialvid)&& "Y".equals(material_construct.get(cmaterialvid))&& (!material_stock.containsKey(cmaterialvid)|| "N".equals(material_stock.get(cmaterialvid)))){
body.setCprojectid(null);
}
}
}
} catch (BusinessException var6) {
ExceptionUtils.wrappException(var6);
}
}
private void queryFix2ByMaterial(ICBillBodyVO[] childrenVOs, Map<String, String> materialConstruct, Map<String, String> materialStock, String pkOrg) throws BusinessException {
List<String> materials=new ArrayList<>();
for (ICBillBodyVO childrenVO : childrenVOs){
String cmaterialvid = childrenVO.getCmaterialvid();
materials.add(cmaterialvid);
}
SqlBuilder sql =new SqlBuilder();
sql.append(" SELECT bdm.pk_material ,bdmf.fix2,bdms.fixasst2 ");
sql.append(" FROM bd_material bdm ");
sql.append(" LEFT JOIN bd_marasstframe bdmf ON bdm.pk_marasstframe =bdmf.pk_marasstframe ");
sql.append(" LEFT JOIN bd_materialstock bdms ON bdms.PK_MATERIAL =bdm.PK_MATERIAL AND bdms.PK_ORG ='"+pkOrg+"' ");
sql.append(" where ");
sql.append("bdm.pk_material",materials.toArray(new String[0]));
List<Map<String,Object>> remain = (List<Map<String, Object>>) dao.executeQuery(sql.toString(), new MapListProcessor());
if(remain==null || remain.isEmpty()){
throw new BusinessException("物料查询辅助属性结构失败,sql【"+sql+"】");
}
for (Map<String,Object> map:remain){
String fix2=map.get("fix2")==null?"N":map.get("fix2").toString();
String fixasst2=map.get("fixasst2")==null?"N":map.get("fixasst2").toString();
materialConstruct.put(map.get("pk_material").toString(),fix2);
materialStock.put(map.get("pk_material").toString(),fixasst2);
}
}
}

153
ic/src/private/nc/bs/ic/m45/update/UpdateBP.java Normal file
View File

@ -0,0 +1,153 @@
package nc.bs.ic.m45.update;
import nc.bs.ic.general.rule.after.AtpAfterUpdate;
import nc.bs.ic.general.rule.before.CtplcustomeridCheck;
import nc.bs.ic.general.update.IUpdateBP;
import nc.bs.ic.general.update.UpdateBPTemplate;
import nc.bs.ic.m45.base.BPPlugInPoint;
import nc.bs.ic.m45.base.rule.FillCostOrgRule;
import nc.bs.ic.m45.base.rule.PurchaseBillCheckRule;
import nc.bs.ic.m45.base.rule.PurchaseInAssetWarehouseCheck;
import nc.bs.ic.m45.base.rule.PurchaseInVOScaleCheckRule;
import nc.bs.ic.m45.base.rule.PurchaseinRetMarginProcess;
import nc.bs.ic.m45.base.rule.PurchaseinRetMarginProcessFor5805;
import nc.bs.ic.m45.base.rule.ReturnSnIsExistInEquipcardCheck;
import nc.bs.ic.m45.base.rule.VmiCheckRule;
import nc.bs.ic.m45.insert.rule.InsertCheckMaterialUnit;
import nc.bs.ic.m45.insert.rule.M45SaveAndRewriteCTPayPlan;
import nc.bs.ic.m45.insert.rule.PurchaseInProjectRule;
import nc.bs.ic.m45.update.rule.FeeDetailUpdate;
import nc.bs.ic.m45.update.rule.IsRedBookThroughUpdate;
import nc.bs.ic.m45.update.rule.UpdReWritePIM;
import nc.bs.ic.m45.update.rule.UpdateNumCheck;
import nc.bs.ic.m45.update.rule.UpdateRedReturnInRewriteRule;
import nc.bs.ic.m45.update.rule.UpdateRewriteITRule;
import nc.bs.ic.m45.update.rule.UpdateRewritePORule;
import nc.bs.ic.m45.update.rule.UpdateRewritePayPlanConfirmDataRule;
import nc.bs.ic.m45.update.rule.UpdateRewritePayPlanConfirmInvoicenumRule;
import nc.bs.ic.pub.base.ICCompareAroundProcesser;
import nc.bs.ic.pub.base.IUpdateRuleProvider;
import nc.bs.ic.pub.util.SagasUtils;
import nc.bs.scmpub.rule.VOSagaFrozenValidateRule;
import nc.impl.pubapp.pattern.rule.processer.CompareAroundProcesser;
import nc.itf.ic.m45.compensate.IPurchaseInSagasCompensate;
import nc.vo.ic.general.define.SagasConst;
import nc.vo.ic.m45.entity.PurchaseInBodyVO;
import nc.vo.ic.m45.entity.PurchaseInVO;
import nc.vo.ic.pub.util.StringUtil;
import nc.vo.pub.VOStatus;
import nc.vo.scmpub.res.billtype.ICBillType;
import nccloud.bs.ic.mobile.inbound.operation.rewrite.MobAfterPurchaseInUpdate;
import nccloud.bs.ic.mobile.inbound.operation.rewrite.MobBeforePurchaseInUpdate;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
* 采购入库单后台更新BP
*
* @author songhy
*/
public class UpdateBP implements IUpdateBP<PurchaseInVO>, IUpdateRuleProvider<PurchaseInVO> {
@Override
public void addAfterRule(PurchaseInVO[] vos, PurchaseInVO[] originVOs,
CompareAroundProcesser<PurchaseInVO> processor) {
//红字采购入库修改单保存的时候，增加判断逻辑，如果表头仓库是直运仓，不检查物料的现存量 放在前面设置session
processor.addAfterRule(new IsRedBookThroughUpdate());
/**
* 放在现存量更新规则（OnhandAfterUpdate）之后，因为现存量更新时会调用预留接口，预留接口会回写采购订单，
* 如果入库数量=订单数量，订单会自动入库关闭，入库关闭会解除预留，导致后续操作错误
*/
((ICCompareAroundProcesser<PurchaseInVO>) processor).addAfterRuleAt(new UpdateRewritePORule(),
AtpAfterUpdate.class);
processor.addAfterRule(new UpdReWritePIM());
processor.addAfterRule(new FeeDetailUpdate());
// processor.addAfterRule(new UpdateRewritePORule());
processor.addAfterRule(new UpdateRewriteITRule());
// 2020年3月19日 补充微协同，增加采购入库单修改后消息
processor.addAfterRule(new MobAfterPurchaseInUpdate());
//红字采购入库单原单退回保存回写累计入库退回主数量，由于预留处理需要查询蓝字采购入库单，回写操作应放在现存量更新规则（OnhandAfterUpdate）之后
((ICCompareAroundProcesser<PurchaseInVO>) processor).addAfterRuleAt(new UpdateRedReturnInRewriteRule(), AtpAfterUpdate.class);
// 入库单保存回写采购合同付款计划
processor.addAfterRule(new M45SaveAndRewriteCTPayPlan());
// 入库修改保存回写采购订单付款计划 add by yinliangc 20220219
processor.addAfterRule(new UpdateRewritePayPlanConfirmDataRule());
// 入库修改保存回写付款计划开票信息
processor.addAfterRule(new UpdateRewritePayPlanConfirmInvoicenumRule());
}
@Override
public void addBeforeRule(PurchaseInVO[] vos, PurchaseInVO[] originVOs,
CompareAroundProcesser<PurchaseInVO> processor) {
// sagas冻结校验
processor.addBeforeRule(new VOSagaFrozenValidateRule<PurchaseInVO>(true));
processor.addBeforeRule(new FillCostOrgRule());
processor.addBeforeRule(new PurchaseBillCheckRule());
processor.addBeforeRule(new PurchaseInAssetWarehouseCheck());
processor.addBeforeRule(new CtplcustomeridCheck<PurchaseInVO>());
processor.addBeforeRule(new VmiCheckRule());
processor.addBeforeRule(new ReturnSnIsExistInEquipcardCheck());
processor.addBeforeRule(new PurchaseinRetMarginProcess());
processor.addBeforeRule(new PurchaseinRetMarginProcessFor5805());
processor.addBeforeRule(new PurchaseInVOScaleCheckRule());
// 利润中心校验规则
// processor.addBeforeRule(
// new CheckCliabilityValue<PurchaseInVO>(MetaNameConst.CLIABILITYOID, MetaNameConst.CIOLIABILITYOID));
processor.addBeforeRule(new InsertCheckMaterialUnit());
processor.addBeforeRule(new MobBeforePurchaseInUpdate());
//新加校验 出库跟踪入库场景 将采购入库单入库数量改小校验
processor.addBeforeRule(new UpdateNumCheck());
//2025年6月13日09点38分 -- 物料档案基本页签启用项目辅助属性+库存组织未启用项目，采购入库单保存时（包含接口导入）清除行项目，材料出库单保存时（包含接口导入）清除行项目
processor.addBeforeRule(new PurchaseInProjectRule());
}
/**
* 父类方法重写
*
*/
@Override
public PurchaseInVO[] update(PurchaseInVO[] vos, PurchaseInVO[] originVOs) {
SagasUtils.frozenAndAddSaga(vos, ICBillType.PurchaseIn.getCode(), SagasConst.COMPENSABLE, null);
Map<String, Serializable> paramMap = new HashMap<String, Serializable>();
paramMap.put(SagasConst.KEY_ACTIONNAME, SagasConst.UPDATE_45);
paramMap.put(SagasConst.KEY_VOS, SagasUtils.produceLightVO(vos, originVOs));
SagasUtils.compensate(paramMap, IPurchaseInSagasCompensate.class);
this.fillCvendorid(vos);
UpdateBPTemplate<PurchaseInVO> updateBP = new UpdateBPTemplate<PurchaseInVO>(BPPlugInPoint.UpdateBP, this);
PurchaseInVO[] retVOs = updateBP.update(vos, originVOs);
return retVOs;
}
private void fillCvendorid(PurchaseInVO[] vos) {
String cvendor = null;
String cvendorvid = null;
for (PurchaseInVO vo : vos) {
// 取表头供应商
cvendor = vo.getHead().getCvendorid();
//取表头供应商vid
cvendorvid = vo.getHead().getCvendorvid();
// 为表体供应商赋值
for (PurchaseInBodyVO body : vo.getBodys()) {
if (StringUtil.isStringEqual(cvendor, body.getCvendorid())) {
continue;
}
body.setCvendorid(cvendor);
body.setCvendorvid(cvendorvid);
if (VOStatus.UNCHANGED == body.getStatus()) {
// 此处必须判断状态，不能全部设为UPDATED，否则删行后，再新增行，保存会报错
body.setStatus(VOStatus.UPDATED);
}
}
}
}
}

121
ic/src/private/nc/bs/ic/m4d/insert/InsertBP.java Normal file
View File

@ -0,0 +1,121 @@
package nc.bs.ic.m4d.insert;
import nc.bs.ic.general.insert.IInsertBP;
import nc.bs.ic.general.insert.rule.after.InsertAfterEventRule;
import nc.bs.ic.general.insert.rule.after.RewriteQCInsertRule;
import nc.bs.ic.general.insert.rule.before.CheckCliabilityValue;
import nc.bs.ic.general.insert.rule.before.InsertBeforeEventRule;
import nc.bs.ic.general.rule.after.AfterInsertRuleForRewriteSpecial;
import nc.bs.ic.general.rule.after.AtpAfterUpdate;
import nc.bs.ic.general.rule.before.CtplcustomeridCheck;
import nc.bs.ic.m45.insert.rule.PurchaseInProjectRule;
import nc.bs.ic.m4d.base.BPPlugInPoint;
import nc.bs.ic.m4d.base.MaterialOutCheckRule;
import nc.bs.ic.m4d.base.MaterialOutValueProcRule;
import nc.bs.ic.m4d.base.MaterialOutWarehouseAttriCheck;
import nc.bs.ic.m4d.base.PurchaseInDateCheck;
import nc.bs.ic.m4d.insert.rule.*;
import nc.bs.ic.pub.base.ICAroundProcesser;
import nc.bs.ic.pub.base.IInsertRuleProvider;
import nc.bs.scmpub.rule.CrossRuleValidateRule;
import nc.impl.pubapp.pattern.rule.processer.AroundProcesser;
import nc.vo.ic.general.define.MetaNameConst;
import nc.vo.ic.m4d.entity.MaterialOutVO;
/**
* <p>
* <b>材料出库单新增BP：</b>
* <ul>
* <li>
* </ul>
* <p>
* <p>
*
* @version 6.0
* @since 6.0
* @author chennn
* @time 2010-4-19 上午09:51:08
*/
public class InsertBP implements IInsertBP<MaterialOutVO>,
IInsertRuleProvider<MaterialOutVO> {
@Override
public void addAfterRule(MaterialOutVO[] vos,
AroundProcesser<MaterialOutVO> processor) {
/*
* 放在现存量更新规则之后，因为回写销售订单，发货单时，如果出库数量等于订单数量，
* 订单自动行关闭，行关闭会执行预留解除，导致现存量更新时，处理预留业务产生错误
*/
((ICAroundProcesser<MaterialOutVO>) processor).addAfterRuleAt(
new UpdRewriteWorkOrder(), AtpAfterUpdate.class);
processor.addAfterRule(new InsReWriteSapplyBillRule());// 回写出库申请申请
processor.addAfterRule(new InsReWriteBuyingReqRule());// 回写物资需求申请
// 回写项目管理备料表，放在回写出库申请之前，为了解决以下问题：
// 不能计算预占量的问题，根本原因是因为出库申请的行关闭状态导致。
// 之前出库单先回写出库申请，再回写备料备料表，回写备料表时，项目管理要查询当前出库申请的行状态是否关闭，根据该状态计算预占量。
// 这样就不能区分此状态是因为出库单保存回写的还是出库单保存前就是关闭的
((ICAroundProcesser<MaterialOutVO>) processor).addAfterRuleAt(
new InsReWritePIM(), InsReWriteSapplyBillRule.class);
// 回写资产的领用单
processor.addAfterRule(new InsRewriteRM());
// 回写紧急放行单
processor.addAfterRule(new RewriteQCInsertRule<MaterialOutVO>());
/*
* 放在现存量更新规则之后，因为回写销售订单，发货单时，如果出库数量等于订单数量，
* 订单自动行关闭，行关闭会执行预留解除，导致现存量更新时，处理预留业务产生错误
*/
((ICAroundProcesser<MaterialOutVO>) processor).addAfterRuleAt(
new InsRewriteMMPAC(), AtpAfterUpdate.class);
// 回写生产报告
processor.addAfterRule(new InsRewriteWR());
//回写发货单
processor.addAfterRule(new ReWriteSOInsertRule());
// 工序完工报告倒冲时，回写备料计划
processor.addAfterRule(new InsRewriteMMSFC());
// 回写计划独立需求
processor.addAfterRule(new InsertRewriteMMDP());
// 回写特殊单据
processor
.addAfterRule(new AfterInsertRuleForRewriteSpecial<MaterialOutVO>());
((ICAroundProcesser<MaterialOutVO>) processor).replaceAfterRuleAt(
new InsAfterfEventRuleFor4D(), InsertAfterEventRule.class);
}
@Override
public void addBeforeRule(MaterialOutVO[] vos,
AroundProcesser<MaterialOutVO> processor) {
processor.addBeforeRule(new MaterialOutValueProcRule());
processor.addBeforeRule(new MaterialOutCheckRule());
// 利润中心校验规则
processor.addBeforeRule(new CheckCliabilityValue<MaterialOutVO>(MetaNameConst.CIOLIABILITYOID,MetaNameConst.CLIABILITYOID));
//processor.addBeforeRule(new CheckBiliValue<MaterialOutVO>());//“领料利润中心有值时，出库利润中心不能为空”
processor.addBeforeRule(new CtplcustomeridCheck<MaterialOutVO>());//表体“货主客户”与“寄存供应商”不能同时存在
processor.addBeforeRule(new MaterialOutWarehouseAttriCheck());
// 材料出库参照采购入库业务日期校验
processor.addBeforeRule(new PurchaseInDateCheck());
// 交叉校验规则
processor.addBeforeRule(new CrossRuleValidateRule<MaterialOutVO>());
((ICAroundProcesser<MaterialOutVO>) processor).replaceBeforeRuleAt(
new InsBeforeEventRuleFor4D(), InsertBeforeEventRule.class);
//2025年6月13日09点38分 -- 物料档案基本页签启用项目辅助属性+库存组织未启用项目，采购入库单保存时（包含接口导入）清除行项目，材料出库单保存时（包含接口导入）清除行项目
processor.addBeforeRule(new MaterialOutProjectRule());
}
@Override
public MaterialOutVO[] insert(MaterialOutVO[] bills) {
M4dInsertBPTemplate<MaterialOutVO> insertBP =
new M4dInsertBPTemplate<MaterialOutVO>(BPPlugInPoint.InsertBP, this);
return insertBP.insert(bills);
}
}

77
ic/src/private/nc/bs/ic/m4d/insert/rule/MaterialOutProjectRule.java Normal file
View File

@ -0,0 +1,77 @@
package nc.bs.ic.m4d.insert.rule;
import nc.bs.dao.BaseDAO;
import nc.bs.ic.pub.base.ICRule;
import nc.jdbc.framework.processor.MapListProcessor;
import nc.vo.ic.general.define.ICBillBodyVO;
import nc.vo.ic.general.define.ICBillVO;
import nc.vo.ic.m4d.entity.MaterialOutVO;
import nc.vo.pub.BusinessException;
import nc.vo.pubapp.pattern.exception.ExceptionUtils;
import nc.vo.pubapp.pattern.pub.SqlBuilder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @Classname MaterialOutProjectRule
* @Description TODO
* @Version 1.0.0
* @Date 2025/6/13 14:59
* @Created by ame
*/
public class MaterialOutProjectRule extends ICRule<MaterialOutVO> {
private static BaseDAO dao=new BaseDAO();
@Override
public void process(MaterialOutVO[] vos) {
if(vos==null || vos.length<1){
return;
}
try {
//获取表头计划组织及表体行物料
for (ICBillVO vo : vos) {
String pk_org = (String) vo.getParentVO().getAttributeValue("pk_org");
ICBillBodyVO[] bodys = vo.getBodys();
Map<String,String> material_construct = new HashMap<>();
Map<String,String> material_stock = new HashMap<>();
queryFix2ByMaterial(bodys,material_construct,material_stock,pk_org);
for(ICBillBodyVO body:bodys){
String cmaterialvid = body.getCmaterialvid();
if(material_construct.containsKey(cmaterialvid)&& "Y".equals(material_construct.get(cmaterialvid))&& (!material_stock.containsKey(cmaterialvid)|| "N".equals(material_stock.get(cmaterialvid)))){
body.setCprojectid(null);
}
}
}
} catch (BusinessException var6) {
ExceptionUtils.wrappException(var6);
}
}
private void queryFix2ByMaterial(ICBillBodyVO[] childrenVOs, Map<String, String> materialConstruct, Map<String, String> materialStock, String pkOrg) throws BusinessException {
List<String> materials=new ArrayList<>();
for (ICBillBodyVO childrenVO : childrenVOs){
String cmaterialvid = childrenVO.getCmaterialvid();
materials.add(cmaterialvid);
}
SqlBuilder sql =new SqlBuilder();
sql.append(" SELECT bdm.pk_material ,bdmf.fix2,bdms.fixasst2 ");
sql.append(" FROM bd_material bdm ");
sql.append(" LEFT JOIN bd_marasstframe bdmf ON bdm.pk_marasstframe =bdmf.pk_marasstframe ");
sql.append(" LEFT JOIN bd_materialstock bdms ON bdms.PK_MATERIAL =bdm.PK_MATERIAL AND bdms.PK_ORG ='"+pkOrg+"' ");
sql.append(" where ");
sql.append("bdm.pk_material",materials.toArray(new String[0]));
List<Map<String,Object>> remain = (List<Map<String, Object>>) dao.executeQuery(sql.toString(), new MapListProcessor());
if(remain==null || remain.isEmpty()){
throw new BusinessException("物料查询辅助属性结构失败,sql【"+sql+"】");
}
for (Map<String,Object> map:remain){
String fix2=map.get("fix2")==null?"N":map.get("fix2").toString();
String fixasst2=map.get("fixasst2")==null?"N":map.get("fixasst2").toString();
materialConstruct.put(map.get("pk_material").toString(),fix2);
materialStock.put(map.get("pk_material").toString(),fixasst2);
}
}
}

122
ic/src/private/nc/bs/ic/m4d/update/UpdateBP.java Normal file
View File

@ -0,0 +1,122 @@
package nc.bs.ic.m4d.update;
import nc.bs.ic.general.insert.rule.before.CheckCliabilityValue;
import nc.bs.ic.general.rule.after.AtpAfterUpdate;
import nc.bs.ic.general.rule.before.CtplcustomeridCheck;
import nc.bs.ic.general.update.IUpdateBP;
import nc.bs.ic.general.update.rule.after.RewriteQCUpdateRule;
import nc.bs.ic.m4d.base.BPPlugInPoint;
import nc.bs.ic.m4d.base.MaterialOutCheckRule;
import nc.bs.ic.m4d.base.MaterialOutValueProcRule;
import nc.bs.ic.m4d.base.MaterialOutWarehouseAttriCheck;
import nc.bs.ic.m4d.base.PurchaseInDateCheck;
import nc.bs.ic.m4d.insert.rule.MaterialOutProjectRule;
import nc.bs.ic.m4d.update.rule.ReWriteSOUpdateRule;
import nc.bs.ic.m4d.update.rule.UpdReWritePIM;
import nc.bs.ic.m4d.update.rule.UpdateRewriteMMDP;
import nc.bs.ic.pub.base.ICCompareAroundProcesser;
import nc.bs.ic.pub.base.IUpdateRuleProvider;
import nc.bs.scmpub.rule.CrossRuleValidateRule;
import nc.bs.scmpub.rule.VOSagaFrozenValidateRule;
import nc.impl.pubapp.pattern.rule.processer.CompareAroundProcesser;
import nc.vo.ic.general.define.MetaNameConst;
import nc.vo.ic.m4d.entity.MaterialOutVO;
/**
* <p>
* <b>材料出库单修改BP：</b>
* <ul>
* <li>
* </ul>
* <p>
* <p>
*
* @version 6.0
* @since 6.0
* @author chennn
* @time 2010-4-19 上午09:56:22
*/
public class UpdateBP implements IUpdateBP<MaterialOutVO>,
IUpdateRuleProvider<MaterialOutVO> {
@Override
public void addAfterRule(MaterialOutVO[] vos, MaterialOutVO[] originVOs,
CompareAroundProcesser<MaterialOutVO> processor) {
/*
* 放在现存量更新规则之后，因为回写销售订单，发货单时，如果出库数量等于订单数量，
* 订单自动行关闭，行关闭会执行预留解除，导致现存量更新时，处理预留业务产生错误
*/
((ICCompareAroundProcesser<MaterialOutVO>) processor).addAfterRuleAt(
new UpdRewriteWorkOrder(), AtpAfterUpdate.class);
// processor.addAfterRule(new UpdRewriteWorkOrder());
processor.addAfterRule(new UpdReWriteSapplyBillRule());// 回写出库申请单
processor.addAfterRule(new UpdReWriteBuyingReqRule());// 回写物资需求申请
// 回写资产的领用单
processor.addAfterRule(new UpdRewriteRM());
// 回写紧急放行单
processor.addAfterRule(new RewriteQCUpdateRule<MaterialOutVO>());
// 回写批次关联
processor.addAfterRule(new UpdRewriteBacthJoin());
//回写发货单
processor.addAfterRule(new ReWriteSOUpdateRule());
/*
* 放在现存量更新规则之后，因为回写销售订单，发货单时，如果出库数量等于订单数量，
* 订单自动行关闭，行关闭会执行预留解除，导致现存量更新时，处理预留业务产生错误
*/
((ICCompareAroundProcesser<MaterialOutVO>) processor).addAfterRuleAt(
new UpdRewriteMMPAC(), AtpAfterUpdate.class);
// 回写备料计划
processor.addAfterRule(new UpdRewriteMMSFC());
// 回写计划独立需求
processor.addAfterRule(new UpdateRewriteMMDP());
// 回写项目管理备料表，放在回写出库申请之前，为了解决以下问题：
// 不能计算预占量的问题，根本原因是因为出库申请的行关闭状态导致。
// 之前出库单先回写出库申请，再回写备料备料表，回写备料表时，项目管理要查询当前出库申请的行状态是否关闭，根据该状态计算预占量。
// 这样就不能区分此状态是因为出库单保存回写的还是出库单保存前就是关闭的
((ICCompareAroundProcesser<MaterialOutVO>) processor).addAfterRuleAt(
new UpdReWritePIM(), UpdReWriteSapplyBillRule.class);
// ((ICCompareAroundProcesser<MaterialOutVO>) processor).replaceAfterRuleAt(
// new UpdAfterEventRuleFor4D(), UpdateAfterEventRule.class);
}
@Override
public void addBeforeRule(MaterialOutVO[] vos, MaterialOutVO[] originVOs,
CompareAroundProcesser<MaterialOutVO> processor) {
//saga状态校验，材料出库既要校验表头也要校验表体
processor.addBeforeRule(new VOSagaFrozenValidateRule<MaterialOutVO>(true));
processor.addBeforeRule(new CtplcustomeridCheck<MaterialOutVO>());//表体“货主客户”与“寄存供应商”不能同时存在
processor.addBeforeRule(new MaterialOutValueProcRule());
processor.addBeforeRule(new MaterialOutCheckRule());
// 利润中心校验规则
processor.addBeforeRule(new CheckCliabilityValue<MaterialOutVO>(MetaNameConst.CIOLIABILITYOID,MetaNameConst.CLIABILITYOID));
processor.addBeforeRule(new MaterialOutWarehouseAttriCheck());
// 交叉校验规则
processor.addBeforeRule(new CrossRuleValidateRule<MaterialOutVO>());
// 材料出库参照采购入库业务日期校验
processor.addBeforeRule(new PurchaseInDateCheck());
// ((ICCompareAroundProcesser<MaterialOutVO>) processor).replaceBeforeRuleAt(
// new UpdBeforeEventRuleFor4D(), UpdateBeforeEventRule.class);
//2025年6月13日09点38分 -- 物料档案基本页签启用项目辅助属性+库存组织未启用项目，采购入库单保存时（包含接口导入）清除行项目，材料出库单保存时（包含接口导入）清除行项目
processor.addBeforeRule(new MaterialOutProjectRule());
}
@Override
public MaterialOutVO[] update(MaterialOutVO[] vos, MaterialOutVO[] originVOs) {
M4DUpdateBPTempate<MaterialOutVO> updateBP =
new M4DUpdateBPTempate<MaterialOutVO>(BPPlugInPoint.UpdateBP, this);
return updateBP.update(vos, originVOs);
}
}

21
imag/src/public/nc/dto/imag/invoice/PInvoice.java
View File

@ -248,6 +248,11 @@ public class PInvoice extends SuperVO implements Serializable ,IEncode{
private PInvoiceCepz[] cepzs;
private PInvoiceTspz[] tspzs;
// 数电发票是否显示购销方地址电话
private String einvoiceShowGxfDzDh;
// 数电发票是否显示购销方银行、账号
private String einvoiceShowGxfYhZh;
public String getApplyNumber() {
@ -945,6 +950,22 @@ public class PInvoice extends SuperVO implements Serializable ,IEncode{
this.kqysssxbgglbm = kqysssxbgglbm;
}
public String getEinvoiceShowGxfDzDh() {
return einvoiceShowGxfDzDh;
}
public void setEinvoiceShowGxfDzDh(String einvoiceShowGxfDzDh) {
this.einvoiceShowGxfDzDh = einvoiceShowGxfDzDh;
}
public String getEinvoiceShowGxfYhZh() {
return einvoiceShowGxfYhZh;
}
public void setEinvoiceShowGxfYhZh(String einvoiceShowGxfYhZh) {
this.einvoiceShowGxfYhZh = einvoiceShowGxfYhZh;
}
@Override
public String toString() {

84
mmpac/src/private/nc/bs/mmpac/pmo/pac0002/bp/rule/AfterApproveRuleSyncMes.java
View File

@ -7,6 +7,7 @@ import nc.bs.dao.BaseDAO;
import nc.bs.framework.common.NCLocator;
import nc.bs.logging.Log;
import nc.impl.pubapp.pattern.rule.IRule;
import nc.jdbc.framework.SQLParameter;
import nc.jdbc.framework.processor.ColumnProcessor;
import nc.vo.bc.pmpub.project.ProjectHeadVO;
import nc.vo.bd.bom.bom0202.entity.BomVO;
@ -21,6 +22,7 @@ import nc.vo.pub.BusinessException;
import nc.vo.pubapp.pattern.exception.ExceptionUtils;
import nc.vo.pubapp.pattern.pub.SqlBuilder;
import nc.vo.scmpub.util.ArrayUtil;
import nc.vo.so.m30.entity.SaleOrderBVO;
import nc.vo.vorg.DeptVersionVO;
import nccloud.pubift.commen.itf.utils.IHttpPostOtherSys;
@ -202,6 +204,12 @@ public class AfterApproveRuleSyncMes implements IRule<PMOAggVO> {
String vbillcode = head.getVbillcode(); // 单据号
String itemRow = item.getVrowno(); // 行号 obmlog.info("开始为生产订单 " + vbillcode + " 行 " + itemRow + " 构建同步MES数据。");
// 检查是否需要同步到MES系统
if (!shouldSyncToMes(item)) {
obmlog.info("生产订单 " + vbillcode + " 行 " + itemRow + " 不满足同步条件，跳过同步到MES系统。");
return;
}
// orderNo String 是 生产订单号+行号 vbillcode+itemRow
String orderNoWithRow = vbillcode + itemRow;
if (orderNoWithRow.length() > 18) {
@ -425,4 +433,80 @@ public class AfterApproveRuleSyncMes implements IRule<PMOAggVO> {
return field;
}
/**
* 判断是否需要同步到MES系统
* 业务逻辑：
* 1. 通过源头单据类型判断是否为销售订单（源头单据类型为30）
* 2. 如果是销售订单，需要联查销售订单子实体
* 3. 判断销售订单是否有定制标识(vbdef18)
* 4. 如果有定制标识，需要检查工艺配置完成时间(vbdef17)是否有值
* - 有值：传递给MES
* - 无值：不传递给MES
* 5. 如果无定制标识：传递给MES
*
* @param item 生产订单明细
* @return true-需要同步，false-不需要同步
* @throws BusinessException
*/
private boolean shouldSyncToMes(PMOItemVO item) throws BusinessException {
// 检查源头单据类型是否为销售订单（30）
if (!"30".equals(item.getVfirsttype())) {
// 非销售订单来源，直接同步
obmlog.debug("生产订单明细行来源不是销售订单（源头单据类型：" + item.getVfirsttype() + "），允许同步。");
return true;
}
// 是销售订单来源，需要进一步检查
String vfirstbid = item.getVfirstbid(); // 源头单据子表ID
if (StringUtils.isEmpty(vfirstbid)) {
obmlog.warn("生产订单明细行来源为销售订单，但源头单据子表ID为空，默认允许同步。");
return true;
}
try {
// 查询销售订单子实体的定制标识和工艺配置完成时间
SqlBuilder sqlBuilder = new SqlBuilder();
sqlBuilder.append(" SELECT vbdef18, vbdef17 ");
sqlBuilder.append(" FROM so_saleorder_b "); sqlBuilder.append(" WHERE csaleorderbid = ? ");
sqlBuilder.append(" AND dr = 0 ");
SQLParameter sqlParam = new SQLParameter();
sqlParam.addParam(vfirstbid);
SaleOrderBVO saleOrderBVO = (SaleOrderBVO) dao.retrieveByPK(SaleOrderBVO.class, vfirstbid);
if (Objects.isNull(saleOrderBVO)) {
obmlog.warn("未查询到销售订单子实体信息（ID：" + vfirstbid + "），默认允许同步。");
return true;
}
String vbdef18 = saleOrderBVO.getVbdef18();
String vbdef17 = saleOrderBVO.getVbdef17();
obmlog.debug("销售订单定制标识：" + vbdef18 + "，工艺配置完成时间：" + vbdef17);
// 如果无定制标识，允许同步
if (StringUtils.isEmpty(vbdef18)) {
obmlog.debug("销售订单无定制标识，允许同步。");
return true;
}
if ("N".equals(vbdef18)) {
obmlog.debug("销售订单定制标识为N，允许同步。");
return true;
}
// 有定制标识，检查工艺配置完成时间
if (StringUtils.isEmpty(vbdef17)) {
obmlog.info("销售订单有定制标识但工艺配置完成时间为空，不允许同步。");
return false;
} else {
obmlog.debug("销售订单有定制标识且工艺配置完成时间有值，允许同步。");
return true;
}
} catch (Exception e) {
obmlog.error("查询销售订单信息失败：" + e.getMessage(), e);
// 查询失败时，为了避免影响正常业务，默认允许同步
throw new BusinessException("查询销售订单信息失败：" + e.getMessage());
}
}
}

0
mmpsc/src/client/.gitkeep Normal file
View File

0
mmpsc/src/private/.gitkeep Normal file
View File

75
mmpsc/src/private/nc/bs/mmpsc/pscrecive/bp/PscreciveApproveBP.java Normal file
View File

@ -0,0 +1,75 @@
package nc.bs.mmpsc.pscrecive.bp;
import nc.bs.mmpsc.pscrecive.plugin.bpplugin.PscrecivePluginPoint;
import nc.bs.mmpsc.pscrecive.rule.*;
import nc.bs.mmpub.rule.MMVOSagaFrozenValidateRule;
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.mmpsc.pscrecive.entity.AggPscreciveVO;
/**
* 单据审核的BP
*
* @since 6.0
* @version 2014-01-27 15:02:41
* @author computer
*/
public class PscreciveApproveBP {
/**
* 单据的持久化
*
* @param clientBills 单据VO
* @param originBills 原始单据VO
* @return 保存后的单据VO
*/
public AggPscreciveVO[] approve(AggPscreciveVO[] clientBills, AggPscreciveVO[] originBills) {
// 调用修改模板
GCUpdateBPTemplate<AggPscreciveVO> bp = new GCUpdateBPTemplate<AggPscreciveVO>(PscrecivePluginPoint.APPROVE);
// 执行前规则
this.addBeforeRule(bp.getAroundProcesser());
// 执行后规则
this.addAfterRule(bp.getAroundProcesser(), originBills);
return bp.update(clientBills, originBills);
}
/**
* @param processer
* @param originBills
*/
private void addAfterRule(CompareAroundProcesser<AggPscreciveVO> processer, AggPscreciveVO[] originBills) {
// 自动业务关闭工序委外订单
IRule<AggPscreciveVO> closerule = new CloseOrderRule();
processer.addAfterRule(closerule);
//添加审批推送加工费结算单逻辑
IRule<AggPscreciveVO> pushrule = new Push55E6Rule();
processer.addAfterFinalRule(pushrule);
}
/**
* @param processer
*/
private void addBeforeRule(CompareAroundProcesser<AggPscreciveVO> processer) {
// 校验冻结状态 added by zhanghr
IRule<AggPscreciveVO> checkFrozenRule = new MMVOSagaFrozenValidateRule<AggPscreciveVO>(true);
processer.addBeforeRule(checkFrozenRule);
// 检查状态
IRule<AggPscreciveVO> irule = new ApproveBillStatusRule();
processer.addBeforeRule(irule);
// 工序委外订单状态检查规则
IRule<AggPscreciveVO> orderCheckRule = new CheckPscOrderStatusRule();
processer.addBeforeRule(orderCheckRule);
// 补充核销状态
IRule<AggPscreciveVO> vrule = new ApproveVerifyStatusRule();
processer.addBeforeRule(vrule);
// 修改审核信息
IRule<AggPscreciveVO> frule = new FillApprovePsnRule();
processer.addBeforeRule(frule);
// 更新审核状态
IRule<AggPscreciveVO> updaterule = new ApproveStatusUpdateRule();
processer.addBeforeRule(updaterule);
}
}

144
mmpsc/src/private/nc/bs/mmpsc/pscrecive/bp/PscreciveAutoApproveBP.java Normal file
View File

@ -0,0 +1,144 @@
package nc.bs.mmpsc.pscrecive.bp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import nc.bs.mmpsc.pscrecive.plugin.bpplugin.PscrecivePluginPoint;
import nc.bs.mmpsc.pscrecive.rule.*;
import nc.bs.mmpub.rule.MMVOSagaFrozenValidateRule;
import nc.impl.pubapp.pattern.rule.IRule;
import nc.impl.pubapp.pattern.rule.processer.CompareAroundProcesser;
import nc.util.mmf.framework.base.MMArrayUtil;
import nc.util.mmf.framework.base.MMVOUtil;
import nc.util.mmf.framework.gc.GCUpdateBPTemplate;
import nc.vo.mmpsc.pscrecive.entity.AggPscreciveVO;
import nc.vo.mmpsc.pscrecive.entity.PscReciveTransTypeVO;
import nc.vo.mmpsc.pscrecive.util.QueryUtil;
import nc.vo.mmpsc.pscrecive.util.VOChangUtil;
/**
* 收货单自动审核的BP
*
* @since 6.0
* @version 2014-01-27 15:02:41
* @author computer
*/
public class PscreciveAutoApproveBP {
/**
* 单据的持久化
*
* @param clientBills 单据VO
* @param originBills 原始单据VO
* @return 保存后的单据VO
*/
public AggPscreciveVO[] approve(AggPscreciveVO[] clientBills) {
AggPscreciveVO[] approveVOs = this.filterAutoApprove(clientBills);
if (MMArrayUtil.isEmpty(approveVOs)) {
return clientBills;
}
AggPscreciveVO[] originBills = VOChangUtil.clone(approveVOs);
// 调用修改模板
GCUpdateBPTemplate<AggPscreciveVO> bp = new GCUpdateBPTemplate<AggPscreciveVO>(PscrecivePluginPoint.APPROVE);
// 执行前规则
this.addBeforeRule(bp.getAroundProcesser());
// 执行后规则
this.addAfterRule(bp.getAroundProcesser(), originBills);
AggPscreciveVO[] returnBills = bp.update(clientBills, originBills);
return new QueryUtil().queryAfterUpdate(returnBills);
}
/**
* @param processer
* @param originBills
*/
private void addAfterRule(CompareAroundProcesser<AggPscreciveVO> processer, AggPscreciveVO[] originBills) {
//暂时没有规则
//添加审批推送加工费结算单逻辑
IRule<AggPscreciveVO> pushrule = new Push55E6Rule();
processer.addAfterFinalRule(pushrule);
}
/**
* @param processer
*/
private void addBeforeRule(CompareAroundProcesser<AggPscreciveVO> processer) {
// 校验冻结状态 added by zhanghr
IRule<AggPscreciveVO> checkFrozenRule = new MMVOSagaFrozenValidateRule<AggPscreciveVO>(true);
processer.addBeforeRule(checkFrozenRule);
// 检查状态
IRule<AggPscreciveVO> irule = new ApproveBillStatusRule();
processer.addBeforeRule(irule);
// 补充核销状态
IRule<AggPscreciveVO> vrule = new ApproveVerifyStatusRule();
processer.addBeforeRule(vrule);
// 修改审核信息
IRule<AggPscreciveVO> frule = new FillApprovePsnRule();
processer.addBeforeRule(frule);
// 更新审核状态
IRule<AggPscreciveVO> updaterule = new ApproveStatusUpdateRule();
processer.addBeforeRule(updaterule);
// 自动业务关闭工序委外订单
IRule<AggPscreciveVO> closerule = new CloseOrderRule();
processer.addBeforeRule(closerule);
}
/**
* 过滤出需要自动审核
*
* @param nowBills
* @return
*/
private AggPscreciveVO[] filterAutoApprove(AggPscreciveVO[] nowBills) {
if (nowBills == null || nowBills.length == 0) {
return null;
}
List<String> typeid = new ArrayList<String>();
for (AggPscreciveVO bill : nowBills) {
typeid.add(bill.getHeadVO().getCtrantype());
}
// 查询哪些交易类型需要自动审核
Map<String, Boolean> autoMap = this.isAutoApprove(typeid.toArray(new String[0]));
// 过滤
List<AggPscreciveVO> reList = new ArrayList<AggPscreciveVO>();
for (AggPscreciveVO bill : nowBills) {
Boolean is = autoMap.get(bill.getHeadVO().getCtrantype());
if (is != null && is.booleanValue()) {
reList.add(bill);
}
}
if (reList.size() > 0) {
return reList.toArray(new AggPscreciveVO[0]);
}
return null;
}
/**
* 是否自动审核
*
* @param ids
* @return
*/
private Map<String, Boolean> isAutoApprove(String[] ids) {
// 查询
PscReciveTransTypeVO[] types = MMVOUtil.query(PscReciveTransTypeVO.class, PscReciveTransTypeVO.CTRANTYPEID, ids);
Map<String, Boolean> map = new HashMap<String, Boolean>();
if (MMArrayUtil.isEmpty(types)) {
return map;
}
// 构造结果
for (PscReciveTransTypeVO type : types) {
if (type.getBautoapprove() != null && type.getBautoapprove().booleanValue()) {
map.put(type.getCtrantypeid(), Boolean.TRUE);
}
else {
map.put(type.getCtrantypeid(), Boolean.FALSE);
}
}
return map;
}
}

126
mmpsc/src/private/nc/bs/mmpsc/pscrecive/rule/Push55E6Rule.java Normal file
View File

@ -0,0 +1,126 @@
package nc.bs.mmpsc.pscrecive.rule;
import nc.bs.framework.common.NCLocator;
import nc.impl.pubapp.pattern.rule.IRule;
import nc.itf.mmpsc.pscsettle.ISettleMaintain;
import nc.itf.uap.pf.IPfExchangeService;
import nc.util.mmf.framework.base.MMArrayUtil;
import nc.util.mmf.framework.base.MMNumberUtil;
import nc.vo.mmpsc.pscrecive.entity.AggPscreciveVO;
import nc.vo.mmpsc.pscrecive.entity.PscreciveItemVO;
import nc.vo.mmpsc.pscrecive.entity.PscreciveQcVO;
import nc.vo.mmpsc.pscrecive.enumeration.PscReciveProcessMethodEnum;
import nc.vo.mmpsc.pscrecive.enumeration.PscReciveStatusEnum;
import nc.vo.mmpsc.pscsettle.entity.AggSettleVO;
import nc.vo.mmpsc.pscsettle.entity.SettleHeadVO;
import nc.vo.mmpsc.pscsettle.entity.SettleItemVO;
import nc.vo.pub.compiler.PfParameterVO;
import nc.vo.pub.lang.UFDouble;
import nc.vo.pubapp.pattern.exception.ExceptionUtils;
import java.util.ArrayList;
import java.util.List;
/**
* @Classname Push55E6Rule
* @Description TODO
* @Version 1.0.0
* @Date 2025/6/16 14:40
* @Created by ame
*/
public class Push55E6Rule implements IRule<AggPscreciveVO> {
@Override
public void process(AggPscreciveVO[] aggvos) {
if(aggvos==null || aggvos.length<1){
return;
}
ISettleMaintain service = NCLocator.getInstance().lookup(ISettleMaintain.class);
try {
AggPscreciveVO[] newAggvos = this.fiterData(aggvos);
if(newAggvos!=null && newAggvos.length>0){
IPfExchangeService ef = NCLocator.getInstance().lookup(IPfExchangeService.class);
AggSettleVO[] aggSettleVOs = (AggSettleVO[])ef.runChangeDataAryNeedClassify("55E5", "55E6", newAggvos, (PfParameterVO)null, 1);
if (aggSettleVOs != null && aggSettleVOs.length > 0) {
this.fillData(aggSettleVOs);
service.insertSettle(aggSettleVOs);
}
}
} catch (Exception e) {
ExceptionUtils.wrappBusinessException(e.getMessage());
}
}
private void fillData(AggSettleVO[] aggSettleVOs) {
for (AggSettleVO aggSettleVO : aggSettleVOs) {
SettleHeadVO headVO = aggSettleVO.getHeadVO();
SettleItemVO[] itemVO = aggSettleVO.getItemVO();
headVO.setStatus(2);
headVO.setFstatusflag(1);
//itemVOµÄvrowno¸ù¾ÝÐòºÅÉèÖÃÖµ£ºi*10
for (int i = 0; i < itemVO.length; i++) {
itemVO[i].setStatus(2);
itemVO[i].setVrowno(String.valueOf((i+1) * 10));
}
}
}
private AggPscreciveVO[] fiterData(AggPscreciveVO[] aggPscreciveVOs) {
AggPscreciveVO[] statusvos = this.fiterDataStatus(aggPscreciveVOs);
AggPscreciveVO[] qcvos = this.fiterDataQc(statusvos);
return qcvos;
}
private AggPscreciveVO[] fiterDataStatus(AggPscreciveVO[] vos) {
List<AggPscreciveVO> aggPscreciveVOs = new ArrayList<AggPscreciveVO>();
for (AggPscreciveVO aggPscreciveVO : vos) {
if (PscReciveStatusEnum.APPROVED.equalsValue(aggPscreciveVO.getHeadVO().getFstatusflag())) {
aggPscreciveVOs.add(aggPscreciveVO);
}
}
return aggPscreciveVOs.toArray(new AggPscreciveVO[aggPscreciveVOs.size()]);
}
private AggPscreciveVO[] fiterDataQc(AggPscreciveVO[] vos) {
if (MMArrayUtil.isEmpty(vos)) {
return null;
}
List<AggPscreciveVO> aggPscreciveVOs = new ArrayList<AggPscreciveVO>();
for (AggPscreciveVO aggPscreciveVO : vos) {
List<PscreciveItemVO> pscreciveItemVOs = new ArrayList<PscreciveItemVO>();
for (PscreciveItemVO pscreciveItemVO : aggPscreciveVO.getItemVO()) {
PscreciveQcVO[] pscreciveQcVOs = pscreciveItemVO.getCpscrecive_qcid();
if (MMArrayUtil.isNotEmpty(pscreciveQcVOs)) {
UFDouble sumNum = UFDouble.ZERO_DBL;
UFDouble sumAstNum = UFDouble.ZERO_DBL;
for (PscreciveQcVO pscreciveQcVO : pscreciveQcVOs) {
if (PscReciveProcessMethodEnum.PRODIN.equalsValue(pscreciveQcVO.getFqprocessmethod())
|| PscReciveProcessMethodEnum.MATERREJECT
.equalsValue(pscreciveQcVO.getFqprocessmethod())
|| PscReciveProcessMethodEnum.REWORK.equalsValue(pscreciveQcVO.getFqprocessmethod())) {
sumNum = MMNumberUtil.add(sumNum, pscreciveQcVO.getNqnum());
sumAstNum = MMNumberUtil.add(sumAstNum, pscreciveQcVO.getNqastnum());
}
}
if (MMNumberUtil.isGtZero(sumNum) && MMNumberUtil.isGtZero(sumAstNum)) {
pscreciveItemVO.setProcessastnum(sumAstNum);
pscreciveItemVO.setProcessnum(sumNum);
pscreciveItemVOs.add(pscreciveItemVO);
}
} else if (aggPscreciveVO.getHeadVO().getBreturn() != null
&& aggPscreciveVO.getHeadVO().getBreturn().booleanValue()) {
pscreciveItemVO.setProcessastnum(MMNumberUtil.toNegValue(pscreciveItemVO.getNbastrecivenum()));
pscreciveItemVO.setProcessnum(MMNumberUtil.toNegValue(pscreciveItemVO.getNbrecivenum()));
pscreciveItemVOs.add(pscreciveItemVO);
}
}
if (pscreciveItemVOs.size() > 0) {
aggPscreciveVO.setChildrenVO(pscreciveItemVOs.toArray(new PscreciveItemVO[0]));
aggPscreciveVOs.add(aggPscreciveVO);
}
}
return aggPscreciveVOs.toArray(new AggPscreciveVO[aggPscreciveVOs.size()]);
}
}

0
mmpsc/src/public/.gitkeep Normal file
View File

0
mmpsc/src/test/.gitkeep Normal file
View File

8
so/src/private/nccloud/api/impl/so/m30/APISaleOrderMaitainImpl.java
View File

@ -719,10 +719,14 @@ public class APISaleOrderMaitainImpl implements IAPISaleOrderMaitain {
targetBVO.setVbdef18(sourceBVO.getVbdef18()); // 是否定制
targetBVO.setVbdef19(sourceBVO.getVbdef19()); // 计划开工日期
targetBVO.setVbdef20(sourceBVO.getVbdef20()); // 计划完工日期
targetBVO.setVbdef14(sourceBVO.getVbdef14()); // 合同销售订单变更明细id
targetBVO.setCrowno(sourceBVO.getCrowno()); // 行号
if (StringUtils.isNotEmpty(sourceBVO.getVbdef19())) {
targetBVO.setVbdef19(sourceBVO.getVbdef19()); // 计划开工日期
}
if (StringUtils.isNotEmpty(sourceBVO.getVbdef20())) {
targetBVO.setVbdef20(sourceBVO.getVbdef20()); // 计划完工日期
}
}

511
sscivm/src/public/nc/bs/sscivm/ivsale/util/InvoiceTransferUtil.java
View File

File diff suppressed because it is too large Load Diff

231
uapbd/src/client/nccloud/web/uapbd/customer/baseinfo/action/CustomerSaveAction.java
View File

@ -1,231 +0,0 @@
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package nccloud.web.uapbd.customer.baseinfo.action;
import com.alibaba.fastjson.JSONObject;
import nc.bs.dao.BaseDAO;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.bs.uif2.LockFailedException;
import nc.bs.uif2.VersionConflictException;
import nc.itf.bd.cust.assign.ICustAssignService;
import nc.itf.bd.cust.baseinfo.ICustBaseInfoQueryService;
import nc.itf.bd.cust.baseinfo.ICustBaseInfoService;
import nc.itf.uap.IUAPQueryBS;
import nc.jdbc.framework.processor.MapProcessor;
import nc.uap.utils.ResHelper;
import nc.vo.bd.cust.*;
import nc.vo.bd.supplier.SupplierVO;
import nc.vo.ml.NCLangRes4VoTransl;
import nc.vo.org.OrgVO;
import nc.vo.pub.BusinessException;
import nc.vo.pub.SuperVO;
import nc.vo.pub.lang.UFDateTime;
import nccloud.commons.lang.StringUtils;
import nccloud.framework.core.exception.ExceptionUtils;
import nccloud.framework.service.ServiceLocator;
import nccloud.framework.web.action.itf.ICommonAction;
import nccloud.framework.web.container.IRequest;
import nccloud.framework.web.json.JsonFactory;
import nccloud.framework.web.processor.template.ExtBillCardConvertProcessor;
import nccloud.framework.web.ui.model.row.Row;
import nccloud.framework.web.ui.pattern.billcard.ExtSpecilAggBill;
import nccloud.framework.web.ui.pattern.extbillcard.ExtBillCard;
import nccloud.framework.web.ui.pattern.extbillcard.ExtBillCardOperator;
import nccloud.framework.web.ui.pattern.grid.Grid;
import nccloud.web.uapbd.customer.baseinfo.utils.CustSupExceptionHandle;
import nccloud.web.uapbd.customer.baseinfo.utils.CustomerExtendAggBill;
import nccloud.web.uapbd.customer.baseinfo.utils.CustomerResultMessage;
import nccloud.web.uapbd.customer.baseinfo.utils.CustomerService;
import nccloud.web.uapbd.supplier.supplier.action.SupplierCommonUtil;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.*;
public class CustomerSaveAction implements ICommonAction {
public CustomerSaveAction() {
}
public Object doAction(IRequest request) {
CustomerExtendAggBill fromJson = (CustomerExtendAggBill) JsonFactory.create().fromJson(request.read(), CustomerExtendAggBill.class);
ExtBillCard extspecilAggBill = fromJson.getExtspecilAggBill();
String step = fromJson.getStep();
boolean checkflag = fromJson.isCheckflag();
boolean createVersion = fromJson.isCreateversion();
String pagecode = fromJson.getPagecode();
List<String> exceptAreas = new ArrayList();
exceptAreas.add("custAddress");
exceptAreas.add("custBankaccbas");
exceptAreas.add("10140LM");
exceptAreas.add("customerassign_list");
exceptAreas.add("cust_sale_simple");
exceptAreas.add("cust_creditctl_simple");
exceptAreas.add("cust_finance_simple");
exceptAreas.add("customer_list_checkbyorg");
exceptAreas.add("versionList");
ExtBillCardConvertProcessor ebcp = new ExtBillCardConvertProcessor(exceptAreas);
ExtBillCardOperator ec = new ExtBillCardOperator(pagecode);
new CustomerResultMessage();
ExtBillCard ebc = null;
ExtSpecilAggBill bill = (ExtSpecilAggBill) ebcp.fromExtBillCard(extspecilAggBill);
CustomerVO customerVO = (CustomerVO) bill.getHead();
CustlinkmanVO[] custlikCustlinkmanVOs = (CustlinkmanVO[]) bill.getBodys(CustlinkmanVO.class);
CustCountrytaxesVO[] custCountrytaxesVOs = (CustCountrytaxesVO[]) bill.getBodys(CustCountrytaxesVO.class);
customerVO.setCustcontacts(custlikCustlinkmanVOs);
customerVO.setCusttaxtypes(custCountrytaxesVOs);
if ("2".equals(customerVO.getCalibrationstate()) && customerVO.getLatestcaltime() == null) {
customerVO.setLatestcaltime(new UFDateTime());
}
if (!SupplierCommonUtil.checkRegisterfund(customerVO.getRegisterfund())) {
ExceptionUtils.wrapBusinessException(NCLangRes4VoTransl.getNCLangRes().getStrByID("nccriauapbd0", "0nccriauapbd00466"));
}
CustomerService cs = new CustomerService();
try {
if (StringUtils.isNotBlank(step) && "one".equals(step)) {
if (createVersion) {
customerVO = ((ICustBaseInfoService) ServiceLocator.find(ICustBaseInfoService.class)).createCustomerVersion(customerVO);
} else if (StringUtils.isNotBlank(customerVO.getPk_customer())) {
CustomerVO[] temp = ((ICustBaseInfoQueryService) ServiceLocator.find(ICustBaseInfoQueryService.class)).queryDataByPkSet(new String[]{customerVO.getPk_customer()});
if (temp == null || temp.length == 0) {
ExceptionUtils.wrapException(new BusinessException("没有找到对应的客户信息"));
}
customerVO = cs.updateCustomer(customerVO, checkflag);
} else {
if (customerVO.getCustcontacts() != null && customerVO.getCustcontacts().length > 0) {
for (CustlinkmanVO custlinkmanvo : customerVO.getCustcontacts()) {
custlinkmanvo.setPk_customer((String) null);
}
}
if (customerVO.getCusttaxtypes() != null && customerVO.getCusttaxtypes().length > 0) {
for (CustCountrytaxesVO custCountrytaxesVO : customerVO.getCusttaxtypes()) {
custCountrytaxesVO.setPk_customer((String) null);
}
}
if (fromJson.getCopy_pk_customer() != null) {
customerVO = cs.insertCustomerVO(customerVO, checkflag);
((ICustAssignService) ServiceLocator.find(ICustAssignService.class)).copyCustomerAssignData(customerVO, fromJson.getCopy_pk_customer());
} else {
customerVO = cs.insertCustomerVO(customerVO, checkflag);
}
}
}
if (StringUtils.isNotBlank(step) && "two_yes".equals(step)) {
SupplierVO supplierVO = fromJson.getSupplierVO();
if (StringUtils.isNotBlank(customerVO.getPk_customer())) {
customerVO = cs.updateCustomerAndRelaToSup(customerVO, supplierVO);
} else {
Map<String, SuperVO> resultMap = cs.insertCustAndRelaToSup(customerVO, supplierVO);
customerVO = (CustomerVO) resultMap.get("customer");
}
}
if (StringUtils.isNotBlank(step) && "two_no".equals(step)) {
if (StringUtils.isNotBlank(customerVO.getPk_customer())) {
customerVO = cs.updateCustomer(customerVO, checkflag);
} else {
customerVO = cs.insertCustomerVO(customerVO, checkflag);
}
}
bill.putvo(CustlinkmanVO.class, customerVO.getCustcontacts());
customerVO.setCustcontacts((CustlinkmanVO[]) null);
bill.putvo(CustbankVO.class, customerVO.getCustbanks());
customerVO.setCustbanks((CustbankVO[]) null);
bill.putvo(CustCountrytaxesVO.class, customerVO.getCusttaxtypes());
customerVO.setCusttaxtypes((CustCountrytaxesVO[]) null);
bill.setHead(customerVO);
ec.setTransFlag(true);
ebc = ec.toCard(bill, exceptAreas);
Grid grid = ebc.getBody("custtaxtypes");
if (grid != null) {
List<Row> listRows = grid.getModel().getListRows();
Map<String, String> executeQuery = null;
if (listRows != null && listRows.size() > 0) {
for (Row row : listRows) {
if (row.getCell("pk_taxes").getValue() != null) {
String value = row.getCell("pk_taxes").getValue().toString();
executeQuery = (Map) ((IUAPQueryBS) ServiceLocator.find(IUAPQueryBS.class)).executeQuery("select custtaxesname from bd_custaxes where pk_custaxes = '" + value + "'", new MapProcessor());
row.getCell("pk_taxes").setDisplay(executeQuery != null ? (String) executeQuery.get("custtaxesname") : "");
}
}
}
}
// 自动分配组织
/*String[] customerPks = {customerVO.getPk_customer()};
OrgVO[] virtulaOrg = getVirtulaOrg();
String[] assignOrgPks = Arrays.stream(virtulaOrg).map(OrgVO::getPk_org).toArray(String[]::new);
ErrLogReturnValue errLogReturnValue = cs.getAssignService().assignCustomerByPks(customerPks, assignOrgPks, null);
Logger.error("CustomerSaveAction-errLogReturnValue = " + errLogReturnValue.getErrLogResult());*/
assignOrgApi(customerVO);
} catch (Exception e) {
if (e instanceof UndeclaredThrowableException) {
Throwable undeclaredThrowable = ((UndeclaredThrowableException) e).getUndeclaredThrowable();
InvocationTargetException ie = (InvocationTargetException) undeclaredThrowable;
Throwable targetException = ie.getTargetException();
if (targetException instanceof CustSupBusiException) {
CustSupBusiException cuBusiException = (CustSupBusiException) targetException;
CustomerResultMessage crm = CustSupExceptionHandle.handleCustSupException(cuBusiException);
return crm;
}
if (targetException instanceof VersionConflictException) {
VersionConflictException versionConflictException = (VersionConflictException) targetException;
Object busiObject = versionConflictException.getBusiObject();
ExceptionUtils.wrapBusinessException(ResHelper.getString("nccriauapbd0", "0nccriauapbd00030"));
} else if (targetException instanceof LockFailedException) {
ExceptionUtils.wrapBusinessException(ResHelper.getString("nccriauapbd0", "0nccriauapbd00030"));
} else {
ExceptionUtils.wrapException(targetException);
}
} else {
ExceptionUtils.wrapException(e);
}
}
return ebc;
}
public void assignOrgApi(CustomerVO customerVO) throws BusinessException {
String[] customerPks = {customerVO.getCode()};
OrgVO[] virtulaOrg = getVirtulaOrg();
String[] assignOrgPks = Arrays.stream(virtulaOrg).map(OrgVO::getCode).toArray(String[]::new);
JSONObject param = new JSONObject();
JSONObject ufinterfaceJson = new JSONObject();
JSONObject dataJson = new JSONObject();
dataJson.put("customer", customerPks);
dataJson.put("org", assignOrgPks);
ufinterfaceJson.put("sender", "default");
ufinterfaceJson.put("data", dataJson);
param.put("ufinterface", ufinterfaceJson);
BaseOpenApiReq req = new BaseOpenApiReq();
req.assignOrgApi("/nccloud/api/uapbd/customermanageext/customer/assign", param);
}
/**
* 查询组织信息
*
* @author mzr
* @date 2025/05/29
*/
public OrgVO[] getVirtulaOrg() throws BusinessException {
String groupID = InvocationInfoProxy.getInstance().getGroupId();
// NCCForUAPLogger.debug("groupID = " + groupID);
// enablestate 启用状态 isbusinessunit 是否业务单元数据
String condition = "pk_group = '" + groupID + "' and ENABLESTATE = '2' and isbusinessunit='Y'";
Collection<OrgVO> collection = (new BaseDAO()).retrieveByClause(OrgVO.class, condition, "code");
return collection.toArray(new OrgVO[0]);
}
}

158
uapbd/src/client/nccloud/web/uapbd/customer/baseinfo/action/CustomerSaveAddAction.java
View File

@ -1,158 +0,0 @@
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package nccloud.web.uapbd.customer.baseinfo.action;
import com.alibaba.fastjson.JSONObject;
import nc.bs.dao.BaseDAO;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.bs.logging.Logger;
import nc.itf.bd.cust.baseinfo.ICustBaseInfoService;
import nc.pub.billcode.itf.IBillcodeManage;
import nc.pub.billcode.vo.BillCodeContext;
import nc.vo.bd.cust.CustCountrytaxesVO;
import nc.vo.bd.cust.CustlinkmanVO;
import nc.vo.bd.cust.CustomerVO;
import nc.vo.bd.errorlog.ErrLogReturnValue;
import nc.vo.org.OrgVO;
import nc.vo.pub.BusinessException;
import nc.vo.pub.lang.UFBoolean;
import nc.vo.pub.lang.UFDateTime;
import nccloud.framework.core.exception.ExceptionUtils;
import nccloud.framework.web.action.itf.ICommonAction;
import nccloud.framework.web.container.IRequest;
import nccloud.framework.web.container.SessionContext;
import nccloud.framework.web.ui.pattern.billcard.ExtSpecilAggBill;
import nccloud.framework.web.ui.pattern.extbillcard.ExtBillCard;
import nccloud.framework.web.ui.pattern.extbillcard.ExtBillCardOperator;
import nccloud.web.uapbd.customer.baseinfo.utils.CustomerService;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class CustomerSaveAddAction implements ICommonAction {
public CustomerSaveAddAction() {
}
public Object doAction(IRequest request) {
ExtBillCardOperator ec = new ExtBillCardOperator();
List<String> exceptAreas = new ArrayList();
exceptAreas.add("custAddress");
exceptAreas.add("custBankaccbas");
exceptAreas.add("10140LM");
exceptAreas.add("customerassign_list");
exceptAreas.add("cust_sale_simple");
exceptAreas.add("cust_creditctl_simple");
exceptAreas.add("cust_finance_simple");
exceptAreas.add("customer_list_checkbyorg");
ExtSpecilAggBill bill = (ExtSpecilAggBill) ec.toBill(request);
ExtBillCard ebc = null;
CustomerVO customerVO = (CustomerVO) bill.getHead();
CustlinkmanVO[] custlikCustlinkmanVOs = (CustlinkmanVO[]) bill.getBodys(CustlinkmanVO.class);
CustCountrytaxesVO[] custCountrytaxesVOs = (CustCountrytaxesVO[]) bill.getBodys(CustCountrytaxesVO.class);
if (custlikCustlinkmanVOs != null && custlikCustlinkmanVOs.length > 0) {
for (CustlinkmanVO custlinkmanvo : custlikCustlinkmanVOs) {
custlinkmanvo.setPk_customer((String) null);
}
}
if (custCountrytaxesVOs != null && custCountrytaxesVOs.length > 0) {
for (CustCountrytaxesVO custCountrytaxesVO : custCountrytaxesVOs) {
custCountrytaxesVO.setPk_customer((String) null);
}
}
customerVO.setCustcontacts(custlikCustlinkmanVOs);
customerVO.setCusttaxtypes(custCountrytaxesVOs);
if ("2".equals(customerVO.getCalibrationstate()) && customerVO.getLatestcaltime() == null) {
customerVO.setLatestcaltime(new UFDateTime());
}
CustomerService cs = new CustomerService();
ICustBaseInfoService getiCustBaseInfoService = cs.getiCustBaseInfoService();
IBillcodeManage billcodeManage = cs.getBillcodeManage();
String pk_group = SessionContext.getInstance().getClientInfo().getPk_group();
String billcode = "";
try {
customerVO.setIssupplier(UFBoolean.FALSE);
customerVO.setCuststate(1);
customerVO.setFrozenflag(UFBoolean.FALSE);
customerVO.setIsfreecust(UFBoolean.FALSE);
customerVO.setPk_group(pk_group);
customerVO.setPk_org(pk_group);
customerVO = getiCustBaseInfoService.insertCustomerVO(customerVO, false);
CustomerVO saveAddRe = new CustomerVO();
BillCodeContext billCodeContext = billcodeManage.getBillCodeContext("customer", pk_group, pk_group);
if (billCodeContext != null && billCodeContext.isPrecode()) {
billcode = billcodeManage.getPreBillCode_RequiresNew("customer", pk_group, pk_group);
}
saveAddRe.setCode(billcode);
saveAddRe.setIssupplier(UFBoolean.FALSE);
saveAddRe.setCuststate(1);
saveAddRe.setFrozenflag(UFBoolean.FALSE);
saveAddRe.setPk_country("0001Z010000000079UJJ");
saveAddRe.setPk_format("FMT0Z000000000000000");
saveAddRe.setPk_timezone("0001Z010000000079U2P");
saveAddRe.setIsfreecust(UFBoolean.FALSE);
saveAddRe.setPk_org(customerVO.getPk_org());
saveAddRe.setPk_group(customerVO.getPk_group());
bill.putvo(CustlinkmanVO.class, new CustlinkmanVO[0]);
bill.putvo(CustCountrytaxesVO.class, new CustCountrytaxesVO[0]);
bill.setHead(saveAddRe);
ebc = ec.toCard(bill, exceptAreas);
ec.setTransFlag(true);
ebc.setUserjson(billCodeContext == null ? "" : "" + billCodeContext.isEditable());
// 自动分配组织
/*String[] customerPks = {customerVO.getPk_customer()};
OrgVO[] virtulaOrg = getVirtulaOrg();
String[] assignOrgPks = Arrays.stream(virtulaOrg).map(OrgVO::getPk_org).toArray(String[]::new);
ErrLogReturnValue errLogReturnValue = cs.getAssignService().assignCustomerByPks(customerPks, assignOrgPks, null);
Logger.error("CustomerSaveAddAction-errLogReturnValue = " + errLogReturnValue.getErrLogResult());*/
assignOrgApi(customerVO);
} catch (BusinessException e) {
ExceptionUtils.wrapException(e);
}
return ebc;
}
public void assignOrgApi(CustomerVO customerVO) throws BusinessException {
String[] customerPks = {customerVO.getCode()};
OrgVO[] virtulaOrg = getVirtulaOrg();
String[] assignOrgPks = Arrays.stream(virtulaOrg).map(OrgVO::getCode).toArray(String[]::new);
JSONObject param = new JSONObject();
JSONObject ufinterfaceJson = new JSONObject();
JSONObject dataJson = new JSONObject();
dataJson.put("customer", customerPks);
dataJson.put("org", assignOrgPks);
ufinterfaceJson.put("sender", "default");
ufinterfaceJson.put("data", dataJson);
param.put("ufinterface", ufinterfaceJson);
BaseOpenApiReq req = new BaseOpenApiReq();
req.assignOrgApi("/nccloud/api/uapbd/customermanageext/customer/assign", param);
}
/**
* 查询组织信息
*
* @author mzr
* @date 2025/05/29
*/
public OrgVO[] getVirtulaOrg() throws BusinessException {
String groupID = InvocationInfoProxy.getInstance().getGroupId();
// NCCForUAPLogger.debug("groupID = " + groupID);
// enablestate 启用状态 isbusinessunit 是否业务单元数据
String condition = "pk_group = '" + groupID + "' and ENABLESTATE = '2' and isbusinessunit='Y'";
Collection<OrgVO> collection = (new BaseDAO()).retrieveByClause(OrgVO.class, condition, "code");
return collection.toArray(new OrgVO[0]);
}
}

273
uapbd/src/private/nc/bs/bd/bom/bom0202/bp/BomInsertBP.java Normal file
View File

@ -0,0 +1,273 @@
package nc.bs.bd.bom.bom0202.bp;
import nc.bs.bd.bom.bom0202.plugin.bpplugin.BomPluginPoint;
import nc.bs.bd.bom.bom0202.rule.*;
import nc.bs.mmbd.pub.rule.MMAutoMaterialAssignRule;
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.material.assistant.MarAssistantSaveRule;
import nc.impl.pubapp.pattern.rule.IRule;
import nc.impl.pubapp.pattern.rule.processer.AroundProcesser;
import nc.itf.org.IOrgConstBasic;
import nc.util.mmf.busi.rule.MMRowNoCheckRule;
import nc.util.mmf.framework.gc.GCInsertBPTemplate;
import nc.vo.bd.bom.bom0202.entity.AggBomVO;
import nc.vo.bd.bom.bom0202.entity.BomActivityVO;
import nc.vo.bd.bom.bom0202.entity.BomItemVO;
import nc.vo.bd.bom.bom0202.entity.BomOutputsVO;
import nc.vo.bd.bom.bom0202.entity.BomPosVO;
import nc.vo.bd.bom.bom0202.entity.BomReplVO;
import nc.vo.bd.bom.bom0202.entity.BomVO;
import nc.vo.bd.bom.bom0202.entity.BomWipVO;
public class BomInsertBP {
/**
* 是否校验工程变更单是否启用
*/
private boolean checkEcn = true;
/**
* 是否支持审批流
*/
private boolean isOnApprove;
public boolean isOnApprove() {
return this.isOnApprove;
}
public void setOnApprove(boolean isOnApprove) {
this.isOnApprove = isOnApprove;
}
public AggBomVO[] insert(AggBomVO[] aggVO) {
return this.insert(aggVO, true);
}
/**
* 跨组织复制时，原bom主键
*/
private String[] origins = null;
/**
* 带参数的BOM新增插入方法
*
* @param aggVO
* @param newCheckEcn
* @return
*/
public AggBomVO[] insert(AggBomVO[] aggVO, boolean newCheckEcn) {
return this.insert(aggVO, newCheckEcn, null, false);
}
/**
* 带参数的BOM新增插入方法
*
* @param aggVO
* @param newCheckEcn
* @param orgins 跨组织复制原bom主键
* @param param 无效参数，占位
* @return
*/
public AggBomVO[] insert(AggBomVO[] aggVO, boolean newCheckEcn, String[] origins, boolean param) {
this.setCheckEcn(newCheckEcn);
if (origins != null) {
this.setOrigins(origins);
}
GCInsertBPTemplate<AggBomVO> bp = new GCInsertBPTemplate<AggBomVO>(BomPluginPoint.INSERT);
// 执行前规则
this.addBeforeRule(bp.getAroundProcesser());
// 执行后规则
this.addAfterRule(bp.getAroundProcesser());
AggBomVO[] returnvo = bp.insert(aggVO);
return returnvo;
}
/**
* 带参的新增方法：是否支持ECN，是否支持审批流
*
* @param aggVO
* @param isCheckEcn
* @param isOnApprove
* @return
*/
public AggBomVO[] insert(AggBomVO[] aggVO, boolean isCheckEcn, boolean isOnApprove) {
this.setCheckEcn(isCheckEcn);
this.setOnApprove(isOnApprove);
GCInsertBPTemplate<AggBomVO> bp = new GCInsertBPTemplate<AggBomVO>(BomPluginPoint.INSERT);
// 执行前规则
this.addBeforeRule(bp.getAroundProcesser());
// 执行后规则
this.addAfterRule(bp.getAroundProcesser());
AggBomVO[] returnvo = bp.insert(aggVO);
return returnvo;
}
/**
* 新增前规则
*
* @param processor
*/
@SuppressWarnings("unchecked")
private void addBeforeRule(AroundProcesser<AggBomVO> processer) {
// 补充默认值规则
IRule<AggBomVO> rule = new FillInsertDataRule();
processer.addBeforeRule(rule);
// 组织停用校验
rule = new OrgDisabledCheckRule(BomVO.PK_ORG, IOrgConstBasic.PRODUCEPLANTYPE);
processer.addBeforeRule(rule);
if (this.getCheckEcn()) {
// 是否启用工程变更校验
rule = new ECNOrgEnableCheckRule();
processer.addBeforeRule(rule);
}
if (!this.getCheckEcn()) {
// 数据检查并设置默认值
rule = new BomSaveDataCheckRule();
processer.addBeforeRule(rule);
} else {
// 数据检查并设置默认值
rule = new BomSaveDataCheckRule(this.getCheckEcn());
processer.addBeforeRule(rule);
}
// 行号检查
rule = new MMRowNoCheckRule<AggBomVO>();
processer.addBeforeRule(rule);
// 物料信息检查
rule = new BomMaterialCheckRule();
processer.addBeforeRule(rule);
// 长度检查
rule = new FieldLengthCheckRule();
processer.addBeforeRule(rule);
// bom自定义项检查
String[] prefixs = new String[] { "hvdef", "vdef", "vbdef", "vdef", "vdef", "vdef", "vdef" };
Class<?>[] voClasses = new Class<?>[] { BomVO.class, BomItemVO.class, BomOutputsVO.class, BomActivityVO.class,
BomWipVO.class, BomPosVO.class, BomReplVO.class };
rule = new nc.impl.pubapp.bd.userdef.UserDefSaveRule<AggBomVO>(prefixs, voClasses);
processer.addBeforeRule(rule);
// 检查自由项
rule = new MarAssistantSaveRule<AggBomVO>();
processer.addBeforeRule(rule);
// delete by qianzhx
// BOM在非审批通过态可以支持存在多个默认 20150425
// BOM默认版本规则
// rule = new BomDefaultVersionCheckRule();
// processer.addBeforeRule(rule);
// edited by renshch 20150507
// 定制BOM不支持审批流，最多一个默认，此规则已做调整，只对定制BOM处理
//选配修改：这个规则仅处理定制BOM是否默认，定制BOM生成的时候已经处理过默认了，不需要再特殊校验，为了性能，先注释掉
//rule = new BomDefaultVersionCheckRule();
//processer.addBeforeRule(rule);
// 默认卷积：在同一维度下只能有一个默认卷积（业务单元+物料+物料版本+bom类型）
ConvolutionRule ctRule = new ConvolutionRule();
processer.addBeforeRule(ctRule);
// 是否委外：在同一维度下只能有一个委外BOM（业务单元+物料+物料版本）
OutsourceRule osRule = new OutsourceRule();
processer.addBeforeRule(osRule);
// 子项物料启用序列号校验规则
//此校验在BomSaveDataCheckRule里头已经校验，这里注释掉
//rule = new SerialManageCheckRule();
//processer.addBeforeRule(rule);
// 定制/配置BOM材料页签的相关校验
// 选配修改：去掉之前定制BOM关于特征码的校验，改到下面的rule里校验
rule = new CfgBomAndCBomItemCheckRule();
processer.addBeforeRule(rule);
//选配修改：增加模型BOM/可选类BOM/定制BOM 设置状态和校验
rule=new BomCheckForMatchRule();
processer.addBeforeRule(rule);
// 分配部分校验
rule = new BomSaveAssignVersionCheckRule();
processer.addBeforeRule(rule);
// 物料表头自动分配
rule = new MMAutoMaterialAssignRule<AggBomVO>(new String[] { BomVO.HCMATERIALVID, BomVO.HCMATERIALID }, null,
null, new String[] { BomVO.PK_ORG }, null, null, BomVO.class, false);
processer.addBeforeFinalRule(rule);
// 表体材料物料自动分配
rule = new MMAutoMaterialAssignRule<AggBomVO>(null,
new String[] { BomItemVO.CMATERIALVID, BomItemVO.CMATERIALID }, null, null,
new String[] { BomItemVO.PK_ORG }, null, BomItemVO.class, false);
processer.addBeforeFinalRule(rule);
// 表体联副产品物料自动分配
rule = new MMAutoMaterialAssignRule<AggBomVO>(null,
new String[] { BomOutputsVO.CMATERIALVID, BomOutputsVO.CMATERIALID }, null, null,
new String[] { BomOutputsVO.PK_ORG }, null, BomOutputsVO.class, false);
processer.addBeforeFinalRule(rule);
// 孙表线上仓物料表体自动分配
// rule = new MMAutoMaterialAssignRule<AggBomVO>(null, BomWipVO.G_CMATERIALVID, null,
// new String[] { BomWipVO.PK_ORG });
// processer.addBeforeFinalRule(rule);
// // 孙表组装位置物料表体自动分配
// rule = new MMAutoMaterialAssignRule<AggBomVO>(null, BomPosVO.G_CMATERIALVID, null,
// new String[] { BomPosVO.PK_ORG });
// processer.addBeforeFinalRule(rule);
// // 孙表阶梯变动损耗物料表体自动分配
// rule = new MMAutoMaterialAssignRule<AggBomVO>(null, BomLossVO.CLMATERIALVID, null,
// new String[] { BomLossVO.PK_ORG });
// processer.addBeforeFinalRule(rule);
// 孙表替代料物料表体自动分配
rule = new MMAutoMaterialAssignRule<AggBomVO>(null, null,
new String[] { BomReplVO.CREPLMATERIALVID, BomReplVO.CREPLMATERIALOID }, null, null,
new String[] { BomReplVO.PK_ORG }, BomReplVO.class, false);
processer.addBeforeFinalRule(rule);
// 注册事件源
rule = new BomAddBeforeEventRule();
processer.addBeforeRule(rule);
if (this.origins != null) {
// 替代方案-物料分配
rule = new BomReplsMaterialAssignRule(this.origins);
processer.addBeforeRule(rule);
}
//2025年6月13日09点38分 -- BOM保存时校验各BOM子件本业务单元库存组织是否启用项目，如果启用，则项目专用料自动启用（包含接口导入）
rule =new BOMBprojectmaterialEnableRule();
processer.addBeforeRule(rule);
}
/**
* 新增后规则
*
* @param processor
*/
private void addAfterRule(AroundProcesser<AggBomVO> processer) {
// BOM版本检查规则
IRule<AggBomVO> rule = new BomVersionCheckRule();
processer.addAfterRule(rule);
// 注册事件源
rule = new BomAddAfterEventRule();
processer.addAfterRule(rule);
}
public void setCheckEcn(boolean checkEcn) {
this.checkEcn = checkEcn;
}
public boolean getCheckEcn() {
return this.checkEcn;
}
public String[] getOrigins() {
return origins;
}
public void setOrigins(String[] origins) {
this.origins = origins;
}
}

399
uapbd/src/private/nc/bs/bd/bom/bom0202/bp/BomUpdateBP.java Normal file
View File

@ -0,0 +1,399 @@
package nc.bs.bd.bom.bom0202.bp;
import nc.bs.bd.bom.bom0202.plugin.bpplugin.BomPluginPoint;
import nc.bs.bd.bom.bom0202.rule.*;
import nc.bs.mmbd.pub.rule.MMAutoMaterialAssignRule;
import nc.bs.pubapp.pub.rule.FieldLengthCheckRule;
import nc.bs.pubapp.pub.rule.FillUpdateDataRule;
import nc.bs.pubapp.pub.rule.OrgDisabledCheckRule;
import nc.impl.pubapp.bd.material.assistant.MarAssistantSaveRule;
import nc.impl.pubapp.pattern.rule.ICompareRule;
import nc.impl.pubapp.pattern.rule.IRule;
import nc.impl.pubapp.pattern.rule.processer.CompareAroundProcesser;
import nc.itf.org.IOrgConstBasic;
import nc.mmbd.utils.factoryparam.MMBDFactoryParameter;
import nc.util.mmf.busi.rule.MMRowNoCheckRule;
import nc.util.mmf.framework.gc.GCUpdateBPTemplate;
import nc.vo.bd.bom.bom0202.entity.AggBomVO;
import nc.vo.bd.bom.bom0202.entity.BomActivityVO;
import nc.vo.bd.bom.bom0202.entity.BomItemVO;
import nc.vo.bd.bom.bom0202.entity.BomOutputsVO;
import nc.vo.bd.bom.bom0202.entity.BomPosVO;
import nc.vo.bd.bom.bom0202.entity.BomReplVO;
import nc.vo.bd.bom.bom0202.entity.BomVO;
import nc.vo.bd.bom.bom0202.entity.BomWipVO;
import nc.vo.pub.VOStatus;
import java.util.Map;
/**
* BOM更新BP
*
* @author baijl
*/
public class BomUpdateBP {
/**
* 是否校验工程变更单是否启用
*/
private boolean checkEcn = true;
public boolean getCheckEcn() {
return this.checkEcn;
}
public void setCheckEcn(boolean checkEcn) {
this.checkEcn = checkEcn;
}
/**
* 是否支持审批流
*/
private boolean onApprove;
public boolean getOnApprove() {
return this.onApprove;
}
public void setOnApprove(boolean onApprove) {
this.onApprove = onApprove;
}
/**
* 是否是bom或bom树修改保存，区分反向bom维护、bom子项批量修改等节点
*/
private boolean isFromBomAndBomTree = false;
private boolean isEcnOrgChanged = false;
private boolean isAssign = false;
private boolean isCancleAssign = false;
/**
* 跨组织复制时，原bom主键
*/
private String[] origins = null;
private Map<String,String> rownoMap = null;
public Map<String, String> getRownoMap() {
return rownoMap;
}
public void setRownoMap(Map<String, String> rownoMap) {
this.rownoMap = rownoMap;
}
public AggBomVO[] update(AggBomVO[] fullBills, AggBomVO[] originBills) {
return this.update(fullBills, originBills, true, false, false);
}
public AggBomVO[] update(AggBomVO[] fullBills, AggBomVO[] originBills, boolean newCheckEcn) {
return this.update(fullBills, originBills, newCheckEcn, false, false);
}
public AggBomVO[] update(AggBomVO[] fullBills, AggBomVO[] originBills, boolean newCheckEcn, boolean isFromBom,
boolean isEcnOrg) {
return this.update(fullBills, originBills, newCheckEcn, isFromBom, isEcnOrg, null, false);
}
public AggBomVO[] update(AggBomVO[] fullBills, AggBomVO[] originBills, boolean newCheckEcn, boolean isFromBom,
boolean isEcnOrg, String[] origins, Boolean param) {
this.setCheckEcn(newCheckEcn);
this.setFromBomAndBomTree(isFromBom);
this.setEcnOrgChanged(this.getIsOrgChanged(fullBills[0], isEcnOrg));
if (origins != null) {
this.setOrigins(origins);
}
// 调用修改模板
GCUpdateBPTemplate<AggBomVO> bp = new GCUpdateBPTemplate<AggBomVO>(BomPluginPoint.UPDATE);
for (AggBomVO vo : fullBills) {
if (vo.getParent().getStatus() != VOStatus.UPDATED && !this.isAssign) {
vo.getParent().setStatus(VOStatus.UPDATED);
}
}
// 执行前规则
this.addBeforeRule(bp.getAroundProcesser());
// 执行后规则
this.addAfterRule(bp.getAroundProcesser());
return bp.update(fullBills, originBills);
}
/**
* 带参的更新方法（是否支持ECN；是否支持审批流）
*
* @param fullBills
* @param originBills
* @param newCheckEcn
* @param onApprove
* @param isFromBom
* @param isEcnOrg
* @return
*/
public AggBomVO[] update(AggBomVO[] fullBills, AggBomVO[] originBills, boolean newCheckEcn, boolean onapprove,
boolean isFromBom, boolean isEcnOrg) {
this.setCheckEcn(newCheckEcn);
this.setOnApprove(onapprove);
this.setFromBomAndBomTree(isFromBom);
this.setEcnOrgChanged(this.getIsOrgChanged(fullBills[0], isEcnOrg));
// 调用修改模板
GCUpdateBPTemplate<AggBomVO> bp = new GCUpdateBPTemplate<AggBomVO>(BomPluginPoint.UPDATE);
for (AggBomVO vo : fullBills) {
if (vo.getParent().getStatus() != VOStatus.UPDATED && !this.isAssign) {
vo.getParent().setStatus(VOStatus.UPDATED);
}
}
// 执行前规则
this.addBeforeRule(bp.getAroundProcesser());
// 执行后规则
if (!this.isAssign && !this.isCancleAssign) {
this.addAfterRule(bp.getAroundProcesser());
}
return bp.update(fullBills, originBills);
}
/**
* 更新前规则
*
* @param processer
*/
@SuppressWarnings("unchecked")
private void addBeforeRule(CompareAroundProcesser<AggBomVO> processer) {
IRule<AggBomVO> rule = null;
if (this.isAssign || this.isCancleAssign) {
// 分配校验
if (this.isAssign) {
rule = new BomAssignCheckRule();
processer.addBeforeRule(rule);
// 分配组织vid
rule = new BomAssgnUseorgRule();
processer.addBeforeRule(rule);
}
if (this.isCancleAssign) {
// 分配部分校验
rule = new BomCancelAssignCheckRule();
processer.addBeforeRule(rule);
}
} else {
// 组织停用校验
rule = new OrgDisabledCheckRule(BomVO.PK_ORG, IOrgConstBasic.PRODUCEPLANTYPE);
processer.addBeforeRule(rule);
if (this.getIsFromBomAndBomTree()) {
// 判断组织启用工程变更的状态前后是否一致，不一致不能修改
if (this.getIsEcnOrgChanged()) {
rule = new ECNOrgChangedRule();
processer.addBeforeRule(rule);
}
} else {
if (this.getCheckEcn()) {
// 如果启用工程的话，不能修改保存bom(适用于批改、反向bom维护、bom子项批量替换场景)
rule = new ECNCheckForModifyBomRule();
processer.addBeforeRule(rule);
}
}
if (this.getCheckEcn()) {
// 数据检查
BomSaveDataCheckRule saveDataCheckRule = new BomSaveDataCheckRule();
saveDataCheckRule.setRownoMap(this.getRownoMap());
processer.addBeforeRule(saveDataCheckRule);
} else {
// 数据检查
BomSaveDataCheckRule saveDataCheckRule = new BomSaveDataCheckRule(!this.getCheckEcn());
saveDataCheckRule.setRownoMap(this.getRownoMap());
processer.addBeforeRule(saveDataCheckRule);
}
// 行号检查
rule = new MMRowNoCheckRule<AggBomVO>();
processer.addBeforeRule(rule);
// 物料信息检查
rule = new BomMaterialCheckRule();
processer.addBeforeRule(rule);
// 保存时分配信息校验
rule = new BomSaveAssignVersionCheckRule();
processer.addBeforeRule(rule);
// 长度检查
rule = new FieldLengthCheckRule();
processer.addBeforeRule(rule);
// if (this.getOnApprove()) {
// // 设置审计信息
// rule = new FillUpdateDataRule();
// processer.addBeforeRule(rule);
// } 注掉 因为定制BOM修改保存时最后修改人修改时间信息会写不进去
// 设置审计信息
rule = new FillUpdateDataRule();
processer.addBeforeRule(rule);
// 检查自由项
rule = new MarAssistantSaveRule<AggBomVO>();
processer.addBeforeRule(rule);
// 检查自定义项
String[] prefixs = new String[] { "hvdef", "vdef", "vbdef", "vdef", "vdef", "vdef", "vdef" };
Class<?>[] voClasses = new Class<?>[] { BomVO.class, BomItemVO.class, BomOutputsVO.class,
BomActivityVO.class, BomWipVO.class, BomPosVO.class, BomReplVO.class };
rule = new nc.impl.pubapp.bd.userdef.UserDefSaveRule<AggBomVO>(prefixs, voClasses);
processer.addBeforeRule(rule);
// delete by qianzhx
// BOM在非审批通过态可以支持存在多个默认 20150425
// BOM默认版本规则
// rule = new BomDefaultVersionCheckRule();
// processer.addBeforeRule(rule);
// edited by renshch 20150507
// 定制BOM不支持审批流，最多一个默认，此规则已做调整，只对定制BOM处理
rule = new BomDefaultVersionCheckRule();
processer.addBeforeRule(rule);
//选配修改：增加模型BOM/可选类BOM/定制BOM 校验
rule=new BomCheckForMatchRule();
processer.addBeforeRule(rule);
// 默认卷积：在同一维度下只能有一个默认卷积（业务单元+物料+物料版本+bom类型）
ConvolutionRule ctRule = new ConvolutionRule();
processer.addBeforeRule(ctRule);
// 是否委外：在同一维度下只能有一个委外BOM（业务单元+物料+物料版本）
OutsourceRule osRule = new OutsourceRule();
processer.addBeforeRule(osRule);
// 子项物料启用序列号校验规则
rule = new SerialManageCheckRule();
processer.addBeforeRule(rule);
// 配置BOM 材料页签的相关校验
// 选配修改：去掉之前定制BOM关于特征码的校验，改到下面的rule里校验
rule = new CfgBomAndCBomItemCheckRule();
processer.addBeforeRule(rule);
// 注册事件源
rule = new BomUpdateBeforeEventRule();
processer.addBeforeRule(rule);
// 被替代方案引用的子项不能修改
ICompareRule<AggBomVO> compareRule = new UpdateHasReplsCheckRule();
processer.addBeforeRule(compareRule);
}
// 物料表头自动分配
rule = new MMAutoMaterialAssignRule<AggBomVO>(new String[] { BomVO.HCMATERIALVID, BomVO.HCMATERIALID }, null,
null, new String[] { BomVO.PK_ORG }, null, null, BomVO.class, this.isAssign);
processer.addBeforeFinalRule(rule);
// 表体材料物料自动分配
rule = new MMAutoMaterialAssignRule<AggBomVO>(null,
new String[] { BomItemVO.CMATERIALVID, BomItemVO.CMATERIALID }, null, null,
new String[] { BomItemVO.PK_ORG }, null, BomItemVO.class, this.isAssign);
processer.addBeforeFinalRule(rule);
// 表体联副产品物料自动分配
rule = new MMAutoMaterialAssignRule<AggBomVO>(null,
new String[] { BomOutputsVO.CMATERIALVID, BomOutputsVO.CMATERIALID }, null, null,
new String[] { BomOutputsVO.PK_ORG }, null, BomOutputsVO.class, this.isAssign);
processer.addBeforeFinalRule(rule);
// 孙表线上仓物料表体自动分配
// rule = new MMAutoMaterialAssignRule<AggBomVO>(null, BomWipVO.G_CMATERIALVID, null,
// new String[] { BomWipVO.PK_ORG });
// processer.addBeforeFinalRule(rule);
// // 孙表组装位置物料表体自动分配
// rule = new MMAutoMaterialAssignRule<AggBomVO>(null, BomPosVO.G_CMATERIALVID, null,
// new String[] { BomPosVO.PK_ORG });
// processer.addBeforeFinalRule(rule);
// // 孙表阶梯变动损耗物料表体自动分配
// rule = new MMAutoMaterialAssignRule<AggBomVO>(null, BomLossVO.CLMATERIALVID, null,
// new String[] { BomLossVO.PK_ORG });
// processer.addBeforeFinalRule(rule);
// 孙表替代料物料表体自动分配
rule = new MMAutoMaterialAssignRule<AggBomVO>(null, null,
new String[] { BomReplVO.CREPLMATERIALVID, BomReplVO.CREPLMATERIALOID }, null, null,
new String[] { BomReplVO.PK_ORG }, BomReplVO.class, this.isAssign);
processer.addBeforeFinalRule(rule);
if (this.origins != null) {
// 替代方案-物料分配
rule = new BomReplsMaterialAssignRule(this.origins);
processer.addBeforeRule(rule);
}
//2025年6月13日09点38分 -- BOM保存时校验各BOM子件本业务单元库存组织是否启用项目，如果启用，则项目专用料自动启用（包含接口导入）
rule =new BOMBprojectmaterialEnableRule();
processer.addBeforeRule(rule);
}
/**
* 更新后规则
*
* @param processer
*/
private void addAfterRule(CompareAroundProcesser<AggBomVO> processer) {
// BOM版本检查规则
IRule<AggBomVO> rule = new BomVersionCheckRule();
processer.addAfterRule(rule);
// 同步BOM匹配规则中的BOM版本 add by lijbe
ICompareRule<AggBomVO> updateBmrtRule = new BomUpdateBmrtVersionRule();
processer.addBeforeRule(updateBmrtRule);
// 注册事件源
IRule<AggBomVO> eventRrule = new BomUpdateAfterEventRule();
processer.addAfterRule(eventRrule);
}
public boolean getIsFromBomAndBomTree() {
return this.isFromBomAndBomTree;
}
public void setFromBomAndBomTree(boolean isFromBomAndBomTree) {
this.isFromBomAndBomTree = isFromBomAndBomTree;
}
public boolean getIsEcnOrgChanged() {
return false;
}
public void setEcnOrgChanged(boolean isEcnOrgChanged) {
this.isEcnOrgChanged = isEcnOrgChanged;
}
public boolean getIsOrgChanged(AggBomVO aggvo, boolean isEcn_old) {
BomVO bomvo = (BomVO) aggvo.getParentVO();
boolean isEcn_new = MMBDFactoryParameter.isAlterCtrl(bomvo.getPk_org());
if (isEcn_new != isEcn_old) {
// 前后不一致则赋值
return true;
}
return false;
}
public boolean isAssign() {
return this.isAssign;
}
public void setAssign(boolean isAssign) {
this.isAssign = isAssign;
}
public boolean isCancleAssign() {
return this.isCancleAssign;
}
public void setCancleAssign(boolean isCancleAssign) {
this.isCancleAssign = isCancleAssign;
}
public String[] getOrigins() {
return origins;
}
public void setOrigins(String[] origins) {
this.origins = origins;
}
}

84
uapbd/src/private/nc/bs/bd/bom/bom0202/rule/BOMBprojectmaterialEnableRule.java Normal file
View File

@ -0,0 +1,84 @@
package nc.bs.bd.bom.bom0202.rule;
import nc.bs.dao.BaseDAO;
import nc.bs.dao.DAOException;
import nc.impl.pubapp.pattern.rule.IRule;
import nc.jdbc.framework.processor.ColumnProcessor;
import nc.jdbc.framework.processor.MapListProcessor;
import nc.util.mmf.framework.base.MMValueCheck;
import nc.vo.bd.bom.bom0202.entity.AggBomVO;
import nc.vo.bd.bom.bom0202.entity.BomItemVO;
import nc.vo.org.OrgVO;
import nc.vo.pub.BusinessException;
import nc.vo.pub.lang.UFBoolean;
import nc.vo.pubapp.pattern.exception.ExceptionUtils;
import nc.vo.pubapp.pattern.pub.SqlBuilder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @Classname BOMBprojectmaterialEnableRule
* @Description TODO
* @Version 1.0.0
* @Date 2025/6/13 9:43
* @Created by ame
*/
public class BOMBprojectmaterialEnableRule implements IRule<AggBomVO> {
private static BaseDAO dao = new BaseDAO();
@Override
public void process(AggBomVO[] vos) {
if (!MMValueCheck.isEmpty(vos)) {
try {
//获取表头计划组织及表体行物料
for (AggBomVO vo : vos) {
String pk_org = (String) vo.getParentVO().getAttributeValue("pk_org");
BomItemVO[] childrenVOs = vo.getChildrenVO();
Map<String,String> material_construct = new HashMap<>();
Map<String,String> material_stock = new HashMap<>();
queryFix2ByMaterial(childrenVOs,material_construct,material_stock,pk_org);
for(BomItemVO bomItemVO:childrenVOs){
String cmaterialvid = bomItemVO.getCmaterialvid();
if(material_construct.containsKey(cmaterialvid)&& "Y".equals(material_construct.get(cmaterialvid))&& material_stock.containsKey(cmaterialvid)&& "Y".equals(material_stock.get(cmaterialvid))){
bomItemVO.setBprojectmaterial(UFBoolean.TRUE);
}
}
}
} catch (BusinessException var6) {
ExceptionUtils.wrappException(var6);
}
}
}
private void queryFix2ByMaterial(BomItemVO[] childrenVOs, Map<String, String> materialConstruct, Map<String, String> materialStock, String pkOrg) throws BusinessException {
List<String> materials=new ArrayList<>();
for (BomItemVO childrenVO : childrenVOs){
String cmaterialvid = childrenVO.getCmaterialvid();
materials.add(cmaterialvid);
}
SqlBuilder sql =new SqlBuilder();
sql.append(" SELECT bdm.pk_material ,bdmf.fix2,bdms.fixasst2 ");
sql.append(" FROM bd_material bdm ");
sql.append(" LEFT JOIN bd_marasstframe bdmf ON bdm.pk_marasstframe =bdmf.pk_marasstframe ");
sql.append(" LEFT JOIN bd_materialstock bdms ON bdms.PK_MATERIAL =bdm.PK_MATERIAL AND bdms.PK_ORG ='"+pkOrg+"' ");
sql.append(" where ");
sql.append("bdm.pk_material",materials.toArray(new String[0]));
List<Map<String,Object>> remain = (List<Map<String, Object>>) dao.executeQuery(sql.toString(), new MapListProcessor());
if(remain==null || remain.isEmpty()){
throw new BusinessException("物料查询辅助属性结构失败,sql【"+sql+"】");
}
for (Map<String,Object> map:remain){
String fix2=map.get("fix2")==null?"N":map.get("fix2").toString();
String fixasst2=map.get("fixasst2")==null?"N":map.get("fixasst2").toString();
materialConstruct.put(map.get("pk_material").toString(),fix2);
materialStock.put(map.get("pk_material").toString(),fixasst2);
}
}
}

66
uapbd/src/private/nccloud/api/uapbd/customer/tms/listener/kejian/AssignCustomerListener.java Normal file
View File

@ -0,0 +1,66 @@
package nccloud.api.uapbd.customer.tms.listener.kejian;
import com.alibaba.fastjson.JSONObject;
import nc.bs.bd.baseservice.ArrayClassConvertUtil;
import nc.bs.businessevent.IBusinessEvent;
import nc.bs.businessevent.IBusinessListener;
import nc.bs.businessevent.bd.BDCommonEvent;
import nc.bs.dao.BaseDAO;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.bs.uapbd.util.BaseOpenApiReq;
import nc.vo.bd.cust.CustomerVO;
import nc.vo.org.OrgVO;
import nc.vo.pub.BusinessException;
import java.util.Arrays;
import java.util.Collection;
/**
* 创建客户后，自动分配组织
*
* @author mzr
* @date 2025/06/16
*/
public class AssignCustomerListener implements IBusinessListener {
@Override
public void doAction(IBusinessEvent event) throws BusinessException {
BDCommonEvent e = (BDCommonEvent) event;
Object[] objs = e.getObjs();
CustomerVO[] useVOs = ArrayClassConvertUtil.convert(objs, CustomerVO.class);
for (CustomerVO customerVO : useVOs) {
assignOrgApi(customerVO);
}
}
public void assignOrgApi(CustomerVO customerVO) throws BusinessException {
String[] customerPks = {customerVO.getPk_customer()};
OrgVO[] virtulaOrg = getVirtulaOrg();
String[] assignOrgPks = Arrays.stream(virtulaOrg).map(OrgVO::getPk_org).toArray(String[]::new);
JSONObject param = new JSONObject();
JSONObject ufinterfaceJson = new JSONObject();
JSONObject dataJson = new JSONObject();
dataJson.put("customer", customerPks);
dataJson.put("org", assignOrgPks);
ufinterfaceJson.put("sender", "default");
ufinterfaceJson.put("data", dataJson);
param.put("ufinterface", ufinterfaceJson);
BaseOpenApiReq req = new BaseOpenApiReq();
req.assignOrgApi("/nccloud/api/uapbd/customermanageext/customer/assignByPk", param);
}
/**
* 查询组织信息
*
* @author mzr
* @date 2025/05/29
*/
public OrgVO[] getVirtulaOrg() throws BusinessException {
String groupID = InvocationInfoProxy.getInstance().getGroupId();
// NCCForUAPLogger.debug("groupID = " + groupID);
// enablestate 启用状态 isbusinessunit 是否业务单元数据
String condition = "pk_group = '" + groupID + "' and ENABLESTATE = '2' and isbusinessunit='Y'";
Collection<OrgVO> collection = (new BaseDAO()).retrieveByClause(OrgVO.class, condition, "code");
return collection.toArray(new OrgVO[0]);
}
}

5
uapbd/src/client/nccloud/web/uapbd/customer/baseinfo/action/BaseOpenApiReq.java → uapbd/src/public/nc/bs/uapbd/util/BaseOpenApiReq.java
View File

@ -1,4 +1,4 @@
package nccloud.web.uapbd.customer.baseinfo.action;
package nc.bs.uapbd.util;
import com.alibaba.fastjson.JSONObject;
@ -7,7 +7,6 @@ import com.sm.misc.BASE64Encoder;
import nc.bs.dao.DAOException;
import nc.bs.logging.Logger;
import nc.bs.trade.business.HYSuperDMO;
import nc.itf.arap.goldentax.SysParaInitQuery;
import nc.vo.opm.thirdapp.ThirdappVO;
import nc.ws.opm.pub.utils.security.SecurityUtil;
import org.apache.commons.httpclient.Header;
@ -61,7 +60,7 @@ public class BaseOpenApiReq {
if (apiInfo == null) {
return;
}
BASE_URL_DEV = SysParaInitQuery.getParaString("GLOBLE00000000000000", "GJBURL");
// BASE_URL_DEV = SysParaInitQuery.getParaString("GLOBLE00000000000000", "GJBURL");
CLIENT_ID = apiInfo.getApp_id();
CLIENT_SECRET = apiInfo.getApp_secret();
PUBLIC_KEY = apiInfo.getPublic_key();

2
uapbd/src/client/nccloud/web/uapbd/customer/baseinfo/action/HttpClientWapper.java → uapbd/src/public/nc/bs/uapbd/util/HttpClientWapper.java
View File

@ -1,4 +1,4 @@
package nccloud.web.uapbd.customer.baseinfo.action;
package nc.bs.uapbd.util;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;

132
uapbd/src/public/nccloud/api/uapbd/customermanage/customer/AssignCustomerExtResource.java Normal file
View File

@ -0,0 +1,132 @@
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package nccloud.api.uapbd.customermanage.customer;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import nc.bs.dao.BaseDAO;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.bs.framework.common.NCLocator;
import nc.itf.bd.cust.assign.ICustAssignService;
import nc.jdbc.framework.processor.ColumnListProcessor;
import nc.vo.pub.BusinessException;
import nccloud.api.rest.utils.ResultMessageUtil;
import nccloud.api.uapbd.common.utils.OpenApiPagenationUtils;
import nccloud.vo.sql.util.InSqlUtil;
import nccloud.ws.rest.resource.AbstractNCCRestResource;
import org.json.JSONString;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import java.util.List;
@Path("uapbd/customermanageext/customer")
public class AssignCustomerExtResource extends AbstractNCCRestResource {
public AssignCustomerExtResource() {
}
@POST
@Path("assign")
@Consumes({"application/json"})
@Produces({"application/json"})
public JSONString assign(JSONString json) {
JSONObject jObject = JSON.parseObject(json.toJSONString());
if (jObject == null) {
return ResultMessageUtil.exceptionToJSON(new NullPointerException("JSONString:null"));
} else {
JSONObject object = jObject.getJSONObject("ufinterface");
if (object == null) {
return ResultMessageUtil.exceptionToJSON(new NullPointerException("ufinterface:null"));
} else {
JSONObject data = object.getJSONObject("data");
if (data == null) {
return ResultMessageUtil.exceptionToJSON(new NullPointerException("data:null"));
} else {
JSONArray customer = data.getJSONArray("customer");
JSONArray org = data.getJSONArray("org");
List<String> customerList = OpenApiPagenationUtils.jSONArrayToList(customer);
List<String> orgList = OpenApiPagenationUtils.jSONArrayToList(org);
if (customerList.size() == 0) {
return ResultMessageUtil.exceptionToJSON(new BusinessException("传入参数中客户编码为空，请确认传入参数！"));
} else if (orgList.size() == 0) {
return ResultMessageUtil.exceptionToJSON(new BusinessException("传入参数待分配组织编码为空，请确认传入参数！"));
} else {
String pk_group = InvocationInfoProxy.getInstance().getGroupId();
String userid = InvocationInfoProxy.getInstance().getUserId();
try {
String[] customerPks = this.translateCustomers(customerList, pk_group);
String[] assignOrgPks = this.translateOrgPk(orgList, pk_group);
((ICustAssignService) NCLocator.getInstance().lookup(ICustAssignService.class)).assignCustomerByPks(customerPks, assignOrgPks, (String[]) null);
return ResultMessageUtil.toJSON("客户分配成功！");
} catch (BusinessException e) {
return ResultMessageUtil.exceptionToJSON(e);
}
}
}
}
}
}
@POST
@Path("assignByPk")
@Consumes({"application/json"})
@Produces({"application/json"})
public JSONString assignByPk(JSONString json) {
JSONObject jObject = JSON.parseObject(json.toJSONString());
if (jObject == null) {
return ResultMessageUtil.exceptionToJSON(new NullPointerException("JSONString:null"));
} else {
JSONObject object = jObject.getJSONObject("ufinterface");
if (object == null) {
return ResultMessageUtil.exceptionToJSON(new NullPointerException("ufinterface:null"));
} else {
JSONObject data = object.getJSONObject("data");
if (data == null) {
return ResultMessageUtil.exceptionToJSON(new NullPointerException("data:null"));
} else {
JSONArray customer = data.getJSONArray("customer");
JSONArray org = data.getJSONArray("org");
List<String> customerList = OpenApiPagenationUtils.jSONArrayToList(customer);
List<String> orgList = OpenApiPagenationUtils.jSONArrayToList(org);
if (customerList.size() == 0) {
return ResultMessageUtil.exceptionToJSON(new BusinessException("传入参数中客户编码为空，请确认传入参数！"));
} else if (orgList.size() == 0) {
return ResultMessageUtil.exceptionToJSON(new BusinessException("传入参数待分配组织编码为空，请确认传入参数！"));
} else {
try {
String[] customerPks = customerList.toArray(new String[0]);
String[] assignOrgPks = orgList.toArray(new String[0]);
((ICustAssignService) NCLocator.getInstance().lookup(ICustAssignService.class)).assignCustomerByPks(customerPks, assignOrgPks, null);
return ResultMessageUtil.toJSON("客户分配成功！");
} catch (BusinessException e) {
return ResultMessageUtil.exceptionToJSON(e);
}
}
}
}
}
}
private String[] translateCustomers(List<String> codes, String pk_group) throws BusinessException {
String sql = "select pk_customer from bd_customer where pk_group = '" + pk_group + "' and " + InSqlUtil.buildInSql("code", "or", "in", (String[]) codes.toArray(new String[0]));
List<String> pks = (List) (new BaseDAO()).executeQuery(sql, new ColumnListProcessor());
return pks != null && pks.size() > 0 ? (String[]) pks.toArray(new String[0]) : null;
}
private String[] translateOrgPk(List<String> codes, String pk_group) throws BusinessException {
String sql = "select pk_org from org_orgs where isbusinessunit = 'Y' and pk_group = '" + pk_group + "' and " + InSqlUtil.buildInSql("code", "or", "in", (String[]) codes.toArray(new String[0]));
List<String> pks = (List) (new BaseDAO()).executeQuery(sql, new ColumnListProcessor());
return pks != null && pks.size() > 0 ? (String[]) pks.toArray(new String[0]) : null;
}
public String getModule() {
return "uapbd";
}
}

11
uapbd/src/public/nccloud/api/uapbd/msg/MsgResource.java
View File

@ -32,12 +32,13 @@ import java.util.Date;
*/
@Path("uapbd/msg")
public class MsgResource extends AbstractNCCRestResource {
private static final String DEFAULT_SENDER = "NC_USER0000000000000";
public String getModule() {
return "uapbd";
}
private HYSuperDMO superDMO = null;
private HYSuperDMO superDMO;
public HYSuperDMO getSuperDMO() {
@ -65,7 +66,7 @@ public class MsgResource extends AbstractNCCRestResource {
// 根据传递的角色查询要发送消息的用户信息
UserVO[] userVOS = getUserByRole(roleId);
if (userVOS == null) {
if (userVOS == null || userVOS.length == 0) {
return ResultMessageUtil.toJSON(false, "未查询到用户");
}
@ -87,7 +88,7 @@ public class MsgResource extends AbstractNCCRestResource {
CommonMessageVO commonMessageVO = new CommonMessageVO();
commonMessageVO.setReceiver(users);
commonMessageVO.setTitle("BOM变更信息通知");
commonMessageVO.setSender("NC_USER0000000000000");
commonMessageVO.setSender(DEFAULT_SENDER);
commonMessageVO.setSendDataTime(new UFDateTime());
commonMessageVO.setPriority(1);
commonMessageVO.setMessageContent(content);
@ -95,8 +96,8 @@ public class MsgResource extends AbstractNCCRestResource {
PfMessageUtil.sendNoticeMessage(commonMessageVO);
return ResultMessageUtil.toJSON(true, "消息发送成功");
} catch (BusinessException e) {
Logger.error("MsgResource-exp:" + e.getMessage());
} catch (Exception e) {
Logger.error("MsgResource-exp:", e);
return ResultMessageUtil.exceptionToJSON(new BusinessException(e.getMessage(), e));
}
}