diff --git a/sys/shkd-sys-sys/src/main/java/shkd/sys/sys/plugin/other/newDraftBillToTradeBillConvertPlugin.java b/sys/shkd-sys-sys/src/main/java/shkd/sys/sys/plugin/other/newDraftBillToTradeBillConvertPlugin.java new file mode 100644 index 0000000..ea30fa2 --- /dev/null +++ b/sys/shkd-sys-sys/src/main/java/shkd/sys/sys/plugin/other/newDraftBillToTradeBillConvertPlugin.java @@ -0,0 +1,305 @@ +// +// Source code recreated from a .class file by IntelliJ IDEA +// (powered by FernFlower decompiler) +// + +package shkd.sys.sys.plugin.other; + +import kd.bos.dataentity.entity.DynamicObject; +import kd.bos.dataentity.entity.DynamicObjectCollection; +import kd.bos.dataentity.serialization.SerializationUtils; +import kd.bos.entity.EntityMetadataCache; +import kd.bos.entity.ExtendedDataEntity; +import kd.bos.entity.botp.plugin.AbstractConvertPlugIn; +import kd.bos.entity.botp.plugin.args.AfterBuildQueryParemeterEventArgs; +import kd.bos.entity.botp.plugin.args.AfterFieldMappingEventArgs; +import kd.bos.logging.Log; +import kd.bos.logging.LogFactory; +import kd.bos.orm.query.QFilter; +import kd.tmc.cdm.common.enums.DraftTradeTypeEnum; +import kd.tmc.cdm.common.enums.SettleMentTypeEnum; +import kd.tmc.cdm.common.helper.TradeBillAmountHelper; +import kd.tmc.cdm.common.helper.TradeBillHelper; +import kd.tmc.fbp.common.helper.TmcDataServiceHelper; +import kd.tmc.fbp.common.util.EmptyUtil; + +import java.math.BigDecimal; +import java.util.*; +import java.util.stream.Collectors; + +public class newDraftBillToTradeBillConvertPlugin extends AbstractConvertPlugIn { + private static Log logger = LogFactory.getLog(newDraftBillToTradeBillConvertPlugin.class); + + public newDraftBillToTradeBillConvertPlugin() { + } + + public void afterBuildQueryParemeter(AfterBuildQueryParemeterEventArgs e) { + super.afterBuildQueryParemeter(e); + } + + public void afterFieldMapping(AfterFieldMappingEventArgs e) { + super.afterFieldMapping(e); + String tradeType = this.getOption().getVariableValue("tradeType"); + boolean isFromAuto = this.getOption().containsVariable("isfromauto"); + logger.info("tradeType is:" + tradeType + ",isFromAuto:" + isFromAuto); + String targetEntityNumber = this.getTgtMainType().getName(); + ExtendedDataEntity[] billDataEntitys = e.getTargetExtDataEntitySet().FindByEntityKey(targetEntityNumber); + ExtendedDataEntity[] var6 = billDataEntitys; + int var7 = billDataEntitys.length; + + for(int var8 = 0; var8 < var7; ++var8) { + ExtendedDataEntity billDataEntity = var6[var8]; + DynamicObject targetBill = billDataEntity.getDataEntity(); + targetBill.set("tradetype", tradeType); + DynamicObject billType = TmcDataServiceHelper.loadSingle(DraftTradeTypeEnum.getType(tradeType), "bos_billtype"); + targetBill.set("billtype", billType); +// targetBill.set("payeetypetext", "bd_supplier"); +// targetBill.set("payeetype", "bd_supplier"); +// targetBill.set("beendorsor", (Object)null); + this.initFeilds(targetBill); + TradeBillAmountHelper.calcTradeBillAmount(targetBill); + String isPledged = this.getOption().getVariableValue("isPledged", "false"); + if ("true".equals(isPledged)) { + long tradeBillId = Long.parseLong(this.getOption().getVariableValue("tradeBillId", "0")); + DynamicObject tradeBill = TmcDataServiceHelper.loadSingle(tradeBillId, EntityMetadataCache.getDataEntityType("cdm_drafttradebill")); + DynamicObjectCollection entry = tradeBill.getDynamicObjectCollection("entrys"); + Map draftIdToBillLogIdMap = (Map)entry.stream().collect(Collectors.toMap((o) -> { + return o.getDynamicObject("draftbill").getLong("id"); + }, (o) -> { + return o.getLong("billlogid"); + }, (a, b) -> { + return a; + })); + DynamicObjectCollection sourceEntry = targetBill.getDynamicObjectCollection("entrys"); + BigDecimal amount = BigDecimal.ZERO; + + DynamicObject dynamicObject; + for(Iterator var20 = sourceEntry.iterator(); var20.hasNext(); amount = amount.add(dynamicObject.getBigDecimal("billamt"))) { + dynamicObject = (DynamicObject)var20.next(); + dynamicObject.set("billlogid", draftIdToBillLogIdMap.get(dynamicObject.getDynamicObject("draftbill").getLong("id"))); + dynamicObject.set("billamt", dynamicObject.getDynamicObject("draftbill").getBigDecimal("amount")); + } + + targetBill.set("source", "fromcollect"); + targetBill.set("sourcebillid", tradeBillId); + targetBill.set("amount", amount); + } + + this.fillDepositEntryWhenAutoCall(tradeType, isFromAuto, targetBill); + } + + } + + private void fillDepositEntryWhenAutoCall(String tradeType, boolean isFromAuto, DynamicObject targetBill) { + if (isFromAuto && "payoff".equals(tradeType)) { + boolean depositDeduct = targetBill.getBoolean("depositdeduct"); + if (depositDeduct) { + DynamicObjectCollection selectEntrys = targetBill.getDynamicObjectCollection("entrys"); + if (EmptyUtil.isNoEmpty(selectEntrys)) { + new ArrayList(); + List draftListIds = (List)selectEntrys.stream().filter(Objects::nonNull).map((o) -> { + return o.getDynamicObject("draftbill").getLong("id"); + }).collect(Collectors.toList()); + DynamicObject[] billsList = TmcDataServiceHelper.load("cdm_payablebill", "id,draftbillno,sourcebillid,source", new QFilter[]{new QFilter("id", "in", draftListIds)}); + logger.info("draftListIds is that is:" + SerializationUtils.toJsonString(draftListIds)); + Map billIdAndBillMap = (Map)Arrays.stream(billsList).collect(Collectors.toMap((e1) -> { + return e1.getLong("id"); + }, (e1) -> { + return e1; + })); + Map> billIdAndSuretyIdMap = TradeBillHelper.loadSurety(billsList); + Map> dpBillMap = new HashMap(); + Map dpBillDyMap = new HashMap(); + Iterator var12 = billIdAndSuretyIdMap.entrySet().iterator(); + + while(true) { + while(var12.hasNext()) { + Map.Entry> entry = (Map.Entry)var12.next(); + Long key = (Long)entry.getKey(); + logger.info("key is that:" + key); + DynamicObject draft = (DynamicObject)billIdAndBillMap.get(key); + if (null == draft) { + logger.info("draft is null:" + key); + } else { + String billno = draft.getString("draftbillno"); + List dpEntrys = (List)entry.getValue(); + Iterator var18 = dpEntrys.iterator(); + + while(var18.hasNext()) { + DynamicObject depositDyj = (DynamicObject)var18.next(); + long dpId = depositDyj.getLong("id"); + if (dpBillMap.containsKey(dpId)) { + ((Set)dpBillMap.get(dpId)).add(billno); + } else { + Set set = new HashSet(); + set.add(billno); + dpBillMap.put(dpId, set); + } + + if (!dpBillDyMap.containsKey(dpId)) { + dpBillDyMap.put(dpId, depositDyj); + } + } + } + } + + Set longSet = dpBillMap.keySet(); + ArrayList dpIdList = new ArrayList(longSet); + DynamicObjectCollection depositentrys = targetBill.getDynamicObjectCollection("depositentry"); + + for(int i = 0; i < dpIdList.size(); ++i) { + Long dpId = (Long)dpIdList.get(i); + Set billNos = (Set)dpBillMap.get(dpId); + StringJoiner billnoStr = new StringJoiner(";"); + Iterator var30 = billNos.iterator(); + + while(var30.hasNext()) { + String billNo = (String)var30.next(); + billnoStr.add(billNo); + } + + String billnosString = billnoStr.toString() + ";"; + DynamicObject depositentry = depositentrys.addNew(); + depositentry.set("dpbillnos_tag", billnosString); + String substr = billnosString; + if (billnosString.length() > 255) { + substr = billnosString.substring(0, 245) + "..."; + } + + depositentry.set("dpbillnos", substr); + this.createDpDataRow(billNos, (DynamicObject)dpBillDyMap.get(dpId), depositentry); + } + + this.calcDepositData(targetBill); + break; + } + } + } + } + + } + + private void calcDepositData(DynamicObject targetBill) { + DynamicObjectCollection dpEntrys = targetBill.getDynamicObjectCollection("depositentry"); + BigDecimal deductamount = BigDecimal.ZERO; + + BigDecimal dpdeductamount; + BigDecimal dinterestamount; + for(Iterator var4 = dpEntrys.iterator(); var4.hasNext(); deductamount = deductamount.add(dpdeductamount).add(dinterestamount)) { + DynamicObject dpEntry = (DynamicObject)var4.next(); + dpdeductamount = dpEntry.getBigDecimal("dpdeductamount"); + dinterestamount = dpEntry.getBigDecimal("dinterestamount"); + if (EmptyUtil.isEmpty(dpdeductamount)) { + dpdeductamount = BigDecimal.ZERO; + } + + if (EmptyUtil.isEmpty(dpdeductamount)) { + dinterestamount = BigDecimal.ZERO; + } + } + + targetBill.set("deductamount", deductamount); + } + + private void createDpDataRow(Set billNos, DynamicObject depositDyj, DynamicObject depositentry) { + QFilter draftBillNoFilter = new QFilter("draftbillno", "in", billNos); + QFilter rpTypeFilter = new QFilter("rptype", "=", "paybill"); + QFilter billStatusFilter = new QFilter("billstatus", "=", "C"); + QFilter draftBillStatusFilter = new QFilter("draftbillstatus", "=", "registered"); + DynamicObject[] payableBills = TmcDataServiceHelper.load("cdm_payablebill", "id,suretymoney", new QFilter[]{draftBillNoFilter, rpTypeFilter, billStatusFilter, draftBillStatusFilter}); + BigDecimal suretyMoneyTotal = BigDecimal.ZERO; + DynamicObject[] var10 = payableBills; + int var11 = payableBills.length; + + for(int var12 = 0; var12 < var11; ++var12) { + DynamicObject payableBill = var10[var12]; + suretyMoneyTotal = suretyMoneyTotal.add(payableBill.getBigDecimal("suretymoney")); + } + + BigDecimal surplusAmount = EmptyUtil.isEmpty(depositDyj.getBigDecimal("surplusamount")) ? BigDecimal.ZERO : depositDyj.getBigDecimal("surplusamount"); + BigDecimal defaultSuretyAmount = surplusAmount.compareTo(suretyMoneyTotal) >= 0 ? suretyMoneyTotal : surplusAmount; + depositentry.set("guarantway", "deposit"); + depositentry.set("dpbillno", depositDyj); + depositentry.set("dpremainamount", depositDyj.getBigDecimal("surplusamount")); + depositentry.set("dpsource", "gm"); + depositentry.set("dpdeductamount", defaultSuretyAmount); + } + + private void initFeilds(DynamicObject targetBill) { + Set currencyIds = new HashSet(); + Set recBodyNames = new HashSet(); + DynamicObjectCollection entrys = targetBill.getDynamicObjectCollection("entrys"); + String tradeType = targetBill.getString("tradetype"); + if (!EmptyUtil.isEmpty(entrys)) { + Set draftbillId = (Set)entrys.stream().map((e) -> { + return e.getDynamicObject("draftbill").getLong("id"); + }).collect(Collectors.toSet()); + Map amountMap = new HashMap(16); + if (DraftTradeTypeEnum.PAYINTEREST.getValue().equals(tradeType) || DraftTradeTypeEnum.REDEEM.getValue().equals(tradeType)) { + amountMap = TradeBillAmountHelper.getTradeAmountByTradeType(tradeType, draftbillId, (Long)null); + } + + DynamicObject[] draftBills = TmcDataServiceHelper.load(draftbillId.toArray(new Object[0]), EntityMetadataCache.getDataEntityType("cdm_draftbillf7")); + Map draftIdAndDyMap = (Map)Arrays.stream(draftBills).collect(Collectors.toMap((e) -> { + return e.getLong("id"); + }, (e) -> { + return e; + })); + Iterator var10 = entrys.iterator(); + + label52: + while(true) { + while(true) { + DynamicObject entry; + DynamicObject selectDraftBill; + do { + if (!var10.hasNext()) { + if (DraftTradeTypeEnum.REDEEM.getValue().equals(tradeType)) { + targetBill.set("company", draftBills[0].getDynamicObject("acceptercompany").getPkValue()); + } + break label52; + } + + entry = (DynamicObject)var10.next(); + selectDraftBill = entry.getDynamicObject("draftbill"); + } while(!EmptyUtil.isNoEmpty(selectDraftBill)); + + DynamicObject draftBill = (DynamicObject)draftIdAndDyMap.get(selectDraftBill.getLong("id")); + entry.set("draftbill", draftBill); + selectDraftBill = entry.getDynamicObject("draftbill"); + Object curreyId = selectDraftBill.getDynamicObject("currency").getPkValue(); + currencyIds.add(curreyId); + recBodyNames.add(selectDraftBill.getString("acceptername")); + if (!DraftTradeTypeEnum.PAYINTEREST.getValue().equals(tradeType) && !DraftTradeTypeEnum.REDEEM.getValue().equals(tradeType)) { + entry.set("billamt", selectDraftBill.getBigDecimal("availableamount")); + } else { + BigDecimal amount = selectDraftBill.getBigDecimal("amount"); + BigDecimal dataBaseBillAmt = (BigDecimal)((Map)amountMap).getOrDefault(draftBill.getLong("id"), BigDecimal.ZERO); + entry.set("billamt", amount.subtract(dataBaseBillAmt)); + } + } + } + } + + logger.info("currencyIds.size():" + currencyIds.size()); + DynamicObject draftType; + if (currencyIds.size() != 1) { + targetBill.set("currency", (Object)null); + } else { + draftType = ((DynamicObject)entrys.get(0)).getDynamicObject("draftbill").getDynamicObject("currency"); + targetBill.set("currency", draftType); + } + + draftType = targetBill.getDynamicObject("drafttype"); + if (null != draftType) { + String setTlementType = draftType.getString("settlementtype"); + if ((tradeType.equals(DraftTradeTypeEnum.COLLECT.getValue()) || tradeType.equals(DraftTradeTypeEnum.DISCOUNT.getValue())) && SettleMentTypeEnum.BUSINESS.getValue().equals(setTlementType) && recBodyNames.size() != 1) { + targetBill.set("recbodyname", (Object)null); + } + } + + } + + private void calcDeInterestAmountAllEntry(DynamicObject targetBill) { + } +}