From 59ee6ccb4267969ed9f9c948624761e3b075963e Mon Sep 17 00:00:00 2001 From: xuhaihui <2098865055@qq.com> Date: Tue, 17 Jun 2025 17:28:05 +0800 Subject: [PATCH] =?UTF-8?q?=E7=B3=BB=E7=BB=9F=E4=BA=8C=E5=BC=80=E6=8F=92?= =?UTF-8?q?=E4=BB=B6=E6=A0=87=E8=AE=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../plugin/form/PaymentTypeValidatorExt.java | 223 ++++++++++++++++++ 1 file changed, 223 insertions(+) create mode 100644 code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/form/PaymentTypeValidatorExt.java diff --git a/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/form/PaymentTypeValidatorExt.java b/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/form/PaymentTypeValidatorExt.java new file mode 100644 index 0000000..af41e73 --- /dev/null +++ b/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/form/PaymentTypeValidatorExt.java @@ -0,0 +1,223 @@ +// +// Source code recreated from a .class file by IntelliJ IDEA +// (powered by FernFlower decompiler) +// + +package zcgj.zcdev.zcdev.pr.plugin.form; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import kd.bos.dataentity.entity.DynamicObject; +import kd.bos.dataentity.entity.DynamicObjectCollection; +import kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType; +import kd.bos.dataentity.resource.ResManager; +import kd.bos.dataentity.utils.StringUtils; +import kd.bos.entity.EntityMetadataCache; +import kd.bos.entity.ExtendedDataEntity; +import kd.bos.entity.MainEntityType; +import kd.bos.entity.ValueMapItem; +import kd.bos.entity.property.ComboProp; +import kd.bos.entity.validate.AbstractValidator; +import kd.bos.orm.query.QFilter; +import kd.bos.servicehelper.QueryServiceHelper; +import kd.ec.basedata.common.enums.BillStatusEnum; +import kd.ec.basedata.common.enums.ContractStatusEnum; +import kd.ec.basedata.common.enums.PlanAmtTypeEnum; + +public class PaymentTypeValidatorExt extends AbstractValidator { + public PaymentTypeValidatorExt() { + } + + public void validate() { + String operateKey = this.getOperateKey(); + if (StringUtils.equals("submit", operateKey)) { + this.validatePayType(); + } + + } + + protected void validatePayType() { + Set balanceContractIds = new HashSet(16); + Set bondContractIds = new HashSet(16); + Set otherSubmitContractIds = new HashSet(16); + Set submitBalanceContractIds = new HashSet(16); + Set contractIds = new HashSet(16); + Set paymentIds = new HashSet(16); + ExtendedDataEntity[] dataEntities = this.getDataEntities(); + ExtendedDataEntity[] var8 = dataEntities; + int var9 = dataEntities.length; + + for(int var10 = 0; var10 < var9; ++var10) { + ExtendedDataEntity dataEntity = var8[var10]; + DynamicObject bill = dataEntity.getDataEntity(); + paymentIds.add(bill.getLong("id")); + DynamicObjectCollection entries = bill.getDynamicObjectCollection("entryentity"); + Iterator var14 = entries.iterator(); + + while(var14.hasNext()) { + DynamicObject entry = (DynamicObject)var14.next(); + String payType = entry.getString("paymenttype"); + long contractId = entry.getDynamicObject("contract").getLong("id"); + contractIds.add(contractId); + if (StringUtils.equals(PlanAmtTypeEnum.BALANCE.getValue(), payType)) { + balanceContractIds.add(contractId); + submitBalanceContractIds.add(contractId); + } else if (StringUtils.equals(PlanAmtTypeEnum.BOND.getValue(), payType)) { + bondContractIds.add(contractId); + } else { + otherSubmitContractIds.add(contractId); + } + } + } + + QFilter filter = new QFilter("entryentity.contract", "in", contractIds); + filter.and("id", "not in", paymentIds); + filter.and("billstatus", "in", new String[]{BillStatusEnum.SUBMIT.getValue(), BillStatusEnum.AUDIT.getValue()}); + DynamicObjectCollection payments = QueryServiceHelper.query("ec_paymentapply", "billstatus,entryentity.contract,entryentity.paymenttype", new QFilter[]{filter}); + Iterator var24 = payments.iterator(); + + while(var24.hasNext()) { + DynamicObject payment = (DynamicObject)var24.next(); + String payType = payment.getString("entryentity.paymenttype"); + long contractId = payment.getLong("entryentity.contract"); + if (StringUtils.equals(PlanAmtTypeEnum.BALANCE.getValue(), payType)) { + balanceContractIds.add(contractId); + if (StringUtils.equals(BillStatusEnum.SUBMIT.getValue(), payment.getString("billstatus"))) { + submitBalanceContractIds.add(contractId); + } + } else if (StringUtils.equals(PlanAmtTypeEnum.BOND.getValue(), payType)) { + bondContractIds.add(contractId); + } else if (StringUtils.equals(BillStatusEnum.SUBMIT.getValue(), payment.getString("billstatus"))) { + otherSubmitContractIds.add(contractId); + } + } + + Map> contractPayPlanTypes = this.getContractPayPlanTypes(contractIds); + Map payTypeCombo = this.getPayTypeCombo(); + ExtendedDataEntity[] var29 = dataEntities; + int var31 = dataEntities.length; + + for(int var32 = 0; var32 < var31; ++var32) { + ExtendedDataEntity dataEntity = var29[var32]; + DynamicObject bill = dataEntity.getDataEntity(); + DynamicObjectCollection entries = bill.getDynamicObjectCollection("entryentity"); + Iterator var18 = entries.iterator(); + + while(var18.hasNext()) { + DynamicObject entry = (DynamicObject)var18.next(); + DynamicObject contract = entry.getDynamicObject("contract"); + String payType = entry.getString("paymenttype"); + this.contractPayPlanValidate(dataEntity, contract, payType, contractPayPlanTypes, payTypeCombo); + this.prePayTypeValidate(dataEntity, contract, payType); + this.payStageValidate(balanceContractIds, bondContractIds, payTypeCombo, dataEntity, contract, payType); + this.payMethodValidate(dataEntity, contract, payType); + this.balanceTypeValidate(otherSubmitContractIds, dataEntity, contract, payType); + this.bondTypeValidate(submitBalanceContractIds, otherSubmitContractIds, dataEntity, contract, payType); + } + } + + } + + protected void contractPayPlanValidate(ExtendedDataEntity dataEntity, DynamicObject contract, String payType, Map> contractPayPlanTypes, Map payTypeCombo) { + Set types = (Set)contractPayPlanTypes.get(contract.getLong("id")); + if (types != null && !types.contains(payType) && !StringUtils.equals(PlanAmtTypeEnum.BALANCE.getValue(), payType)) { + this.addErrorMessage(dataEntity, String.format(ResManager.loadKDString("合同【%1$s】付款条件中不包含付款类型【%2$s】，不允许付款。", "PaymentTypeValidator_8", "ec-contract-opplugin", new Object[0]), contract.getString("name"), payTypeCombo.getOrDefault(payType, ""))); + } + + } + + protected Map> getContractPayPlanTypes(Set contractIds) { + Map> payPlanTypeMap = new HashMap(contractIds.size()); + QFilter contractFilter = new QFilter("id", "in", contractIds); + DynamicObjectCollection contracts = QueryServiceHelper.query("ec_out_contract", "id,outcontpayplanentry.paytype", new QFilter[]{contractFilter}); + + Iterator var5; + long contractId; + Set payPlanTypes; + for(var5 = contracts.iterator(); var5.hasNext(); payPlanTypeMap.put(contractId, payPlanTypes)) { + DynamicObject contract = (DynamicObject)var5.next(); + contractId = contract.getLong("id"); + payPlanTypes = (Set)payPlanTypeMap.getOrDefault(contractId, new HashSet(4)); + String type = contract.getString("outcontpayplanentry.paytype"); + if (StringUtils.isNotEmpty(type)) { + payPlanTypes.add(type); + } + } + + var5 = payPlanTypeMap.values().iterator(); + + while(var5.hasNext()) { + Set planTypes = (Set)var5.next(); + if (planTypes.isEmpty()) { + planTypes.add(PlanAmtTypeEnum.PREPAYMENT.getValue()); + planTypes.add(PlanAmtTypeEnum.SETTLEPAYMENT.getValue()); + planTypes.add(PlanAmtTypeEnum.BALANCE.getValue()); + planTypes.add(PlanAmtTypeEnum.BOND.getValue()); + } + } + + return payPlanTypeMap; + } + + protected void bondTypeValidate(Set submitBalanceContractIds, Set otherSubmitContractIds, ExtendedDataEntity dataEntity, DynamicObject contract, String payType) { + long contractId = contract.getLong("id"); + if (StringUtils.equals(payType, PlanAmtTypeEnum.BOND.getValue()) && (otherSubmitContractIds.contains(contractId) || submitBalanceContractIds.contains(contractId))) { + this.addErrorMessage(dataEntity, String.format(ResManager.loadKDString("合同【%s】存在其他在途付款申请，无法进行质保金支付。", "PaymentTypeValidator_1", "ec-contract-opplugin", new Object[0]), contract.getString("name"))); + } + + } + + protected void balanceTypeValidate(Set otherSubmitContractIds, ExtendedDataEntity dataEntity, DynamicObject contract, String payType) { + if (StringUtils.equals(payType, PlanAmtTypeEnum.BALANCE.getValue()) && otherSubmitContractIds.contains(contract.getLong("id"))) { + this.addErrorMessage(dataEntity, String.format(ResManager.loadKDString("合同【%s】存在其他在途付款申请，无法进行尾款支付。", "PaymentTypeValidator_2", "ec-contract-opplugin", new Object[0]), contract.getString("name"))); + } + + } + + protected void payMethodValidate(ExtendedDataEntity dataEntity, DynamicObject contract, String payType) { + if (contract.getBoolean("ispaybytasknode") && StringUtils.equals(PlanAmtTypeEnum.SETTLEPAYMENT.getValue(), payType)) { + this.addErrorMessage(dataEntity, String.format(ResManager.loadKDString("合同【%s】为按节点支付，无法进行结算款支付。", "PaymentTypeValidator_3", "ec-contract-opplugin", new Object[0]), contract.getString("name"))); + } else if (!contract.getBoolean("ispaybytasknode") && StringUtils.equals(PlanAmtTypeEnum.PROGRESSPAYMENT.getValue(), payType)) { + this.addErrorMessage(dataEntity, String.format(ResManager.loadKDString("合同【%s】为按月支付，无法进行进度款支付。", "PaymentTypeValidator_4", "ec-contract-opplugin", new Object[0]), contract.getString("name"))); + } + + } + + protected void payStageValidate(Set balanceContractIds, Set bondContractIds, Map payTypeCombo, ExtendedDataEntity dataEntity, DynamicObject contract, String payType) { + if (bondContractIds.contains(contract.getLong("id")) && !StringUtils.equals(PlanAmtTypeEnum.BOND.getValue(), payType)) { + this.addErrorMessage(dataEntity, String.format(ResManager.loadKDString("合同【%1$s】已进入质保金支付阶段，无法进行%2$s支付。", "PaymentTypeValidator_9", "ec-contract-opplugin", new Object[0]), contract.getString("name"), payTypeCombo.get(payType))); + } else if (balanceContractIds.contains(contract.getLong("id")) && !StringUtils.equals(PlanAmtTypeEnum.BALANCE.getValue(), payType) && !StringUtils.equals(PlanAmtTypeEnum.BOND.getValue(), payType)) { + this.addErrorMessage(dataEntity, String.format(ResManager.loadKDString("合同【%1$s】已进入尾款支付阶段，无法进行%2$s支付。", "PaymentTypeValidator_10", "ec-contract-opplugin", new Object[0]), contract.getString("name"), payTypeCombo.get(payType))); + } + + } + + protected void prePayTypeValidate(ExtendedDataEntity dataEntity, DynamicObject contract, String payType) { + String contStatus = contract.getString("contstatus"); + if (StringUtils.equals(contStatus, ContractStatusEnum.OVERSETTLE.getValue()) && StringUtils.equals(PlanAmtTypeEnum.PREPAYMENT.getValue(), payType)) { + this.addErrorMessage(dataEntity, String.format(ResManager.loadKDString("合同【%s】已决算，无法进行预付款支付。", "PaymentTypeValidator_7", "ec-contract-opplugin", new Object[0]), contract.getString("name"))); + } + + } + + protected Map getPayTypeCombo() { + MainEntityType paymentType = EntityMetadataCache.getDataEntityType("ec_paymentapply"); + DynamicObject paymentBill = new DynamicObject(paymentType); + DynamicObjectType entryType = paymentBill.getDynamicObjectCollection("entryentity").getDynamicObjectType(); + ComboProp payTypeCombo = (ComboProp)entryType.getProperty("paymenttype"); + List comboItems = payTypeCombo.getComboItems(); + Map payTypeComboMap = new HashMap(comboItems.size()); + Iterator var7 = comboItems.iterator(); + + while(var7.hasNext()) { + ValueMapItem comboItem = (ValueMapItem)var7.next(); + payTypeComboMap.put(comboItem.getValue(), comboItem.getName().getLocaleValue()); + } + + return payTypeComboMap; + } +}