From 23e80cd89e8a8ebe8040ac96e4c6bd30a36321af Mon Sep 17 00:00:00 2001 From: xuhaihui <2098865055@qq.com> Date: Thu, 11 Sep 2025 14:35:03 +0800 Subject: [PATCH] =?UTF-8?q?=E6=A0=87=E5=BF=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../plugin/operate/InContractBillOpExt.java | 385 ++++++++++++++++++ 1 file changed, 385 insertions(+) create mode 100644 code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/operate/InContractBillOpExt.java diff --git a/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/operate/InContractBillOpExt.java b/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/operate/InContractBillOpExt.java new file mode 100644 index 0000000..9752ea8 --- /dev/null +++ b/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/operate/InContractBillOpExt.java @@ -0,0 +1,385 @@ +// +// Source code recreated from a .class file by IntelliJ IDEA +// (powered by FernFlower decompiler) +// + +package zcgj.zcdev.zcdev.pr.plugin.operate; + +import java.math.BigDecimal; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import kd.bos.dataentity.entity.DataEntityBase; +import kd.bos.dataentity.entity.DynamicObject; +import kd.bos.dataentity.entity.DynamicObjectCollection; +import kd.bos.dataentity.utils.StringUtils; +import kd.bos.entity.EntityMetadataCache; +import kd.bos.entity.plugin.AbstractOperationServicePlugIn; +import kd.bos.entity.plugin.AddValidatorsEventArgs; +import kd.bos.entity.plugin.PreparePropertysEventArgs; +import kd.bos.entity.plugin.args.BeginOperationTransactionArgs; +import kd.bos.entity.plugin.args.EndOperationTransactionArgs; +import kd.bos.entity.validate.AbstractValidator; +import kd.bos.orm.query.QFilter; +import kd.bos.servicehelper.BusinessDataServiceHelper; +import kd.bos.servicehelper.operation.SaveServiceHelper; +import kd.ec.basedata.business.model.cont.ProjectConstant; +import kd.ec.basedata.common.enums.BillStatusEnum; +import kd.ec.contract.common.enums.ContractStatusEnum; +import kd.ec.contract.common.enums.PayDirectionEnum; +import kd.ec.contract.common.utils.CurrencyHelper; +import kd.ec.contract.opplugin.validator.ContUnitProjectValidator; +import kd.ec.contract.opplugin.validator.ContractValidator; + +public class InContractBillOpExt extends AbstractOperationServicePlugIn { + private static final String LISTMODELID = "listmodelid"; + private static final String STDCURRENCY = "stdcurrency"; + private static final String CURRENCY = "currency"; + private static final String SIGNAMOUNT = "signamount"; + private static final String EXCHANGEDATE = "exchangedate"; + private static final String MODELNAME = "modelname"; + private static final String ISLEAF = "isleaf"; + private static final String LISTNUMBER = "listnumber"; + private static final String LISTNAME = "listname"; + private static final String MATERIAL = "material"; + private static final String RESOURCEITEM = "resourceitem"; + private static final String MEASUREUNIT = "measureunit"; + private static final String QTY = "qty"; + private static final String PRICE = "price"; + private static final String AMOUNT = "amount"; + private static final String VERSIONNUMBER = "versionnumber"; + private static final String LASTVERSIONNUMBER = "lastversionnumber"; + private static final String CONTSTATUS = "contstatus"; + private static final String CONTRACT = "contract"; + + public InContractBillOpExt() { + } + + public void onPreparePropertys(PreparePropertysEventArgs e) { + super.onPreparePropertys(e); + List fields = e.getFieldKeys(); + fields.add("isonlist"); + fields.add("contracttype"); + fields.add("specentry"); + fields.add("propname"); + fields.add("value"); + fields.add("project"); + fields.add("listmodelid"); + fields.add("stdcurrency"); + fields.add("currency"); + fields.add("signamount"); + fields.add("originaloftaxamount"); + fields.add("exchangedate"); + fields.add("modelname"); + fields.add("isleaf"); + fields.add("listnumber"); + fields.add("listname"); + fields.add("material"); + fields.add("resourceitem"); + fields.add("measureunit"); + fields.add("qty"); + fields.add("price"); + fields.add("amount"); + fields.add("originalamount"); + fields.add("originalamount"); + fields.add("totalamount"); + fields.add("totaloftaxamount"); + fields.add("billno"); + fields.add("paydirection"); + fields.add("versionnumber"); + fields.add("lastversionnumber"); + fields.add("contstatus"); + fields.add("contract"); + fields.add("billstatus"); + fields.add("leaseqty"); + fields.add("leaseunit"); + fields.add("leasebegintime"); + fields.add("leaseendtime"); + fields.add("leasedayqty"); + fields.add("listunitproject"); + fields.add("onunit"); + fields.add("listmodelentry"); + fields.add("sublistentry"); + } + + public void beginOperationTransaction(BeginOperationTransactionArgs e) { + String operateKey = e.getOperationKey(); + DynamicObject[] contractBillCols = e.getDataEntities(); + PayDirectionEnum paydirection = PayDirectionEnum.getEnumByValue(contractBillCols[0].get("paydirection")); + int i; + DynamicObject contractBill; + if ("audit".equals(operateKey)) { + for(i = 0; i < contractBillCols.length; ++i) { + contractBill = contractBillCols[i]; + contractBill = BusinessDataServiceHelper.loadSingle(contractBill.getPkValue(), contractBill.getDynamicObjectType()); + contractBill.set("totalamount", contractBill.get("originalamount")); + contractBill.set("totaloftaxamount", contractBill.get("originaloftaxamount")); + contractBill.set("contstatus", ContractStatusEnum.APPROVED.getValue()); + Object lastversion = contractBill.get("versionnumber"); + if (PayDirectionEnum.IN == paydirection) { + this.updateLastVersionNumber("ec_in_contract", contractBill.getPkValue(), lastversion); + } else { + this.updateLastVersionNumber("ec_out_contract", contractBill.getPkValue(), lastversion); + } + + SaveServiceHelper.save(contractBill.getDynamicObjectType(), new DynamicObject[]{contractBill}); + } + + this.udateProjectAllInContractAmount(contractBillCols, paydirection, true); + } else if ("unaudit".equals(operateKey)) { + for(i = 0; i < contractBillCols.length; ++i) { + contractBill = contractBillCols[i]; + contractBill = BusinessDataServiceHelper.loadSingle(contractBill.getPkValue(), contractBill.getDynamicObjectType()); + contractBill.set("totalamount", BigDecimal.ZERO); + contractBill.set("totaloftaxamount", BigDecimal.ZERO); + contractBill.set("contstatus", ContractStatusEnum.INDRAFT.getValue()); + SaveServiceHelper.save(contractBill.getDynamicObjectType(), new DynamicObject[]{contractBill}); + this.updateContractType(contractBill); + } + + this.udateProjectAllInContractAmount(contractBillCols, paydirection, false); + } else if ("submit".equals(operateKey)) { + for(i = 0; i < contractBillCols.length; ++i) { + contractBill = contractBillCols[i]; + contractBill.set("contstatus", ContractStatusEnum.INAUDIT.getValue()); + contractBill.set("totalamount", BigDecimal.ZERO); + contractBill.set("totaloftaxamount", BigDecimal.ZERO); + contractBill.set("totalamount", contractBill.get("originalamount")); + contractBill.set("totaloftaxamount", contractBill.get("originaloftaxamount")); + } + } else if ("unsubmit".equals(operateKey)) { + for(i = 0; i < contractBillCols.length; ++i) { + contractBill = contractBillCols[i]; + contractBill.set("contstatus", ContractStatusEnum.INDRAFT.getValue()); + contractBill.set("totalamount", BigDecimal.ZERO); + contractBill.set("totaloftaxamount", BigDecimal.ZERO); + SaveServiceHelper.save(contractBill.getDynamicObjectType(), new DynamicObject[]{contractBill}); + this.updateContractType(contractBill); + } + } else if ("save".equals(operateKey)) { + for(i = 0; i < contractBillCols.length; ++i) { + contractBill = contractBillCols[i]; + String status = contractBill.getString("billstatus"); + if (StringUtils.equals(status, BillStatusEnum.SAVE.getValue())) { + contractBill.set("contstatus", ContractStatusEnum.INDRAFT.getValue()); + } + } + } + + } + + public void endOperationTransaction(EndOperationTransactionArgs e) { + String operateKey = e.getOperationKey(); + DynamicObject[] contractBillCols = e.getDataEntities(); + if ("save".equals(operateKey) || "submit".equals(operateKey) || "audit".equals(operateKey)) { + this.updateContListingData(contractBillCols); + } + + } + + protected void updateContListingData(DynamicObject[] contractBillCols) { + DynamicObject[] var2 = contractBillCols; + int var3 = contractBillCols.length; + + label36: + for(int var4 = 0; var4 < var3; ++var4) { + DynamicObject contract = var2[var4]; + String contId = contract.getString("id"); + DynamicObject currency = contract.getDynamicObject("currency"); + String payDirection = contract.getString("paydirection"); + DynamicObjectCollection listModelCol = contract.getDynamicObjectCollection("listmodelentry"); + Iterator var10 = listModelCol.iterator(); + + while(true) { + DynamicObject listModel; + DynamicObjectCollection listings; + do { + if (!var10.hasNext()) { + continue label36; + } + + listModel = (DynamicObject)var10.next(); + listings = listModel.getDynamicObjectCollection("sublistentry"); + } while(listings.isEmpty()); + + Object[] listIds = listings.stream().map(DataEntityBase::getPkValue).toArray(); + DynamicObject[] listingsArr = BusinessDataServiceHelper.load(listIds, EntityMetadataCache.getDataEntityType("ec_intreelisting")); + int j = 0; + DynamicObject[] var16 = listingsArr; + int var17 = listingsArr.length; + + for(int var18 = 0; var18 < var17; ++var18) { + DynamicObject listing = var16[var18]; + listing.set("contractid", contId); + listing.set("totalqty", listing.getBigDecimal("qty")); + listing.set("lstoftaxamount", listing.getBigDecimal("oftax")); + listing.set("lasttotalamt", listing.getBigDecimal("amount")); + BigDecimal taxprice = listing.getBigDecimal("taxprice"); + listing.set("curtaxprice", taxprice); + listing.set("avgtaxprice", taxprice); + BigDecimal price = listing.getBigDecimal("price"); + listing.set("currentprice", price); + listing.set("avgprice", price); + listing.set("listingmodel", listModel.getLong("listmodelid")); + listing.set("currency", currency); + listing.set("paydirection", payDirection); + ++j; + listing.set("sequence", j); + } + + if (listingsArr.length > 0) { + SaveServiceHelper.save(listingsArr[0].getDynamicObjectType(), listingsArr); + } + } + } + + } + + private void udateProjectAllInContractAmount(DynamicObject[] contractBillCols, PayDirectionEnum paydirection, boolean isAudit) { + if (PayDirectionEnum.IN == paydirection) { + Map projCurrency = new HashMap(); + String proSelector = (String)Stream.of(ProjectConstant.ID_ENTITY_PK, "org", "currency", "allincontamount").collect(Collectors.joining(",")); + + for(int i = 0; i < contractBillCols.length; ++i) { + DynamicObject contractBill = contractBillCols[i]; + DynamicObject pro = (DynamicObject)contractBill.get("project"); + if (pro != null) { + DynamicObject stdCurrency = (DynamicObject)contractBill.get("stdcurrency"); + DynamicObject currency = (DynamicObject)contractBill.get("currency"); + BigDecimal signamount = contractBill.getBigDecimal("signamount"); + BigDecimal originaloftaxamount = contractBill.getBigDecimal("originaloftaxamount"); + Object[] values = null; + DynamicObject proCurrency; + DynamicObject project; + if (projCurrency.containsKey(pro.getLong("id"))) { + values = (Object[])projCurrency.get(pro.getLong("id")); + } else { + values = new Object[2]; + proCurrency = BusinessDataServiceHelper.loadSingle(pro.getPkValue(), "ec_project", proSelector); + project = (DynamicObject)proCurrency.get("currency"); + if (project == null) { + project = CurrencyHelper.getCurrency((Long)proCurrency.getDynamicObject("org").getPkValue()); + } + + values[0] = proCurrency; + values[1] = project; + projCurrency.put((Long)pro.getPkValue(), values); + } + + proCurrency = (DynamicObject)values[1]; + project = (DynamicObject)values[0]; + BigDecimal addContAmount = BigDecimal.ZERO; + if (stdCurrency != null && stdCurrency.equals(proCurrency)) { + addContAmount = signamount; + } else { + BigDecimal rate; + if (currency != null && currency.equals(proCurrency)) { + if (BigDecimal.ZERO.compareTo(signamount) != 0) { + Long exRateTable = (Long)CurrencyHelper.getExRateTable((Long)project.getDynamicObject("org").getPkValue()).getPkValue(); + rate = CurrencyHelper.getExChangeRate((Long)currency.getPkValue(), (Long)proCurrency.getPkValue(), exRateTable, contractBill.getDate("exchangedate")); + addContAmount = originaloftaxamount.multiply(rate); + } else { + addContAmount = originaloftaxamount; + } + } else { + DynamicObject exRateTable = CurrencyHelper.getExRateTable((Long)project.getDynamicObject("org").getPkValue()); + rate = null; + if (exRateTable != null && stdCurrency != null) { + Long exRateTableId = (Long)exRateTable.getPkValue(); + rate = CurrencyHelper.getExChangeRate((Long)stdCurrency.getPkValue(), (Long)proCurrency.getPkValue(), exRateTableId, contractBill.getDate("exchangedate")); + } + + if (rate == null) { + rate = BigDecimal.ZERO; + } + + addContAmount = signamount.multiply(rate); + } + } + + BigDecimal amtPrecision = BigDecimal.valueOf(2L); + if (proCurrency != null) { + amtPrecision = proCurrency.getBigDecimal("amtprecision"); + } + + if (isAudit) { + project.set("allincontamount", project.getBigDecimal("allincontamount").add(addContAmount).setScale(amtPrecision.intValue(), 4)); + } else { + project.set("allincontamount", project.getBigDecimal("allincontamount").subtract(addContAmount).setScale(amtPrecision.intValue(), 4)); + } + } + } + + DynamicObject[] updateProList = (DynamicObject[])projCurrency.entrySet().stream().map((entry) -> { + return (DynamicObject)((Object[])entry.getValue())[0]; + }).toArray((x$0) -> { + return new DynamicObject[x$0]; + }); + SaveServiceHelper.update(updateProList); + } + } + + public void onAddValidators(AddValidatorsEventArgs e) { + boolean isAdd = false; + List validators = e.getValidators(); + Iterator var4 = validators.iterator(); + + while(true) { + String key; + do { + if (!var4.hasNext()) { + if (isAdd) { + e.getValidators().add(new ContractValidator()); + } + + e.addValidator(new ContUnitProjectValidator()); + return; + } + + AbstractValidator val = (AbstractValidator)var4.next(); + key = val.getOperateKey(); + } while(!"submit".equals(key) && !"audit".equals(key) && !"unaudit".equals(key)); + + isAdd = true; + } + } + + private void updateLastVersionNumber(String paydirection, Object contractid, Object lastversionnumber) { + DynamicObject contract = BusinessDataServiceHelper.loadSingle(contractid, paydirection); + if (contract != null) { + contract.set("lastversionnumber", lastversionnumber); + SaveServiceHelper.save(new DynamicObject[]{contract}); + DynamicObject sourcecontract = contract.getDynamicObject("sourcecontract"); + if (sourcecontract != null) { + this.updateLastVersionNumber(paydirection, sourcecontract.getPkValue(), lastversionnumber); + } + } + + } + + protected void updateContractType(DynamicObject contract) { + Long contractTypeId = (Long)contract.getDynamicObject("contracttype").getPkValue(); + DynamicObject contractType = BusinessDataServiceHelper.loadSingle(contractTypeId, "ec_conttype"); + Boolean isValid = contractType.getBoolean("isvalid"); + if (!isValid) { + Long oldId = contractType.getLong("oldid"); + if (oldId == null || oldId == 0L) { + oldId = contractTypeId; + } + + QFilter filter = new QFilter("isvalid", "=", "1"); + QFilter filter1 = new QFilter("oldid", "=", oldId); + DynamicObject[] contractTypeList = BusinessDataServiceHelper.load("ec_conttype", "isvalid,OldId,lastId,version", new QFilter[]{filter, filter1}); + if (contractTypeList.length != 1) { + } + + DynamicObject newContractType = contractTypeList[0]; + contract.set("contracttype", newContractType.getPkValue()); + SaveServiceHelper.update(contract); + } + + } +}