diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java index 7be4a4e1b..dcb4a6d4e 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java @@ -1,13 +1,16 @@ package ru.spcex.clearing.service.executors; +import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.account.AccountBalance; +import ru.clearing.classes.statics.data.account.ClearingAccount; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.Registry; +import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.classes.statics.data.sdf.SDf02; import ru.clearing.classes.statics.data.sdf.SDf57; import ru.clearing.classes.statics.data.security.Security; @@ -39,6 +42,7 @@ import java.time.Instant; import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.util.Collection; +import java.util.Map; import java.util.Optional; import java.util.function.Consumer; import java.util.function.Function; @@ -56,6 +60,8 @@ public class Sdf57Executor extends AbstractExecutor { private final ImdgProvider imdgProvider; private final IMessageResolver errorResolver; private final Imdg accountBalanceImdg; + private final Imdg clearingAccountImdg; + private final Imdg tradingClearingRegistryImdg; private final Imdg securityImdg; private final IMessageResolver messageResolver; @@ -67,6 +73,8 @@ public class Sdf57Executor extends AbstractExecutor { this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class); this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); + this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); + this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class); this.sDf57Validator = sDf57Validator; this.errorLogger = errorLogger; this.imdgProvider = imdgProvider; @@ -137,9 +145,9 @@ public class Sdf57Executor extends AbstractExecutor { Account accountCred = validator.getStored(ValidationStored.Sdf57AccountCred); //адресат CREDIT / владелец DEBIT - Optional statementDeb = createStatementIfNeeded.apply(companyDeb, accountDeb, InOutDirection.in); + Optional statementDeb = createStatementIfNeeded.apply(companyDeb, accountDeb, InOutDirection.out); //адресат DEBIT / владелец CREDIT - Optional statementCred = createStatementIfNeeded.apply(companyCred, accountCred, InOutDirection.out); + Optional statementCred = createStatementIfNeeded.apply(companyCred, accountCred, InOutDirection.in); Consumer createRegistryIfNeeded = stmtCmpAcc -> { Statement stmt = stmtCmpAcc.statement(); @@ -157,8 +165,12 @@ public class Sdf57Executor extends AbstractExecutor { Registry registry = createRegistryByStatement(stmt, company, account, dsgn); Registry registryF = registry.clone(); registryF.setRegistryUnit(RegistryUnit.F.getKey()); + registryF.setRegistryCode(RegistryUtil.clearingCode(registryF)); + registryF.setId(imdgProvider.getImdgIdGenerator().nextId()); Registry registryB = registry.clone(); registryB.setRegistryUnit(RegistryUnit.B.getKey()); + registryB.setRegistryCode(RegistryUtil.clearingCode(registryB)); + registryB.setId(imdgProvider.getImdgIdGenerator().nextId()); registryImdg.insert(registry); registryImdg.insert(registryF); registryImdg.insert(registryB); @@ -166,7 +178,10 @@ public class Sdf57Executor extends AbstractExecutor { //todo понять что происходит со инициатором/контрагентом, особенно если у нас только один Statement findReg(stmt, RegistryDesignation.A).ifPresentOrElse(update, () -> create.accept(RegistryDesignation.A)); - findReg(stmt, RegistryDesignation.D).ifPresentOrElse(update, () -> create.accept(RegistryDesignation.D)); + if (!StringUtils.isEmpty(sdf57.getSpecif())) { + //todo доделать 11. Идентификация средств УК на клиринговом счете + findReg(stmt, RegistryDesignation.D).ifPresentOrElse(update, () -> create.accept(RegistryDesignation.D)); + } stmt.setOperationStatus(OperationStatus.Executed.getKey()); } else { stmt.setErrorCodeId(err.get().getSubject().getId()); // fixme ErrorText insert @@ -222,11 +237,23 @@ public class Sdf57Executor extends AbstractExecutor { rgs.setAccount(account.getAccount()); rgs.setRegistryDesignation(designation.getKey()); rgs.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); - rgs.setRegistryCapacity(RegistryCapacity.A.getKey()); + + ClearingAccount accountForStatement = clearingAccountImdg.getSingleObjectByID(statement.getAccountId()); + if (accountForStatement != null) { + rgs.setRegistryCapacity(accountForStatement.getClearingAccountType()); + } rgs.setRegistryUnit(RegistryUnit.T.getKey()); rgs.setRegistryCode(RegistryUtil.clearingCode(rgs)); - //rgs.setTradingClearingRegistryId(); //todo ! - //rgs.setTradingClearingRegistry(); //todo ! + + Collection tcrsByAccount = tradingClearingRegistryImdg.getCollectionObjectsByFieldValues(Map.of( + "moneyAccountId", statement.getAccountId() + )); + if (!tcrsByAccount.isEmpty()) { + TradingClearingRegistry tcr = tcrsByAccount.iterator().next(); + rgs.setTradingClearingRegistryId(tcr.getId()); + rgs.setTradingClearingRegistry(tcr.getCode()); + } + rgs.setRegistryStatus(RegistryStatus.PROC.getKey()); rgs.setSecurityId(statement.getSecurityId()); if (statement.getSecurityId() != null) { diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/PrimaryAuctionBnSession.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/PrimaryAuctionBnSession.java index 7beadc73e..e5495dc46 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/PrimaryAuctionBnSession.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/PrimaryAuctionBnSession.java @@ -33,6 +33,7 @@ public class PrimaryAuctionBnSession extends AbstractSession implements Initiali private final ObligationAdmission obligationsAdmission; private final InclusionObligations inclusionObligations; + private final InspectionObligations inspectionObligations; private final FormingRegistersOnOS formingRegistersOnOS; private final FormingPaymentInstruction formingPaymentInstruction; private final UnlockResources unlockResources; @@ -51,7 +52,7 @@ public class PrimaryAuctionBnSession extends AbstractSession implements Initiali FormingRegistersOnOS formingRegistersOnOS, FormingPaymentInstruction formingPaymentInstruction, UnlockResources unlockResources, - FinishingSession finishingSession, EndStageNotification endStageNotification, IMessageResolver messageResolver) { + FinishingSession finishingSession, EndStageNotification endStageNotification, IMessageResolver messageResolver, InspectionObligations inspectionObligations) { super(imdgProvider, messageResolver); this.balanceRevise = balanceRevise; this.dealsPrepare = dealsPrepare; @@ -64,6 +65,7 @@ public class PrimaryAuctionBnSession extends AbstractSession implements Initiali this.finishingSession = finishingSession; this.endStageNotification = endStageNotification; this.executionFondImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ExecutionFond, ExecutionFond.class); + this.inspectionObligations = inspectionObligations; } @Override @@ -116,7 +118,7 @@ public class PrimaryAuctionBnSession extends AbstractSession implements Initiali { InspectionPoolPayload companyIdPayload = new InspectionPoolPayload(); companyIdPayload.setProcessedCompanyId(currSession.getCompanyId()); - runStage(TaskType.InspectionObligations, companyIdPayload, inclusionObligations); + runStage(TaskType.InspectionObligations, companyIdPayload, inspectionObligations); } //stage 6 runStage(TaskType.FormingRegistersOnOS, formingRegistersOnOS); //returns Collection diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/InspectionObligations.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/InspectionObligations.java index 5f60447d6..3f3291863 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/InspectionObligations.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/InspectionObligations.java @@ -12,12 +12,11 @@ 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.InspectionPoolPayload; -import ru.spcex.platform.enumeration.RegistryDesignation; -import ru.spcex.platform.enumeration.RegistryInstrumentType; -import ru.spcex.platform.enumeration.RegistryUnit; +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.specific.RegistryCodeSqlBuilder; import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.enumeration.IEnumKey; import ru.spcex.platform.utils.enumeration.IMessageResolver; @@ -62,15 +61,18 @@ public class InspectionObligations implements ISessionStage { private StageResult inspectionPool(Long processedCompanyId) { - String sqlCondition = String.format("registryDesignation in ('%s', '%s') and " + - "registryInstrumentType in ('%s', '%s') and " + - "registryUnit = '%s' and " + - "registryStatus = '%s' and " + - "settlementDate = '%s'", - RegistryDesignation.O.getKey(), RegistryDesignation.T.getKey(), - RegistryInstrumentType.S.getKey(), RegistryInstrumentType.M.getKey(), - RegistryUnit.T.getKey(), - "POOL"); + RegistryTradingParams registryTradingParamsOST = new RegistryTradingParams(RegistryDesignation.O, + RegistryInstrumentType.S, + null, + RegistryUnit.T); + RegistryTradingParams registryTradingParamsTMT = new RegistryTradingParams(RegistryDesignation.T, + RegistryInstrumentType.M, + null, + RegistryUnit.T); + + String sqlCondition = String.format("%s and registryStatus = '%s'", + RegistryCodeSqlBuilder.getInstance(registryTradingParamsOST, registryTradingParamsTMT).build(), + RegistryStatus.POOL.getKey()); Collection obligations = registryImdg.getCollectionObjectsBySQL(sqlCondition); Map>> registryByGroupIdAndCompanyId = obligations.stream(). diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryStatus.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryStatus.java index 6c6536495..381da2f07 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryStatus.java +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryStatus.java @@ -6,7 +6,8 @@ public enum RegistryStatus implements IEnumKey { OK("OK"), PROC("PROC"), NACK("NACK"), - FAIL("FAIL") + FAIL("FAIL"), + POOL("POOL") ; private final String key; diff --git a/platform-parent/platform-imdg-api/pom.xml b/platform-parent/platform-imdg-api/pom.xml index 1c6e12c22..69d60ff13 100644 --- a/platform-parent/platform-imdg-api/pom.xml +++ b/platform-parent/platform-imdg-api/pom.xml @@ -33,5 +33,25 @@ ru.spcex.platform platform-utils + + + org.junit.jupiter + junit-jupiter + test + + + org.assertj + assertj-core + test + + + org.mockito + mockito-core + + + org.springframework.boot + spring-boot-starter-test + test + \ No newline at end of file diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryCodeSqlBuilder.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryCodeSqlBuilder.java index 1d4d23329..376b4cdde 100644 --- a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryCodeSqlBuilder.java +++ b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryCodeSqlBuilder.java @@ -52,6 +52,10 @@ public class RegistryCodeSqlBuilder { } if (tradingParams.registryUnit() != null) { condition.append(String.format("registryUnit = '%s'", tradingParams.registryUnit().getKey())); + wasAddedCondition = true; + } + if (!wasAddedCondition) { + condition.delete(condition.length() - " and ".length(), condition.length()); } conditions.add(condition); } diff --git a/platform-parent/platform-imdg-api/src/test/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryCodeSqlBuilderTest.java b/platform-parent/platform-imdg-api/src/test/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryCodeSqlBuilderTest.java new file mode 100644 index 000000000..0410b7c4f --- /dev/null +++ b/platform-parent/platform-imdg-api/src/test/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryCodeSqlBuilderTest.java @@ -0,0 +1,61 @@ +package ru.spcex.platform.imdg.api.predicate.specific; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import ru.spcex.platform.enumeration.*; + +public class RegistryCodeSqlBuilderTest { + + @Test + public void testBuildByOneObject() { + RegistryTradingParams registryTradingParams = new RegistryTradingParams(RegistryDesignation.C, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R); + RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams); + String sql = registryCodeSqlBuilder.build(); + Assertions.assertEquals("(registryDesignation = 'C' and registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')", sql); + + registryTradingParams = new RegistryTradingParams(null, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R); + registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams); + sql = registryCodeSqlBuilder.build(); + Assertions.assertEquals("(registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')", sql); + + registryTradingParams = new RegistryTradingParams(RegistryDesignation.C, null, null, RegistryUnit.R); + registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams); + sql = registryCodeSqlBuilder.build(); + Assertions.assertEquals("(registryDesignation = 'C' and registryUnit = 'R')", sql); + } + + @Test + public void testBuildByFewObjects() { + RegistryTradingParams registryTradingParams_first = new RegistryTradingParams(RegistryDesignation.C, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R); + RegistryTradingParams registryTradingParams_second = new RegistryTradingParams(RegistryDesignation.O, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F); + RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second); + String sql = registryCodeSqlBuilder.build(); + Assertions.assertEquals("(registryDesignation = 'C' and registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')" + + " or (registryDesignation = 'O' and registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql); + + registryTradingParams_first = new RegistryTradingParams(null, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R); + registryTradingParams_second = new RegistryTradingParams(null, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F); + registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second); + sql = registryCodeSqlBuilder.build(); + Assertions.assertEquals("(registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R') or " + + "(registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql); + + registryTradingParams_first = new RegistryTradingParams(RegistryDesignation.C, null, null, RegistryUnit.R); + registryTradingParams_second = new RegistryTradingParams(null, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F); + registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second); + sql = registryCodeSqlBuilder.build(); + Assertions.assertEquals("(registryDesignation = 'C' and registryUnit = 'R') or " + + "(registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql); + } + + @Test + public void test(){ + RegistryTradingParams registryTradingParamsL = new RegistryTradingParams(RegistryDesignation.L, + RegistryInstrumentType.S, null, RegistryUnit.T); + RegistryTradingParams registryTradingParamsC = new RegistryTradingParams(RegistryDesignation.C, + RegistryInstrumentType.M, null, null); + RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParamsL, registryTradingParamsC); + Assertions.assertEquals("(registryDesignation = 'L' and registryInstrumentType = 'S' and registryUnit = 'T') or (registryDesignation = 'C' and registryInstrumentType = 'M')", + registryCodeSqlBuilder.build()); + } +}