租赁合同id带入资产卡片

src/main/java/kd/fi/fa/business/cardgenerate/CardGenerateHelperEx.java

@@ -0,0 +1,323 @@
+package kd.fi.fa.business.cardgenerate;
+
+import java.util.ArrayList;
+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.algo.DataSet;
+import kd.bos.algo.Row;
+import kd.bos.dataentity.OperateOption;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.LocaleString;
+import kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.entity.EntityMetadataCache;
+import kd.bos.entity.MainEntityType;
+import kd.bos.entity.operate.result.IOperateInfo;
+import kd.bos.entity.operate.result.OperationResult;
+import kd.bos.entity.property.EntryProp;
+import kd.bos.exception.KDBizException;
+import kd.bos.orm.query.QFilter;
+import kd.bos.orm.util.CollectionUtils;
+import kd.bos.servicehelper.BusinessDataServiceHelper;
+import kd.bos.servicehelper.DBServiceHelper;
+import kd.bos.servicehelper.QueryServiceHelper;
+import kd.bos.servicehelper.operation.OperationServiceHelper;
+import kd.bos.workflow.engine.impl.util.CollectionUtil;
+import kd.fi.fa.business.SourceFlagEnum;
+import kd.fi.fa.business.cardgenerate.impl.AbstractFinCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.AddCardToFinCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.AssetCardToFinCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.DispatchToFinCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.DispatchToRealCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.EngineeringToFinCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.InitLeaseContractToFinCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.InventoryProfitToFinCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.LeaseContractToFinCardGenerate;
+import kd.fi.fa.business.cardgenerate.impl.PurchaseToFinCardGenerate;
+import kd.fi.fa.business.errorcode.FinCardErrorCode;
+import kd.fi.fa.business.utils.FaCommonUtils;
+import kd.fi.fa.business.utils.FaUtils;
+import kd.fi.fa.common.util.Fa;
+
+public class CardGenerateHelperEx {
+    public CardGenerateHelperEx() {
+    }
+
+    public static final Object[] generateRealCard(DynamicObject srcBill) {
+        IRealCardGenerate generate = null;
+        DynamicObjectType dt = srcBill.getDynamicObjectType();
+        if (!"fa_dispatch_in".equals(dt.getName()) && !"fa_dispatch".equals(dt.getName())) {
+            throw new KDBizException(FinCardErrorCode.FINCARD_GENERATE_ERROR, new Object[0]);
+        } else {
+            generate = new DispatchToRealCardGenerate(srcBill.getPkValue());
+            return generate.generateRealCard();
+        }
+    }
+
+    public static void generateFinCard(List<DynamicObject> objects) {
+        MainEntityType finCardType = EntityMetadataCache.getDataEntityType("fa_card_fin");
+        DynamicObjectType billHeadType = ((EntryProp)finCardType.getProperty("billhead_lk")).getDynamicCollectionItemPropertyType();
+        Long realCardTableId = EntityMetadataCache.loadTableDefine("fa_card_real", "fa_card_real").getTableId();
+        AbstractFinCardGenerate generate = null;
+        List<DynamicObject> dynamicAdd = new ArrayList();
+        List<DynamicObject> dynamicPurchase = new ArrayList();
+        List<DynamicObject> dynamicDispatch = new ArrayList();
+        List<DynamicObject> dynamicInventory = new ArrayList();
+        List<DynamicObject> dynamicEnginner = new ArrayList();
+        List<DynamicObject> dynamicLease = new ArrayList();
+        List<DynamicObject> dynamicInitLease = new ArrayList();
+        List<DynamicObject> callbackFincards = new ArrayList();
+        Map<Object, DynamicObject[]> orgAssetBooksMap = getAssetBooksByOrg(objects);
+        Iterator var14 = objects.iterator();
+
+        while(true) {
+            while(var14.hasNext()) {
+                DynamicObject dynamicObject = (DynamicObject)var14.next();
+                long realCardId = dynamicObject.getLong("id");
+                Object sourceFlag = dynamicObject.get("sourceflag");
+                boolean justrealcard = dynamicObject.getBoolean("justrealcard");
+                if (justrealcard) {
+                    dynamicObject.set("bizstatus", "READY");
+                } else if (!FaCommonUtils.equals(SourceFlagEnum.ADD, sourceFlag) && !FaCommonUtils.equals(SourceFlagEnum.IMPORT, sourceFlag) && !FaCommonUtils.equals(SourceFlagEnum.INITIAL, sourceFlag) && !FaCommonUtils.equals(SourceFlagEnum.INVENTORYPROFIT, sourceFlag) && !FaCommonUtils.equals(SourceFlagEnum.DATAASSET, sourceFlag) && !FaCommonUtils.equals(SourceFlagEnum.SCAN, sourceFlag)) {
+                    if (FaCommonUtils.equals(SourceFlagEnum.PURCHASE, sourceFlag)) {
+                        dynamicPurchase.add(dynamicObject);
+                    } else if (FaCommonUtils.equals(SourceFlagEnum.DISPATCH, sourceFlag)) {
+                        dynamicDispatch.add(dynamicObject);
+                    } else if (FaCommonUtils.equals(SourceFlagEnum.INVENTORYPROFIT, sourceFlag)) {
+                        dynamicInventory.add(dynamicObject);
+                    } else if (FaCommonUtils.equals(SourceFlagEnum.ENGINEERINGTRANS, sourceFlag)) {
+                        dynamicEnginner.add(dynamicObject);
+                    } else if (FaCommonUtils.equals(SourceFlagEnum.LEASECONTRACT, sourceFlag)) {
+                        dynamicLease.add(dynamicObject);
+                    } else {
+                        if (!FaCommonUtils.equals(SourceFlagEnum.INITLEASECONTRACT, sourceFlag)) {
+                            throw new KDBizException(FinCardErrorCode.FINCARD_GENERATE_ERROR, new Object[0]);
+                        }
+
+                        dynamicInitLease.add(dynamicObject);
+                    }
+                } else {
+                    dynamicAdd.add(dynamicObject);
+                }
+            }
+
+            Map<Object, Object> finCardAndrealCard = new HashMap();
+            if (CollectionUtil.isNotEmpty(dynamicAdd)) {
+                generate = new AddCardToFinCardGenerate();
+                callbackFincards.addAll(generate.generateDynamicFinCard(dynamicAdd, orgAssetBooksMap, finCardType, billHeadType, realCardTableId, finCardAndrealCard));
+            }
+
+            if (CollectionUtil.isNotEmpty(dynamicPurchase)) {
+                generate = new PurchaseToFinCardGenerate();
+                callbackFincards.addAll(generate.generateDynamicFinCard(dynamicPurchase, orgAssetBooksMap, finCardType, billHeadType, realCardTableId, finCardAndrealCard));
+            }
+
+            if (CollectionUtil.isNotEmpty(dynamicDispatch)) {
+                generate = new DispatchToFinCardGenerate();
+                callbackFincards.addAll(generate.generateDynamicFinCard(dynamicDispatch, orgAssetBooksMap, finCardType, billHeadType, realCardTableId, finCardAndrealCard));
+            }
+
+            if (CollectionUtil.isNotEmpty(dynamicInventory)) {
+                generate = new InventoryProfitToFinCardGenerate();
+                callbackFincards.addAll(generate.generateDynamicFinCard(dynamicInventory, orgAssetBooksMap, finCardType, billHeadType, realCardTableId, finCardAndrealCard));
+            }
+
+            if (CollectionUtil.isNotEmpty(dynamicEnginner)) {
+                generate = new EngineeringToFinCardGenerate();
+                callbackFincards.addAll(generate.generateDynamicFinCard(dynamicEnginner, orgAssetBooksMap, finCardType, billHeadType, realCardTableId, finCardAndrealCard));
+            }
+
+            if (CollectionUtil.isNotEmpty(dynamicLease)) {
+                generate = new LeaseContractToFinCardGenerate();
+                callbackFincards.addAll(generate.generateDynamicFinCard(dynamicLease, orgAssetBooksMap, finCardType, billHeadType, realCardTableId, finCardAndrealCard));
+                Map<Long, Long> leaseMap = new HashMap<>();
+                for (DynamicObject object : dynamicLease) {
+                    long id = object.getLong("id");
+                    long srcbillid = object.getLong("srcbillid");
+                    leaseMap.put(id, srcbillid);
+                }
+                for (DynamicObject callbackFincard : callbackFincards) {
+                    long realcardmasterid = callbackFincard.getLong("realcardmasterid");
+                    if (leaseMap.containsKey(realcardmasterid)) {
+                        long srcbillid = leaseMap.get(realcardmasterid);
+                        callbackFincard.set("nckd_bigintfield", srcbillid);
+                    }
+                }
+            }
+
+            if (CollectionUtil.isNotEmpty(dynamicInitLease)) {
+                generate = new InitLeaseContractToFinCardGenerate();
+                callbackFincards.addAll(generate.generateDynamicFinCard(dynamicInitLease, orgAssetBooksMap, finCardType, billHeadType, realCardTableId, finCardAndrealCard));
+            }
+
+            OperateOption operateOption = OperateOption.create();
+            operateOption.setVariableValue("genfincard", "true");
+            operateOption.setVariableValue("ignore_validate_initial_fincard", "true");
+            operateOption.setVariableValue("ignoreAssetBookStatus", "true");
+            OperationResult result = OperationServiceHelper.executeOperate("save", "fa_card_fin", (DynamicObject[])callbackFincards.toArray(new DynamicObject[0]), operateOption);
+            if (result.isSuccess()) {
+                return;
+            }
+
+            List<IOperateInfo> allError = result.getAllErrorOrValidateInfo();
+            result.getAllErrorInfo();
+            StringBuilder errorInfo = new StringBuilder();
+            if (!CollectionUtils.isEmpty(allError)) {
+                Iterator var31 = allError.iterator();
+
+                while(var31.hasNext()) {
+                    IOperateInfo in = (IOperateInfo)var31.next();
+                    errorInfo.append(in.getMessage());
+                }
+            }
+
+            String msg = (new LocaleString(String.format("%s%s-%s", ResManager.loadKDString("生成财务卡片失败,审核事务失败", "CardGenerateHelper_0", "fi-fa-business", new Object[0]), result.getMessage(), errorInfo.toString()))).toString();
+            throw new KDBizException(msg);
+        }
+    }
+
+    public static Map<Long, Map<Long, DynamicObject>> generateFinCardForAssetCard(List<DynamicObject> realCardList, String entityName) {
+        String finEntityName = "";
+        if (entityName.equals("fa_asset_card")) {
+            finEntityName = "fa_card_fin";
+        }
+
+        if (entityName.equals("fa_asset_initcard")) {
+            finEntityName = "fa_initcard_fin";
+        }
+
+        MainEntityType finCardType = EntityMetadataCache.getDataEntityType(finEntityName);
+        DynamicObjectType billHeadType = ((EntryProp)finCardType.getProperty("billhead_lk")).getDynamicCollectionItemPropertyType();
+        Long realCardTableId = EntityMetadataCache.loadTableDefine("fa_card_real", "fa_card_real").getTableId();
+        Map<Object, DynamicObject[]> orgAssetBookMap = getAssetBooksByOrg(realCardList);
+        Map<Object, Object> finCardAndrealCard = new HashMap(realCardList.size());
+        AbstractFinCardGenerate generate = new AssetCardToFinCardGenerate();
+        List<DynamicObject> finCardList = generate.generateDynamicFinCard(realCardList, orgAssetBookMap, finCardType, billHeadType, realCardTableId, finCardAndrealCard);
+        Map<Long, Map<Long, DynamicObject>> finCardMap = new HashMap(finCardList.size());
+        Iterator var11 = finCardList.iterator();
+
+        while(var11.hasNext()) {
+            DynamicObject finCard = (DynamicObject)var11.next();
+            long fid = DBServiceHelper.genGlobalLongId();
+            finCard.set("id", fid);
+            long realCardId = finCard.getLong(Fa.id("realcard"));
+            long depreUseId = finCard.getLong(Fa.id("depreuse"));
+            Map<Long, DynamicObject> depreUseCardMap = (Map)finCardMap.computeIfAbsent(realCardId, (v) -> {
+                return new HashMap(4);
+            });
+            depreUseCardMap.put(depreUseId, finCard);
+            finCard.getDynamicObjectCollection("billhead_lk").clear();
+        }
+
+        return finCardMap;
+    }
+
+    private static Map<Object, DynamicObject[]> getAssetBooksByOrg(List<DynamicObject> realCards) {
+        Set<Long> orgIds = new HashSet(4);
+        Set<Long> realCardIds = new HashSet(FaUtils.getInitialCapacity43(realCards.size()));
+        Iterator var3 = realCards.iterator();
+
+        while(var3.hasNext()) {
+            DynamicObject realCard = (DynamicObject)var3.next();
+            orgIds.add(realCard.getLong(Fa.id("org")));
+            realCardIds.add(realCard.getLong("id"));
+        }
+
+        QFilter filters = new QFilter("org", "in", orgIds);
+        String sic = Fa.join(",", new String[]{"id", "depreuse", "org", "ismainbook", "basecurrency", "periodtype", "depresystem", "curperiod", "isgroupbook", "exchangetable", "status", "startperiod"});
+        Map<Object, DynamicObject> assetBook4Load = BusinessDataServiceHelper.loadFromCache("fa_assetbook", sic, new QFilter[]{filters});
+        Map<Long, Set<DynamicObject>> org2AssetBooks = new HashMap(FaUtils.getInitialCapacity43(orgIds.size()));
+        Iterator var7 = assetBook4Load.values().iterator();
+
+        while(var7.hasNext()) {
+            DynamicObject assetBook = (DynamicObject)var7.next();
+            long orgId = assetBook.getLong(Fa.id("org"));
+            Set<DynamicObject> assetBooks = (Set)org2AssetBooks.computeIfAbsent(orgId, (k) -> {
+                return new HashSet(4);
+            });
+            assetBooks.add(assetBook);
+        }
+
+        DataSet finCards = QueryServiceHelper.queryDataSet("getAssetBooksByOrg.realCardsQueryFinCards", "fa_card_fin", Fa.comma(new String[]{"realcard", "assetbook"}), new QFilter[]{new QFilter("realcard", "in", realCardIds), new QFilter("endperiod", "=", 99999999999L)}, (String)null);
+        Map<Long, Set<Long>> realCardId2AssetBookIds = new HashMap(realCards.size());
+
+        while(finCards.hasNext()) {
+            Row next = finCards.next();
+            long realCardId = next.getLong("realcard");
+            Set<Long> assetBookIds = (Set)realCardId2AssetBookIds.computeIfAbsent(realCardId, (v) -> {
+                return new HashSet(4);
+            });
+            assetBookIds.add(next.getLong("assetbook"));
+        }
+
+        Map<Object, DynamicObject[]> realCardId2AssetBooks = new HashMap(FaUtils.getInitialCapacity43(realCards.size()));
+        Iterator var31 = realCards.iterator();
+
+        while(true) {
+            while(true) {
+                while(true) {
+                    while(true) {
+                        long realCardId;
+                        boolean isFromLease;
+                        Set assetBookIds;
+                        Set assetBooks;
+                        do {
+                            if (!var31.hasNext()) {
+                                return realCardId2AssetBooks;
+                            }
+
+                            DynamicObject realCard = (DynamicObject)var31.next();
+                            long orgId = realCard.getLong(Fa.id("org"));
+                            realCardId = realCard.getLong("id");
+                            isFromLease = SourceFlagEnum.INITLEASECONTRACT.name().equals(realCard.getString("sourceflag")) || SourceFlagEnum.LEASECONTRACT.name().equals(realCard.getString("sourceflag"));
+                            assetBookIds = (Set)realCardId2AssetBookIds.get(realCardId);
+                            assetBooks = (Set)org2AssetBooks.get(orgId);
+                        } while(assetBooks == null);
+
+                        if (assetBookIds == null) {
+                            if (isFromLease) {
+                                Iterator var34 = assetBooks.iterator();
+
+                                while(var34.hasNext()) {
+                                    DynamicObject assetBook = (DynamicObject)var34.next();
+                                    if (assetBook.getBoolean("ismainbook")) {
+                                        realCardId2AssetBooks.put(realCardId, new DynamicObject[]{assetBook});
+                                        break;
+                                    }
+                                }
+                            } else {
+                                DynamicObject[] array = (DynamicObject[]) assetBooks.toArray(new DynamicObject[0]);
+                                realCardId2AssetBooks.put(realCardId, array);
+                            }
+                        } else {
+                            Set<DynamicObject> books = new HashSet(FaUtils.getInitialCapacity43(assetBooks.size()));
+                            Iterator var20 = assetBooks.iterator();
+
+                            while(var20.hasNext()) {
+                                DynamicObject assetBook = (DynamicObject)var20.next();
+                                boolean mainBook = assetBook.getBoolean("ismainbook");
+                                long assetBookId = assetBook.getLong("id");
+                                if (!assetBookIds.contains(assetBookId)) {
+                                    if (isFromLease) {
+                                        if (mainBook) {
+                                            books.add(assetBook);
+                                            break;
+                                        }
+                                    } else {
+                                        books.add(assetBook);
+                                    }
+                                }
+                            }
+
+                            realCardId2AssetBooks.put(realCardId, books.toArray(new DynamicObject[0]));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/kd/fi/fa/opplugin/realcard/FaRealCardAuditOpEx.java

@@ -0,0 +1,218 @@
+package kd.fi.fa.opplugin.realcard;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import kd.bos.algo.DataSet;
+import kd.bos.algo.Row;
+import kd.bos.dataentity.OperateOption;
+import kd.bos.dataentity.entity.CloneUtils;
+import kd.bos.dataentity.entity.DataEntityBase;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.db.DB;
+import kd.bos.db.DBRoute;
+import kd.bos.db.SqlBuilder;
+import kd.bos.entity.ExtendedDataEntity;
+import kd.bos.entity.plugin.AddValidatorsEventArgs;
+import kd.bos.entity.plugin.args.BeginOperationTransactionArgs;
+import kd.bos.entity.plugin.args.EndOperationTransactionArgs;
+import kd.bos.entity.validate.AbstractValidator;
+import kd.bos.exception.KDBizException;
+import kd.bos.orm.query.QFilter;
+import kd.bos.servicehelper.BusinessDataServiceHelper;
+import kd.bos.servicehelper.QueryServiceHelper;
+import kd.bos.servicehelper.operation.SaveServiceHelper;
+import kd.fi.fa.business.cardgenerate.CardGenerateHelperEx;
+import kd.fi.fa.business.operate.IFaOpHandler;
+import kd.fi.fa.business.utils.AttachmentUtils;
+import kd.fi.fa.business.utils.FunctionMutexHelperV2Utils;
+import kd.fi.fa.common.util.Fa;
+import kd.fi.fa.utils.FaOpUtils;
+
+public class FaRealCardAuditOpEx extends FaAbstractRealCardOp implements IFaOpHandler {
+    public FaRealCardAuditOpEx() {
+    }
+
+    public void onAddValidators(AddValidatorsEventArgs e) {
+        super.onAddValidators(e);
+        e.addValidator(new AbstractValidator() {
+            public void validate() {
+                ExtendedDataEntity[] dataEntities = this.getDataEntities();
+                Map<Long, String> orgIdToNumber = new HashMap(4);
+                ExtendedDataEntity[] var3 = dataEntities;
+                int var4 = dataEntities.length;
+
+                for(int var5 = 0; var5 < var4; ++var5) {
+                    ExtendedDataEntity dataEntity = var3[var5];
+                    long orgId = dataEntity.getDataEntity().getLong(Fa.id("org"));
+                    if (orgIdToNumber.get(orgId) == null) {
+                        String number = dataEntity.getDataEntity().getDynamicObject("org").getString("number");
+                        orgIdToNumber.put(orgId, number);
+                    }
+                }
+
+                DynamicObjectCollection mainBooks = QueryServiceHelper.query("fa_assetbook", "org", new QFilter[]{new QFilter("org", "in", orgIdToNumber.keySet()), new QFilter("ismainbook", "=", true)});
+                Set<Long> bookOrgIds = (Set)mainBooks.stream().map((v) -> {
+                    return v.getLong("org");
+                }).collect(Collectors.toSet());
+                String numbers = "";
+                Iterator var13 = orgIdToNumber.entrySet().iterator();
+
+                while(var13.hasNext()) {
+                    Map.Entry<Long, String> entry = (Map.Entry)var13.next();
+                    if (!bookOrgIds.contains(entry.getKey())) {
+                        numbers = "、" + (String)entry.getValue();
+                    }
+                }
+
+                if (!numbers.isEmpty()) {
+                    throw new KDBizException(String.format(ResManager.loadKDString("核算组织[%s]不存在主账簿。", "FaRealCardAuditOp_0", "fi-fa-opplugin", new Object[0]), numbers.substring(1)));
+                }
+            }
+        });
+    }
+
+    public void beginOperationTransaction(BeginOperationTransactionArgs e) {
+        String operationKey = e.getOperationKey();
+        Map<String, Object> otherParams = new HashMap(1, 1.0F);
+        otherParams.put("beginArgs", e);
+        FunctionMutexHelperV2Utils.doFaOpWithWithOrgPcChildLock(operationKey, "fa_card_real", e.getDataEntities(), otherParams, this);
+    }
+
+    public void endOperationTransaction(EndOperationTransactionArgs e) {
+        super.endOperationTransaction(e);
+        this.updateAuditInfo4OriReal(e);
+    }
+
+    public void doFaOp(String operationKey, String billName, DynamicObject[] dataEntities, Map<String, Object> otherParams) {
+        BeginOperationTransactionArgs e = (BeginOperationTransactionArgs)otherParams.get("beginArgs");
+        OperateOption option = this.getOption();
+        boolean assetCardOperate = option.containsVariable("assetCardOperate");
+        this.createOriginalReal(e);
+        if (!assetCardOperate) {
+            this.createFinCard(e);
+        }
+
+        super.restoreInitFields(e);
+    }
+
+    private void createOriginalReal(BeginOperationTransactionArgs e) {
+        DynamicObject[] dataEntities = e.getDataEntities();
+        List<Long> realCardIds = new ArrayList(dataEntities.length);
+        DynamicObject[] var4 = dataEntities;
+        int var5 = dataEntities.length;
+
+        for(int var6 = 0; var6 < var5; ++var6) {
+            DynamicObject data = var4[var6];
+            realCardIds.add(data.getLong("id"));
+        }
+
+        Collection<DynamicObject> realCards = BusinessDataServiceHelper.loadFromCache("fa_card_real", new QFilter[]{new QFilter("id", "in", realCardIds)}).values();
+        List<DynamicObject> oriRealCards = new ArrayList(realCards.size());
+        long[] ids = DB.genLongIds("t_fa_card_real", realCards.size());
+        Map<Object, List<Object>> sourceId2TargetIdMap = new HashMap(realCards.size());
+        int i = 0;
+
+        for(Iterator var9 = realCards.iterator(); var9.hasNext(); ++i) {
+            DynamicObject realCard = (DynamicObject)var9.next();
+            DynamicObject oriRealCard = (DynamicObject)(new CloneUtils(true, true)).clone(realCard);
+            oriRealCard.set("id", ids[i]);
+            oriRealCard.set("isbak", Boolean.TRUE);
+            oriRealCard.set("originaldata", Boolean.TRUE);
+            oriRealCards.add(oriRealCard);
+            List<Object> targetIds = new ArrayList(1);
+            targetIds.add(ids[i]);
+            sourceId2TargetIdMap.put(realCard.getLong("id"), targetIds);
+        }
+
+        SaveServiceHelper.save((DynamicObject[])oriRealCards.toArray(new DynamicObject[0]));
+        Set<Object> pks = (Set)realCards.stream().map(DataEntityBase::getPkValue).collect(Collectors.toSet());
+        SqlBuilder sql = new SqlBuilder();
+        sql.append("update t_fa_card_real set foriginaldata = '0' where foriginaldata = '1' and ", new Object[0]);
+        sql.appendIn(" fid ", pks.toArray(new Object[0]));
+        DB.execute(DBRoute.of("fa"), sql);
+        AttachmentUtils.copyAttachments("fa_card_real", "fa_card_real", "attachmentpanel", sourceId2TargetIdMap);
+    }
+
+    private void updateAuditInfo4OriReal(EndOperationTransactionArgs e) {
+        DynamicObject[] dataEntities = e.getDataEntities();
+        List<Long> realCardIds = new ArrayList(dataEntities.length);
+        DynamicObject[] var4 = dataEntities;
+        int var5 = dataEntities.length;
+
+        for(int var6 = 0; var6 < var5; ++var6) {
+            DynamicObject data = var4[var6];
+            realCardIds.add(data.getLong("id"));
+        }
+
+        List<Object[]> params = new ArrayList(realCardIds.size());
+        SqlBuilder querySql = new SqlBuilder();
+        querySql.append("select fmasterid,fbillstatus,fbizstatus,fauditdate,fauditorid from t_fa_card_real where ", new Object[0]);
+        querySql.appendIn(" fid ", realCardIds.toArray(new Object[0]));
+        DataSet dataSet = DB.queryDataSet(this.getClass().getName(), DBRoute.of("fa"), querySql);
+        Throwable var24 = null;
+
+        try {
+            Iterator var8 = dataSet.iterator();
+
+            while(var8.hasNext()) {
+                Row row = (Row)var8.next();
+                Object[] auditInfo = new Object[]{row.getString("fbillstatus"), row.getString("fbizstatus"), row.getDate("fauditdate"), row.getLong("fauditorid"), row.getLong("fmasterid")};
+                params.add(auditInfo);
+            }
+        } catch (Throwable var18) {
+            var24 = var18;
+            throw var18;
+        } finally {
+            if (dataSet != null) {
+                if (var24 != null) {
+                    try {
+                        dataSet.close();
+                    } catch (Throwable var17) {
+                        var24.addSuppressed(var17);
+                    }
+                } else {
+                    dataSet.close();
+                }
+            }
+
+        }
+
+        String updateSql = "update t_fa_card_real set fbillstatus = ?,fbizstatus = ?,fauditdate = ?,fauditorid = ? where fmasterid = ? and foriginaldata = '1';";
+        DB.executeBatch(DBRoute.of("fa"), updateSql, params);
+    }
+
+    private void createFinCard(BeginOperationTransactionArgs e) {
+        Map<Object, List<DynamicObject>> orgDynamicObjectMap = this.orgDynamicObjectMap(e);
+        Iterator var3 = orgDynamicObjectMap.entrySet().iterator();
+
+        while(var3.hasNext()) {
+            Map.Entry<Object, List<DynamicObject>> entry = (Map.Entry)var3.next();
+            CardGenerateHelperEx.generateFinCard((List)entry.getValue());
+        }
+
+    }
+
+    private Map<Object, List<DynamicObject>> orgDynamicObjectMap(BeginOperationTransactionArgs e) {
+        Map<Object, List<DynamicObject>> orgCardMap = new HashMap(16);
+        Iterator var3 = FaOpUtils.getDataEntities(e).iterator();
+
+        while(var3.hasNext()) {
+            DynamicObject realCard = (DynamicObject)var3.next();
+            Object orgPk = realCard.getDynamicObject("org").getPkValue();
+            List<DynamicObject> cards = (List)orgCardMap.computeIfAbsent(orgPk, (v) -> {
+                return new ArrayList();
+            });
+            cards.add(realCard);
+        }
+
+        return orgCardMap;
+    }
+}