From 9c559b5c807ab1e491e717274ca26e5d83904144 Mon Sep 17 00:00:00 2001 From: ialbert Date: Wed, 13 Sep 2023 17:31:53 +0300 Subject: [PATCH] D**V registries --- .../service/executors/Sdf57Executor.java | 19 ++++ .../service/registry/AssetTBFProcessing.java | 26 ++--- .../registry/PaymentStateMarkService.java | 98 +++++++++++++++++++ .../session/stage/FinalMkrSession.java | 1 + .../impl/FormingPaymentInstructionAssets.java | 13 ++- .../platform/enumeration/CompanyRole.java | 19 ++++ .../enumeration/RegistryTradingParams.java | 68 +++++++++++++ .../platform/enumeration/RegistryUnit.java | 1 + 8 files changed, 232 insertions(+), 13 deletions(-) create mode 100644 clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/PaymentStateMarkService.java create mode 100644 platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CompanyRole.java 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 f543510f4..a0299ad48 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 @@ -10,6 +10,7 @@ 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.misc.Currency; +import ru.clearing.classes.statics.data.misc.Session; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.classes.statics.data.sdf.SDf02; @@ -60,6 +61,7 @@ import java.util.function.Consumer; import java.util.function.Function; import java.util.regex.Pattern; +import static ru.spcex.platform.enumeration.RegistryTradingParams.D__V; import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD; @Service @@ -69,6 +71,7 @@ public class Sdf57Executor extends AbstractExecutor { private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy"); private final Imdg statementImdg; private final Imdg registryImdg; + private final Imdg sessionImdg; private final Function sDf57Validator; private final LoggingService errorLogger; private final Imdg sdf02Imdg; @@ -103,6 +106,7 @@ public class Sdf57Executor extends AbstractExecutor { this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class); this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); this.sDf57Validator = sDf57Validator; this.errorLogger = errorLogger; this.imdgProvider = imdgProvider; @@ -676,6 +680,21 @@ public class Sdf57Executor extends AbstractExecutor { private AssetOperationListRequest gatewayRequest(Statement stmt, String tradingCode, String tcrCode) { AssetOperationListRequest gatewayRequest = new AssetOperationListRequest(); AssetOperationRequest req = GatewayRequestCreator.gatewayRequestPart(stmt, tradingCode, tcrCode); + Session existActiveSession = sessionImdg.getFirstObjectByFieldValues(Map.of( + "workflowStatus", SessionStatus.ACTV.getKey() + )); + if (existActiveSession != null) { + log.debug("active session.id={} type {}", existActiveSession.getId(), existActiveSession.getSessionType()); + List d__vs = assets.searchByParams(stmt.getAccount(), CurrencyCode.RUB.getKey(), stmt.getSenderId(), D__V) + .stream() + .filter(rgs -> existActiveSession.getId().equals(rgs.getSessionId())) + .toList(); + BigDecimal d__vSum = d__vs.stream() + .map(rgs -> safeBD(rgs.getBalance())) + .reduce(BigDecimal.ZERO, BigDecimal::add); + BigDecimal amount = req.getAmount(); + req.setAmount(safeBD(amount).subtract(d__vSum)); + } gatewayRequest.setAssetOperationRequests(List.of(req)); return gatewayRequest; } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/AssetTBFProcessing.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/AssetTBFProcessing.java index d6931f97c..707c1cb8f 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/AssetTBFProcessing.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/AssetTBFProcessing.java @@ -15,7 +15,6 @@ 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 java.math.BigDecimal; import java.time.Instant; @@ -43,18 +42,25 @@ public class AssetTBFProcessing { safeWrapField(am_t::getBalance, am_t::setBalance); safeWrapField(am_b::getBalance, am_b::setBalance); safeWrapField(am_f::getBalance, am_f::setBalance); - Collection d__is = searchD__i(am_b.getAccount(), + Collection d__is = searchByParams(am_b.getAccount(), am_b.getSecuritySymbol(), am_b.getCompanyId(), - IEnumKey.getEnumByKey(RegistryInstrumentType.class, am_b.getRegistryInstrumentType())); + D__I.type(am_b.getRegistryInstrumentType())); BigDecimal d__iSum = d__is.stream() .filter(d__i -> safeBD(d__i.getBalance()).compareTo(BigDecimal.ZERO) < 0) .map(rgs -> safeBD(rgs.getBalance())) .reduce(BigDecimal.ZERO, BigDecimal::add); + Collection d__vs = searchByParams(am_b.getAccount(), + am_b.getSecuritySymbol(), + am_b.getCompanyId(), + D__V.type(am_b.getRegistryInstrumentType())); + BigDecimal d__vSum = d__vs.stream() + .map(rgs -> safeBD(rgs.getBalance())) + .reduce(BigDecimal.ZERO, BigDecimal::add); Instant now = Instant.now(); am_b.setBalance(am_b.getBalance().subtract(sum)); - am_f.setBalance(am_t.getBalance().subtract(am_b.getBalance()).add(d__iSum)); + am_f.setBalance(am_t.getBalance().subtract(am_b.getBalance()).add(d__iSum).subtract(d__vSum)); am_b.setUpdated(now); am_f.setUpdated(now); @@ -62,15 +68,11 @@ public class AssetTBFProcessing { rgsImdg.update(am_f); } - private Collection searchD__i(String account, - String securitySymbol, - Long companyId, - RegistryInstrumentType instrumentType) { + public Collection searchByParams(String account, + String securitySymbol, + Long companyId, + RegistryTradingParams params) { ImdgPredicateBuilder pb = rgsImdg.predicateBuilder(); - RegistryTradingParams params = new RegistryTradingParams( - RegistryDesignation.D, instrumentType, null, RegistryUnit.I - ); - ImdgPredicate d__iPrdct = pb.and( pb.equals("account", account), pb.equals("securitySymbol", securitySymbol), diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/PaymentStateMarkService.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/PaymentStateMarkService.java new file mode 100644 index 000000000..3621ce918 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/PaymentStateMarkService.java @@ -0,0 +1,98 @@ +package ru.spcex.clearing.service.registry; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.company.CompanyRoleSet; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.service.AssetTrio; +import ru.spcex.clearing.session.stage.util.RegistryUtil; +import ru.spcex.platform.enumeration.*; +import ru.spcex.platform.imdg.api.Imdg; +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 java.math.BigDecimal; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; +import java.util.stream.Collectors; + +import static ru.spcex.platform.enumeration.RegistryTradingParams.CM_T; +import static ru.spcex.platform.enumeration.RegistryTradingParams.LM_T; + +@Component +public class PaymentStateMarkService { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final Imdg rgsImdg; + private final Imdg cmpImdg; + private final Imdg cmpRoleImdg; + private final AssetTBFProcessing assets; + + @Autowired + public PaymentStateMarkService(ImdgProvider imdgProvider, AssetTBFProcessing assets) { + this.rgsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + this.cmpImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + this.cmpRoleImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class); + this.assets = assets; + } + + public void createDmv(Long sessionId) { + ImdgPredicateBuilder pb = rgsImdg.predicateBuilder(); + ImdgPredicate prdct = pb.and( + pb.sql(RegistryCodeSqlBuilder.getInstance(CM_T, LM_T).build()), + pb.equals("sessionId", sessionId), + pb.equals("registryStatus", RegistryStatus.OK.getKey()) + ); + Collection claimsAndLiabilities = rgsImdg.getCollectionObjectsByPredicate(prdct); + Map> groups = claimsAndLiabilities + .stream() + .collect(Collectors.groupingBy(Registry::getGroupId)); + log.debug("found {} ({} groups) CM*T/LM*T by {}", claimsAndLiabilities.size(), groups.size(), prdct.toString()); + for (Map.Entry> group : groups.entrySet()) { + Long groupId = group.getKey(); + Function findRgs = (rd) -> group.getValue() + .stream() + .filter(rgs -> rd.equalsByKey(rgs.getRegistryDesignation())) + .findFirst() + .orElse(null); + Registry cm_t = findRgs.apply(RegistryDesignation.C); + Registry lm_t = findRgs.apply(RegistryDesignation.L); + if (cm_t == null || lm_t == null) { + log.warn("groupId {}, coudn't find CM*T or LM*T", groupId); + continue; + } + CompanyRoleSet initRole = cmpRoleImdg.getFirstObjectBySQL( + "companyId = %d and companyRole = '%s' and workflowStatus = '%s'".formatted( + lm_t.getCompanyId(), + CompanyRole.ODEP.getKey(), + WorkflowStatus.Active.getKey() + ) + ); + if (initRole == null) { + log.debug("groupId {}, initiator (lm*t.id={}) does not have ODEP role", groupId, lm_t.getId()); + continue; + } + Registry dm_v = cm_t.clone(); + RegistryManager.zeroState(dm_v); + dm_v.setRegistryDesignation(RegistryDesignation.D.getKey()); + dm_v.setRegistryUnit(RegistryUnit.V.getKey()); + dm_v.setRegistryCode(RegistryUtil.clearingCode(dm_v)); + dm_v.setBalance(cm_t.getBalance()); + dm_v.setRegistryStatus(RegistryStatus.PROC.getKey()); + rgsImdg.insert(dm_v); + log.debug("groupId {}, lm*t.id={}, cm*t.id={} created dm*v.id={}", + groupId, lm_t.getId(), cm_t.getId(), dm_v.getId()); + Optional assetsFound = assets.searchMoneyByAccAndCompany(cm_t.getCompanyId(), cm_t.getAccountId()); + assetsFound.ifPresent(assetTrio + -> assets.process(assetTrio.a__b(), assetTrio.a__t(), assetTrio.a__f(), BigDecimal.ZERO)); + } + } +} 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 22e891809..b3692dae2 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 @@ -109,6 +109,7 @@ public class FinalMkrSession extends AbstractSession implements InitializingBean inspectionObligationsReturn.setSessionType(sessionType()); inspectionObligations.setSessionType(sessionType()); formingPaymentInstructionDeals.setSection(section()); + formingPaymentInstructionDeals.setSessionType(sessionType()); imdgProvider.waitAvailable(); initSessionIfPresent(); } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionAssets.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionAssets.java index a80b91369..df3838a63 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionAssets.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionAssets.java @@ -21,6 +21,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.importexport.SwtExporterR import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; import ru.spcex.clearing.service.Sdf03Creator; import ru.spcex.clearing.service.builder.PaymentInstructionBuilderV2; +import ru.spcex.clearing.service.registry.PaymentStateMarkService; import ru.spcex.clearing.service.registry.RegistryManager; import ru.spcex.clearing.session.stage.ISessionStage; import ru.spcex.clearing.session.stage.StageResult; @@ -68,10 +69,12 @@ public class FormingPaymentInstructionAssets implements ISessionStage { private final SecuritySelector securitySelector; private final RegistryManager rgsMng; private Section section; + private SessionType sessionType; + private final PaymentStateMarkService dmvSrv; @Autowired public FormingPaymentInstructionAssets(ImdgProvider imdgProvider, - Sdf03Creator sdf03Creator, KafkaSender kafkaSender, RegistryManager rgsMng) { + Sdf03Creator sdf03Creator, KafkaSender kafkaSender, RegistryManager rgsMng, PaymentStateMarkService dmvSrv) { this.sdf03Creator = sdf03Creator; this.kafkaSender = kafkaSender; this.imdgProvider = imdgProvider; @@ -85,6 +88,7 @@ public class FormingPaymentInstructionAssets implements ISessionStage { this.paymentInstructionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class); this.rgsMng = rgsMng; this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class); + this.dmvSrv = dmvSrv; } @Override @@ -126,6 +130,9 @@ public class FormingPaymentInstructionAssets implements ISessionStage { private StageResult formingPaymentInstructions(FormingPaymentInstructionPayload payload) { Long sessionId = payload.getSessionId(); + if (SessionType.FINL.equals(sessionType)) { + dmvSrv.createDmv(sessionId); + } Collection AMBregistries = selectAMBRegistries(sessionId); log.debug("found AMB registries.size() = {}", AMBregistries.size()); Instant now = Instant.now(); @@ -398,4 +405,8 @@ public class FormingPaymentInstructionAssets implements ISessionStage { public void setSection(Section section) { this.section = section; } + + public void setSessionType(SessionType sessionType) { + this.sessionType = sessionType; + } } diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CompanyRole.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CompanyRole.java new file mode 100644 index 000000000..9d750f537 --- /dev/null +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CompanyRole.java @@ -0,0 +1,19 @@ +package ru.spcex.platform.enumeration; + +import ru.spcex.platform.utils.enumeration.IEnumKey; + +public enum CompanyRole implements IEnumKey { + ODEP("ODEP") + ; + + private final String key; + + CompanyRole(String key) { + this.key = key; + } + + @Override + public String getKey() { + return key; + } +} 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 92e142ce5..4d3d5919f 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 @@ -1,5 +1,7 @@ package ru.spcex.platform.enumeration; +import ru.spcex.platform.utils.enumeration.IEnumKey; + public record RegistryTradingParams(RegistryDesignation registryDesignation, RegistryInstrumentType registryInstrumentType, RegistryCapacity registryCapacity, @@ -14,6 +16,67 @@ public record RegistryTradingParams(RegistryDesignation registryDesignation, return isEqualDesignation && isEqualInstrumentType && isEqualCapacity && isEqualUnit; } + public RegistryTradingParams dsgn(RegistryDesignation registryDesignation) { + return new RegistryTradingParams(registryDesignation, + registryInstrumentType, + registryCapacity, + registryUnit); + } + + public RegistryTradingParams dsgn(String registryDesignationS) { + RegistryDesignation registryDesignation = IEnumKey.getEnumByKey(RegistryDesignation.class, registryDesignationS); + return new RegistryTradingParams(registryDesignation, + registryInstrumentType, + registryCapacity, + registryUnit); + } + + public RegistryTradingParams type(RegistryInstrumentType registryInstrumentType) { + return new RegistryTradingParams(registryDesignation, + registryInstrumentType, + registryCapacity, + registryUnit); + } + + public RegistryTradingParams type(String registryInstrumentTypeS) { + RegistryInstrumentType registryInstrumentType = IEnumKey.getEnumByKey(RegistryInstrumentType.class, + registryInstrumentTypeS); + return new RegistryTradingParams(registryDesignation, + registryInstrumentType, + registryCapacity, + registryUnit); + } + + public RegistryTradingParams cpcty(RegistryCapacity registryCapacity) { + return new RegistryTradingParams(registryDesignation, + registryInstrumentType, + registryCapacity, + registryUnit); + } + + public RegistryTradingParams cpcty(String registryCapacityS) { + RegistryCapacity registryCapacity = IEnumKey.getEnumByKey(RegistryCapacity.class, registryCapacityS); + return new RegistryTradingParams(registryDesignation, + registryInstrumentType, + registryCapacity, + registryUnit); + } + + public RegistryTradingParams unit(RegistryUnit registryUnit) { + return new RegistryTradingParams(registryDesignation, + registryInstrumentType, + registryCapacity, + registryUnit); + } + + public RegistryTradingParams unit(String registryUnitS) { + RegistryUnit registryUnit = IEnumKey.getEnumByKey(RegistryUnit.class, registryUnitS); + return new RegistryTradingParams(registryDesignation, + registryInstrumentType, + registryCapacity, + registryUnit); + } + public final static RegistryTradingParams OS_T; public final static RegistryTradingParams OM_T; public final static RegistryTradingParams TS_T; @@ -42,6 +105,7 @@ public record RegistryTradingParams(RegistryDesignation registryDesignation, public final static RegistryTradingParams LM__; public final static RegistryTradingParams DMAU; public final static RegistryTradingParams D__I; + public final static RegistryTradingParams D__V; static { OS_T = new RegistryTradingParams(RegistryDesignation.O, @@ -157,6 +221,10 @@ public record RegistryTradingParams(RegistryDesignation registryDesignation, null, null, RegistryUnit.I); + D__V = new RegistryTradingParams(RegistryDesignation.D, + null, + null, + RegistryUnit.V); } } diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryUnit.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryUnit.java index 0466b4367..aaf4a5e17 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryUnit.java +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryUnit.java @@ -11,6 +11,7 @@ public enum RegistryUnit implements IEnumKey { X("X"), U("U"), I("I"), + V("V"), ; private final String key;