From ef17c60c5847944adba8d66ff0aecc9553056e26 Mon Sep 17 00:00:00 2001 From: ialbert Date: Thu, 8 Jun 2023 13:32:49 +0300 Subject: [PATCH] =?UTF-8?q?=D0=B8=D1=82=D0=BE=D0=B3=D0=BE=D0=B2=D0=B0?= =?UTF-8?q?=D1=8F=20=D0=9C=D0=9A=D0=A0=20=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D0=BB=20=D1=81=D0=BE=D0=B7=D0=B4=D0=B0=D0=BD=D0=B8=D0=B5?= =?UTF-8?q?=20PaymentInstruction=20=D0=BF=D0=BE=20=D0=B2=D0=BE=D0=B7=D0=B2?= =?UTF-8?q?=D1=80=D0=B0=D1=82=D1=83=20=D0=BF=D0=BE=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D0=BB=20=D0=BE=D1=82=D0=BF=D1=80=D0=B0=D0=B2=D0=BA=D1=83?= =?UTF-8?q?=20SDF03?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../PaymentInstructionBuilderFinalMkr.java | 3 + .../session/stage/FinalMkrSession.java | 22 +- ...ormingPaymentInstructionDealsFinalMkr.java | 49 +-- .../FormingPaymentInstructionReturnMkr.java | 338 ++++++++++++++++++ ...mingPaymentInstructionDealsMkrPayload.java | 29 ++ 5 files changed, 397 insertions(+), 44 deletions(-) create mode 100644 clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionReturnMkr.java create mode 100644 clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/task/FormingPaymentInstructionDealsMkrPayload.java diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/PaymentInstructionBuilderFinalMkr.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/PaymentInstructionBuilderFinalMkr.java index 1cec2ecee..10aaae950 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/PaymentInstructionBuilderFinalMkr.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/PaymentInstructionBuilderFinalMkr.java @@ -22,6 +22,9 @@ import java.time.format.DateTimeFormatter; import java.util.Map; import java.util.concurrent.atomic.AtomicLong; +/** + * Builder для кейса итоговой сессии МКР, 7 шаг, кейс - по сделкам + */ public class PaymentInstructionBuilderFinalMkr { private final static Logger log = LoggerFactory.getLogger(PaymentInstructionBuilderFinalMkr.class); diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/FinalMkrSession.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/FinalMkrSession.java index 39da49f47..3dd5b038a 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/FinalMkrSession.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/FinalMkrSession.java @@ -40,7 +40,8 @@ public class FinalMkrSession extends AbstractSession implements InitializingBean private final InclusionObligations inclusionObligations; private final InspectionObligations inspectionObligations; private final FormingRegistersOnOS formingRegistersOnOS; - private final FormingPaymentInstructionDealsFinalMkr formingPaymentInstruction; + private final FormingPaymentInstructionReturnMkr formingPaymentInstructionReturn; + private final FormingPaymentInstructionDealsFinalMkr formingPaymentInstructionDeals; private final UnlockResources unlockResources; private final FinishingSession finishingSession; private final EndStageNotification endStageNotification; @@ -58,7 +59,7 @@ public class FinalMkrSession extends AbstractSession implements InitializingBean ObligationAdmission obligationsAdmission, InclusionObligations inclusionObligations, FormingRegistersOnOS formingRegistersOnOS, - FormingPaymentInstructionDealsFinalMkr formingPaymentInstruction, + FormingPaymentInstructionReturnMkr formingPaymentInstructionReturn, FormingPaymentInstructionDealsFinalMkr formingPaymentInstructionDeals, UnlockResources unlockResources, FinishingSession finishingSession, EndStageNotification endStageNotification, @@ -72,7 +73,8 @@ public class FinalMkrSession extends AbstractSession implements InitializingBean this.obligationsAdmission = obligationsAdmission; this.inclusionObligations = inclusionObligations; this.formingRegistersOnOS = formingRegistersOnOS; - this.formingPaymentInstruction = formingPaymentInstruction; + this.formingPaymentInstructionReturn = formingPaymentInstructionReturn; + this.formingPaymentInstructionDeals = formingPaymentInstructionDeals; this.unlockResources = unlockResources; this.finishingSession = finishingSession; this.endStageNotification = endStageNotification; @@ -170,12 +172,22 @@ public class FinalMkrSession extends AbstractSession implements InitializingBean //stage 6 runStage(TaskType.FormingRegistersOnOS, formingRegistersOnOS); //returns Collection //stage 7 - StageResult> paymentResult = null; + + StageResult> returnsPayment = null; { FormingPaymentInstructionPayload payload = new FormingPaymentInstructionPayload(); payload.setSessionId(currSession.getId()); //stage 7 - paymentResult = runStage(TaskType.FormingPaymentInstruction, payload, formingPaymentInstruction); + returnsPayment = runStage(TaskType.FormingPaymentInstruction, payload, formingPaymentInstructionReturn); + } + + StageResult> paymentResult = null; + { + FormingPaymentInstructionDealsMkrPayload payload = new FormingPaymentInstructionDealsMkrPayload(); + payload.setSessionId(currSession.getId()); + payload.setPaymentInstructionReturns(returnsPayment.getStageResult()); + //stage 7 + paymentResult = runStage(TaskType.FormingPaymentInstruction, payload, formingPaymentInstructionDeals); } if (paymentResult != null && paymentResult.getStageResult().isEmpty()) { runStage(TaskType.FormingPaymentInstruction, balanceRevise); diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionDealsFinalMkr.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionDealsFinalMkr.java index ae010368e..5d387760a 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionDealsFinalMkr.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionDealsFinalMkr.java @@ -17,13 +17,12 @@ import ru.spcex.clearing.error.ClearingError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import ru.spcex.clearing.platform.messaging.domain.cud.balance.ExportToFileRequest; -import ru.spcex.clearing.platform.messaging.domain.cud.importexport.SwtExporterRequest; import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; import ru.spcex.clearing.service.builder.PaymentInstructionBuilderFinalMkr; import ru.spcex.clearing.session.stage.ISessionStage; import ru.spcex.clearing.session.stage.StageResult; import ru.spcex.clearing.session.stage.Task; -import ru.spcex.clearing.session.stage.task.FormingPaymentInstructionPayload; +import ru.spcex.clearing.session.stage.task.FormingPaymentInstructionDealsMkrPayload; import ru.spcex.platform.enumeration.*; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgId; @@ -43,6 +42,7 @@ import java.time.format.DateTimeFormatter; import java.util.*; import java.util.function.Function; import java.util.stream.Collectors; +import java.util.stream.Stream; import static ru.spcex.platform.enumeration.RegistryTradingParams.CM_T; import static ru.spcex.platform.enumeration.RegistryTradingParams.LM_T; @@ -81,10 +81,10 @@ public class FormingPaymentInstructionDealsFinalMkr implements ISessionStage { @Override public StageResult submit(Task task) { - FormingPaymentInstructionPayload payload = (FormingPaymentInstructionPayload) task.getData(); + FormingPaymentInstructionDealsMkrPayload payload = (FormingPaymentInstructionDealsMkrPayload) task.getData(); switch (task.getTaskType()) { case FormingPaymentInstruction -> { - return formingPaymentInstructions(payload.getSessionId()); + return formingPaymentInstructions(payload.getSessionId(), payload.getPaymentInstructionReturns()); } default -> { throw new IllegalStateException("Unknown task type: " + task.getTaskType()); @@ -112,7 +112,7 @@ public class FormingPaymentInstructionDealsFinalMkr implements ISessionStage { * регистр LMAT кто переводит деньги (registry.account)
* в итоге создается 2 PaymentInstruction: LMAT -> TRAN счет -> CMAT счет */ - private StageResult formingPaymentInstructions(Long sessionId) { + private StageResult formingPaymentInstructions(Long sessionId, Collection paymentInstructionReturns) { Collection registries = selectRegistries(); log.debug("found registries.size() = {}", registries.size()); Account tranAcc = accountImdg.getSingleObjectBySQL("accountType = '%s' and status = '%s' and processingSign = '%s'" @@ -161,24 +161,20 @@ public class FormingPaymentInstructionDealsFinalMkr implements ISessionStage { pmtInstrs.getFirst().getId(), pmtInstrs.getSecond().getId()); } - sendSdfs(allPaymentInstructions); + + List returnsAndDeals = Stream.concat(paymentInstructionReturns.stream(), allPaymentInstructions.stream()).toList(); + sendSdfs(returnsAndDeals); StageResult> stageResult = new StageResult<>(null, true); - stageResult.setStageResult(allPaymentInstructions); + stageResult.setStageResult(returnsAndDeals); return stageResult; } private void sendSdfs(List formedPaymentInstructions) { List sDf03Created = new ArrayList<>(); - List sDf12Created = new ArrayList<>(); for (PaymentInstruction paymentInstruction : formedPaymentInstructions) { - Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId()); Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId()); - if (InstrumentType.CRNC.equalsByKey(security.getInstrumentType()) && - List.of(AccountType.Corr, AccountType.Clrn).contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) { + if (List.of(AccountType.Corr, AccountType.Clrn).contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) { sDf03Created.add(newSDf03(paymentInstruction)); - } else if (!InstrumentType.CRNC.equalsByKey(security.getInstrumentType()) && - AccountType.Depo.equalsByKey(account.getAccountType())) { - sDf12Created.add(newSDf12(paymentInstruction)); } } @@ -194,31 +190,6 @@ public class FormingPaymentInstructionDealsFinalMkr implements ISessionStage { exportToFileRequest.setSdfGroupId(sdf03GroupId); kafkaSender.sendRequestToQueue(Consts.EXPORT_PROCESS, exportToFileRequest); } - - Long sdf12GroupId = null; - Long maxTxNumber = 1L; - if (!sDf12Created.isEmpty()) { - sdf12GroupId = imdgProvider.getImdgIdGenerator().nextId(); - ImdgPredicateBuilder predicateBuilder = sDf12Imdg.predicateBuilder(); - ImdgPredicate notEmptyTransactionNum = predicateBuilder.not(predicateBuilder.equals("transaction_number", "")); - Long maxId = sDf12Imdg.aggregateLongMax("id", notEmptyTransactionNum); - if (maxId != null) { - SDf12 sDf12 = sDf12Imdg.getSingleObjectByID(maxId); - maxTxNumber = Long.parseLong(sDf12.getTransactionNumber()) + 1; - } - } - for (SDf12 sDf12 : sDf12Created) { - sDf12.setGenerationId(sdf03GroupId); - sDf12.setTransactionNumber(maxTxNumber.toString()); - sDf12.setTransactionQuantity(String.valueOf(sDf12Created.size())); - sDf12Imdg.insert(sDf12); - } - - if (sdf12GroupId != null) { - SwtExporterRequest swtExporterRequest = new SwtExporterRequest(); - swtExporterRequest.setType("SDF_12"); - kafkaSender.sendRequestToQueue(Consts.SWT_EXPORTER, swtExporterRequest); - } } private SDf03 newSDf03(PaymentInstruction paymentInstruction) { diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionReturnMkr.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionReturnMkr.java new file mode 100644 index 000000000..96c77284b --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionReturnMkr.java @@ -0,0 +1,338 @@ +package ru.spcex.clearing.session.stage.impl; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.payment.PaymentInstruction; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.clearing.classes.statics.data.sdf.SDf03; +import ru.clearing.classes.statics.data.sdf.SDf12; +import ru.clearing.classes.statics.data.security.Security; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.balance.ExportToFileRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.importexport.SwtExporterRequest; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.clearing.service.builder.PaymentInstructionBuilder; +import ru.spcex.clearing.session.stage.ISessionStage; +import ru.spcex.clearing.session.stage.StageResult; +import ru.spcex.clearing.session.stage.Task; +import ru.spcex.clearing.session.stage.task.FormingPaymentInstructionPayload; +import ru.spcex.platform.enumeration.*; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgId; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder; +import ru.spcex.platform.utils.enumeration.IEnumKey; +import ru.spcex.platform.utils.time.TimeUtil; + +import java.math.BigDecimal; +import java.time.Instant; +import java.time.format.DateTimeFormatter; +import java.util.*; + +import static ru.spcex.platform.enumeration.RegistryTradingParams.*; + +@Service +@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class FormingPaymentInstructionReturnMkr implements ISessionStage { + private final Logger log = LoggerFactory.getLogger(getClass()); + //todo remove (set all in single method setImdg(provider -> setImdg1();setIdGenerator();...) + private ImdgProvider imdgProvider; + private ImdgId idGenerator; + private Imdg registryImdg; + private Imdg paymentInstructionImdg; + private Imdg securityImdg; + private Imdg accountImdg; + private Imdg companyImdg; + private Imdg sDf03Imdg; + private Imdg sDf12Imdg; + private KafkaSender kafkaSender; + + @Autowired + public FormingPaymentInstructionReturnMkr(ImdgProvider imdgProvider, + KafkaSender kafkaSender) { + this.kafkaSender = kafkaSender; + this.imdgProvider = imdgProvider; + this.idGenerator = imdgProvider.getImdgIdGenerator(); + this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class); + this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); + this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class); + this.sDf12Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf12, SDf12.class); + this.paymentInstructionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class); + } + + @Override + public StageResult submit(Task task) { + FormingPaymentInstructionPayload payload = (FormingPaymentInstructionPayload) task.getData(); + switch (task.getTaskType()) { + case FormingPaymentInstruction -> { + return formingPaymentInstruction(payload.getSessionId()); + } + default -> { + throw new IllegalStateException("Unknown task type: " + task.getTaskType()); + } + } + } + + + private StageResult formingPaymentInstruction(Long sessionId) { + RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(LM_T, CM_T); + String registryCodeCondition = registryCodeSqlBuilder.build(); + + Collection rgsAll = registryImdg.getCollectionObjectsBySQL(registryCodeCondition); + log.debug("LM*T and CM*T size = {}", rgsAll.size()); + + List obligationsByMoney = rgsAll.stream() + .filter(registry -> equalsByRegistry(LM_T, registry)) + .toList(); + + log.debug("changing assets by LM*T"); + //изменяем активы по обязательствам по деньгам (LM_T) + for (Registry obligationByMoney : obligationsByMoney) { + String sql = String.format("tradingClearingRegistryId = %s and companyId = %s", + obligationByMoney.getTradingClearingRegistryId(), obligationByMoney.getCompanyId()); + Collection relatedRegistries = registryImdg.getCollectionObjectsBySQL(sql); + + for (Registry relatedRegistry : relatedRegistries) { + if (equalsByRegistry(AM_F, relatedRegistry)) { + relatedRegistry.setBalance(safeBD(relatedRegistry.getBalance()).subtract(safeBD(obligationByMoney.getBalance()))); + } else if (equalsByRegistry(AM_T, relatedRegistry)) { + relatedRegistry.setSettledDebit(safeBD(relatedRegistry.getSettledDebit()).add(safeBD(obligationByMoney.getBalance()))); + } else if (equalsByRegistry(AM_B, relatedRegistry)) { + relatedRegistry.setBalance(safeBD(relatedRegistry.getBalance()).add(safeBD(obligationByMoney.getBalance()))); + } + registryImdg.update(relatedRegistry); + } + } + log.debug("changing assets by CM*T"); + List requirementsByMoney = rgsAll.stream() + .filter(registry -> equalsByRegistry(CM_T, registry)) + .toList(); + //изменяем активы по требованиям по деньгам CM_T + for (Registry requirementByMoney : requirementsByMoney) { + String sql = String.format("tradingClearingRegistryId = %s and companyId = %s", + requirementByMoney.getTradingClearingRegistryId(), requirementByMoney.getCompanyId()); + Collection relatedRegistries = registryImdg.getCollectionObjectsBySQL(sql); + + for (Registry relatedRegistry : relatedRegistries) { + if (equalsByRegistry(AM_T, relatedRegistry)) { + relatedRegistry.setSettledDebit(safeBD(relatedRegistry.getSettledDebit()).add(safeBD(requirementByMoney.getBalance()))); + } + registryImdg.update(relatedRegistry); + } + } + + List formedPaymentInstructions = new ArrayList<>(); + + List allLiabilities = rgsAll + .stream() + .filter(registry -> RegistryDesignation.L.equalsByKey(registry.getRegistryDesignation())) + .toList(); + //todo сортировка if needed + for (int i = 0; i < allLiabilities.size(); i++) { + Registry lm_t = allLiabilities.get(i); + if (lm_t == null) continue; + LinkedList relatedRegistries = new LinkedList<>(); + relatedRegistries.add(lm_t); + for (int j = i + 1; j < allLiabilities.size(); j++) { + Registry related = allLiabilities.get(j); + if (related == null) continue; + if (registriesOfTheSameAgents(lm_t, related)) { + relatedRegistries.add(related); + allLiabilities.set(j, null); + } + } + log.trace("LM*T.id={} return group size {}", lm_t.getId(), relatedRegistries.size()); + BigDecimal sumBalance = relatedRegistries.stream().map(Registry::getBalance).reduce(BigDecimal.ZERO, BigDecimal::add); + log.trace("LM*T.id={} sumBalance={}", lm_t.getId(), sumBalance); + List builderList = new ArrayList<>(); + builderList.add(lm_t); + rgsAll.stream() + .filter(rgs -> rgs.getGroupId().equals(lm_t.getGroupId())) + .filter(rgs -> RegistryDesignation.C.equalsByKey(rgs.getRegistryDesignation())) + .findFirst() + .ifPresent(builderList::add); + + PaymentInstruction paymentInstruction = createPaymentInstruction(builderList, sumBalance, sessionId); + formedPaymentInstructions.add(paymentInstruction); + paymentInstructionImdg.insert(paymentInstruction); + log.trace("LM*T.id={} created paymentInstruction.id={}", lm_t.getId(), paymentInstruction.getId()); + builderList.forEach(registry -> { + registry.setPaymentId(paymentInstruction.getId()); + registry.setUpdated(Instant.now()); + registryImdg.update(registry); + }); + } + + //sdf отправляют + //sendSdfs(formedPaymentInstructions); + + StageResult> stageResult = new StageResult(null, true); + stageResult.setStageResult(formedPaymentInstructions); + return stageResult; + } + + private void sendSdfs(List formedPaymentInstructions) { + List sDf03Created = new ArrayList<>(); + List sDf12Created = new ArrayList<>(); + for (PaymentInstruction paymentInstruction : formedPaymentInstructions) { + Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId()); + Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId()); + if (InstrumentType.CRNC.equalsByKey(security.getInstrumentType()) && + List.of(AccountType.Corr, AccountType.Clrn).contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) { + sDf03Created.add(newSDf03(paymentInstruction)); + } else if (!InstrumentType.CRNC.equalsByKey(security.getInstrumentType()) && + AccountType.Depo.equalsByKey(account.getAccountType())) { + sDf12Created.add(newSDf12(paymentInstruction)); + } + } + + Long sdf03GroupId = !sDf03Created.isEmpty() ? imdgProvider.getImdgIdGenerator().nextId() : null; + for (SDf03 sDf03 : sDf03Created) { + sDf03.setGenerationId(sdf03GroupId); + sDf03Imdg.insert(sDf03); + } + + if (sdf03GroupId != null) { + ExportToFileRequest exportToFileRequest = new ExportToFileRequest(); + exportToFileRequest.setNameOfTable("DF-03"); + exportToFileRequest.setSdfGroupId(sdf03GroupId); + kafkaSender.sendRequestToQueue(Consts.EXPORT_PROCESS, exportToFileRequest); + } + + Long sdf12GroupId = null; + Long maxTxNumber = 1L; + if (!sDf12Created.isEmpty()) { + sdf12GroupId = imdgProvider.getImdgIdGenerator().nextId(); + ImdgPredicateBuilder predicateBuilder = sDf12Imdg.predicateBuilder(); + ImdgPredicate notEmptyTransactionNum = predicateBuilder.not(predicateBuilder.equals("transaction_number", "")); + Long maxId = sDf12Imdg.aggregateLongMax("id", notEmptyTransactionNum); + if (maxId != null) { + SDf12 sDf12 = sDf12Imdg.getSingleObjectByID(maxId); + maxTxNumber = Long.parseLong(sDf12.getTransactionNumber()) + 1; + } + } + for (SDf12 sDf12 : sDf12Created) { + sDf12.setGenerationId(sdf03GroupId); + sDf12.setTransactionNumber(maxTxNumber.toString()); + sDf12.setTransactionQuantity(String.valueOf(sDf12Created.size())); + sDf12Imdg.insert(sDf12); + } + + if (sdf12GroupId != null) { + SwtExporterRequest swtExporterRequest = new SwtExporterRequest(); + swtExporterRequest.setType("SDF_12"); + kafkaSender.sendRequestToQueue(Consts.SWT_EXPORTER, swtExporterRequest); + } + } + + private PaymentInstruction createPaymentInstruction(List registries, BigDecimal balance, Long sessionId) { + PaymentInstructionBuilder paymentInstructionBuilder = PaymentInstructionBuilder.builder(imdgProvider, registries) + .sessionId(sessionId) + .amount(balance); + return paymentInstructionBuilder.build(); + } + + private SDf03 newSDf03(PaymentInstruction paymentInstruction) { + log.debug("creating sdf03"); + SDf03 sDf03 = new SDf03(); + sDf03.setId(idGenerator.nextId()); + sDf03.setSeg_type("S"); + sDf03.setDoc_type("002"); + String strId = paymentInstruction.getId().toString(); + String strIdCut = strId.length() > 16 ? strId.substring(strId.length() - 16) : strId; + sDf03.setDocnm_ref(strIdCut); + sDf03.setC_acc_deb(paymentInstruction.getCreditLeg_account()); + + String senderSbankName = ""; + if (paymentInstruction.getSenderId().equals(1L)) { + senderSbankName = paymentInstruction.getPayeeBankName(); + } else { + Company company = companyImdg.getSingleObjectByID(paymentInstruction.getSenderId()); + if (company != null) { + senderSbankName = company.getShortName(); + } + } + sDf03.setSbanknam1(senderSbankName); + sDf03.setSbanknam2(senderSbankName); + sDf03.setSbanknam3(senderSbankName); + sDf03.setSbanknam4(senderSbankName); + sDf03.setSbanknam5(senderSbankName); + + sDf03.setC_acc_cred(paymentInstruction.getDebitLeg_account()); + + String addresseeSbankName = ""; + if (paymentInstruction.getAddresseeId().equals(1L)) { + addresseeSbankName = paymentInstruction.getAddresseeBankName(); + } else { + Company company = companyImdg.getSingleObjectByID(paymentInstruction.getAddresseeId()); + if (company != null) { + addresseeSbankName = company.getShortName(); + } + } + sDf03.setRbanknam1(addresseeSbankName); + sDf03.setRbanknam2(addresseeSbankName); + sDf03.setRbanknam3(addresseeSbankName); + sDf03.setRbanknam4(addresseeSbankName); + sDf03.setRbanknam5(addresseeSbankName); + + sDf03.setPay_date(payDateFormatter.format(TimeUtil.toLocalDate(paymentInstruction.getPaymentDate()))); + sDf03.setPay_val("RUR"); + sDf03.setSum_deb(paymentInstruction.getDebitLeg_amount() != null ? paymentInstruction.getDebitLeg_amount().toString() : ""); + sDf03.setSpecif_1(paymentInstruction.getPaymentPurpose()); + sDf03.setGenerationTime(Instant.now()); + sDf03.setPaymentInstructionId(paymentInstruction.getId()); + log.debug("successfully processed, new id {}", sDf03.getId()); + return sDf03; + } + + private SDf12 newSDf12(PaymentInstruction paymentInstruction) { + log.debug("creating sdf12"); + SDf12 sDf12 = new SDf12(); + sDf12.setId(idGenerator.nextId()); + sDf12.setOutDocument(sDf12.getId().toString()); + sDf12.setDirection("DELFREE"); + sDf12.setQuantity(paymentInstruction.getCreditLeg_amount().toString()); + sDf12.setSecurityCode(paymentInstruction.getCreditLeg_securityId().toString()); + sDf12.setDepoCodeSender(paymentInstruction.getCreditLeg_account()); + sDf12.setDepoCodeAdressee(paymentInstruction.getDebitLeg_account()); +// sDf12.setTransactionNumber(); + sDf12.setGenerationTime(Instant.now()); + return sDf12; + } + + private BigDecimal safeBD(BigDecimal value) { + return value != null ? value : BigDecimal.ZERO; + } + + DateTimeFormatter payDateFormatter = DateTimeFormatter.ofPattern("dd.MM.yy"); + + + + private boolean registriesOfTheSameAgents(Registry rgs1, Registry rgs2) { + return Objects.equals(rgs1.getSecurityId(), rgs2.getSecurityId()) + && Objects.equals(rgs1.getTradingClearingRegistryId(), rgs2.getTradingClearingRegistryId()) + && Objects.equals(rgs1.getCompanyId(), rgs2.getCompanyId()) + && Objects.equals(rgs1.getCounterPartyId(), rgs2.getCounterPartyId()); + } + + private static boolean equalsByRegistry(RegistryTradingParams code, Registry rgs) { + return code.equalByRegistry( + IEnumKey.getEnumByKey(RegistryDesignation.class, rgs.getRegistryDesignation()), + IEnumKey.getEnumByKey(RegistryInstrumentType.class, rgs.getRegistryInstrumentType()), + IEnumKey.getEnumByKey(RegistryCapacity.class, rgs.getRegistryCapacity()), + IEnumKey.getEnumByKey(RegistryUnit.class, rgs.getRegistryUnit()) + ); + + } +} diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/task/FormingPaymentInstructionDealsMkrPayload.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/task/FormingPaymentInstructionDealsMkrPayload.java new file mode 100644 index 000000000..51fd741d6 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/task/FormingPaymentInstructionDealsMkrPayload.java @@ -0,0 +1,29 @@ +package ru.spcex.clearing.session.stage.task; + +import ru.clearing.classes.statics.data.payment.PaymentInstruction; + +import java.util.Collection; + +public class FormingPaymentInstructionDealsMkrPayload { + private Long sessionId; + /** + * для МКР итоговой сессии SDF будет отправляться по 1. возвратам 2. сделкам + * соотв. поле нужно чтобы передать сделанные пейменты из пункта 1 в 2 + */ + private Collection paymentInstructionReturns; + public Long getSessionId() { + return sessionId; + } + + public void setSessionId(Long sessionId) { + this.sessionId = sessionId; + } + + public Collection getPaymentInstructionReturns() { + return paymentInstructionReturns; + } + + public void setPaymentInstructionReturns(Collection paymentInstructionReturns) { + this.paymentInstructionReturns = paymentInstructionReturns; + } +}