From 210b855cb2cf656138d54047e32885546452c435 Mon Sep 17 00:00:00 2001 From: AKurakin Date: Fri, 1 Sep 2023 18:11:30 +0300 Subject: [PATCH] =?UTF-8?q?clearing-service=20BalanceRevise=20=D1=80=D0=B5?= =?UTF-8?q?=D0=B2=D0=B8=D0=B7=D0=B8=D0=B8=203=20=D1=81=D1=82=D0=B0=D0=B4?= =?UTF-8?q?=D0=B8=D0=B8=20AgainRevise.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config/session/StateBnConfig.java | 12 +++- .../session/stage/FinalMkrSession.java | 4 ++ .../session/stage/IntermediateMkrSession.java | 4 ++ .../stage/PrimaryAuctionB0Session.java | 4 ++ .../stage/PrimaryAuctionBnSession.java | 4 ++ .../stage/PrimaryAuctionT0Session.java | 4 ++ .../session/stage/ReturnDepositSession.java | 4 ++ .../stage/SecondaryAuctionT0Session.java | 4 ++ .../clearing/session/stage/TaskType.java | 8 +-- .../session/stage/impl/BalanceRevise.java | 66 ++++++++++++++++++- .../stage/impl/InspectionObligations.java | 46 +++++++++++++ .../session/stage/util/RegistryUtil.java | 1 + .../enumeration/RegistryTradingParams.java | 10 +++ 13 files changed, 161 insertions(+), 10 deletions(-) diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/session/StateBnConfig.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/session/StateBnConfig.java index 006393491..a22e0ab90 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/session/StateBnConfig.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/session/StateBnConfig.java @@ -153,8 +153,9 @@ public class StateBnConfig extends EnumStateMachineConfigurerAdapter { - return revise(); + revise(); // основная сверка + return reviseStage1(); // подготовка к стадии 3 (к AgainRevise) + } + case AgainRevise -> { + return reviseStage3(); } default -> throw new IllegalStateException("unknown task " + task.getTaskType()); } @@ -94,8 +102,60 @@ public class BalanceRevise implements ISessionStage { return new StageResult<>(null, true); } - private BigDecimal safeBD(BigDecimal value) { - return value != null ? value : BigDecimal.ZERO; + private StageResult reviseStage1() { + String sql = RegistryCodeSqlBuilder.getInstance(ru.spcex.platform.enumeration.RegistryTradingParams.A__T).build(); + Collection regsAT = registryImdg.getCollectionObjectsBySQL(sql); + log.trace("Select {} registry's by query \"{}\" for revision step 1", regsAT.size(), sql); + + Instant now = Instant.now(); + int updateCount = 0; + for (Registry reg : regsAT) { + if (reg.getBalance() == null) { + log.debug("Registry[{}] with null balance", reg.getId()); + } else { + if (!Objects.equals(reg.getPlanBalance(), reg.getBalance())) { + reg.setPlanBalance(reg.getBalance()); + reg.setUpdated(now); + registryImdg.update(reg); + updateCount++; + } + } + } + log.debug("At revision stage 1 do updated {} of {} registers {}", updateCount, regsAT.size(), sql); + return new StageResult<>(null, true); + } + + private StageResult reviseStage3() { + String sql = RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.A__T).build(); + Collection regsAT = registryImdg.getCollectionObjectsBySQL(sql); + log.trace("Select {} registry's by query \"{}\" for revision step 3", regsAT.size(), sql); + + int errorRegs = 0; + for (Registry reg : regsAT) { + if (reg.getBalance() == null && reg.getPlanBalance() == null) { + log.debug("Can not verify registry[{}] with null balance and planBalance", reg.getId()); + } else { + if (reg.getBalance() == null || reg.getPlanBalance() == null) { + log.warn("Can not verify registry[{}] with null balance xor planBalance", reg.getId()); + } + if (safeBD(reg.getBalance()).compareTo(safeBD(reg.getPlanBalance())) != 0) { + log.info("Revision: registry id={}, companyId={}, balance={}, plannedBalance={}", + reg.getId(), reg.getCompanyId(), reg.getBalance(), reg.getPlanBalance()); + errorRegs++; + } + } + + } + if (errorRegs > 0) { + log.warn("После сверки обнаружена разница между плановым и фактическим балансом. Всего {} регистров не совпали.", errorRegs); + NotificationNewRequest nRequest = new NotificationNewRequest(); + nRequest.setObjectType(ObjectType.rgst.getKey()); + nRequest.setPriority(Priority.LOW.getKey()); + nRequest.setComment("После сверки обнаружена разница между плановым и фактическим балансом"); + kafkaSender.sendRequestToQueue(Consts.NOTIFICATION_NEW, nRequest); + } + + return new StageResult<>(null, true); } private void newSDf56(Statement statement) { 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 c83bc9767..46c77388f 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 @@ -1,5 +1,7 @@ package ru.spcex.clearing.session.stage.impl; +import org.apache.commons.lang3.tuple.MutableTriple; +import org.apache.commons.lang3.tuple.Triple; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; @@ -31,6 +33,7 @@ import java.util.*; import java.util.stream.Collectors; import static ru.spcex.platform.enumeration.RegistryTradingParams.*; +import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD; @Service @@ -156,9 +159,52 @@ public class InspectionObligations implements ISessionStage { } } + stageRevision2(sessionId); + return new StageResult(null, true); } + protected void stageRevision2(Long sessionId) { + /* todo logic + Collection rgsAT = findRegistryATBySession // registry_disignation=A and registry_unit=T +Collection rgsAB = findRegistryATBySession // registry_disignation=A and registry_unit=B and sessionId = current + +foreach( at: rgsAT) + foreach (ab: rgsAB) + if (at.companyId=ab.companyId and at.accountId=ab.accountId and at.securityId=ab.securityId) + at.plannecBallance -= ab.balance + */ + String sqlAT = RegistryCodeSqlBuilder.getInstance(A__T).build(); + String sqlAB = String.format("(%s) and sessionId = %d", + RegistryCodeSqlBuilder.getInstance(A__B).build(), + sessionId + ); + Collection registriesAT = registryImdg.getCollectionObjectsBySQL(sqlAT); + Collection registriesAB = registryImdg.getCollectionObjectsBySQL(sqlAB); + log.debug("Select {} registers by \"{}\", {} registers by \"{}\" for revision step 2", + registriesAT.size(), sqlAT, registriesAB.size(), sqlAB); + Map, List> regABIndex = registriesAB.stream().collect(Collectors.groupingBy( + (Registry reg) -> new MutableTriple(reg.getCompanyId(), reg.getAccountId(), reg.getSecurityId()) + )); + int updateCount = 0; + Instant now = Instant.now(); + for (Registry regT : registriesAT) { + Triple key = new MutableTriple(regT.getCompanyId(), regT.getAccountId(), regT.getSecurityId()); + List regsB = regABIndex.get(key); + if (regsB == null) { + log.debug("Registry A__B for registry[{}] (A__T key {}) not found", regT, key); + } else { + for (Registry regB : regsB) { + regT.setPlanBalance(safeBD(regT.getPlanBalance()).subtract(safeBD(regB.getBalance()))); + } + regT.setUpdated(now); + registryImdg.update(regT); + updateCount++; + } + } + log.debug("Updated {} registers A__T with planBalance at {}", updateCount, now); + } + private String searchAssetsByObligationSql(Registry obligation) { RegistryTradingParams counterRegistryTradingParams = null; if (IEnumKey.getEnumByKey(RegistryInstrumentType.class, obligation.getRegistryInstrumentType()) == RegistryInstrumentType.S) { diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/util/RegistryUtil.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/util/RegistryUtil.java index 4361b6d4b..ab1826862 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/util/RegistryUtil.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/util/RegistryUtil.java @@ -7,6 +7,7 @@ import ru.spcex.platform.enumeration.RegistryDesignation; import ru.spcex.platform.enumeration.RegistryInstrumentType; import ru.spcex.platform.enumeration.RegistryUnit; +import java.math.BigDecimal; import java.util.*; public class RegistryUtil { diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryTradingParams.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryTradingParams.java index ed86625cd..ecd362ce2 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryTradingParams.java +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryTradingParams.java @@ -24,6 +24,8 @@ public record RegistryTradingParams(RegistryDesignation registryDesignation, public final static RegistryTradingParams AM_F; public final static RegistryTradingParams AM_T; public final static RegistryTradingParams AM_B; + public final static RegistryTradingParams A__B; + public final static RegistryTradingParams A__T; public final static RegistryTradingParams AS_T; public final static RegistryTradingParams DS_T; public final static RegistryTradingParams AS_B; @@ -83,6 +85,14 @@ public record RegistryTradingParams(RegistryDesignation registryDesignation, RegistryInstrumentType.M, null, RegistryUnit.B); + A__B = new RegistryTradingParams(RegistryDesignation.A, + null, + null, + RegistryUnit.B); + A__T = new RegistryTradingParams(RegistryDesignation.A, + null, + null, + RegistryUnit.T); AS_T = new RegistryTradingParams(RegistryDesignation.A, RegistryInstrumentType.S, null,