From c1d70b599071a4bb4e0fe2d40dc8732da20fb377 Mon Sep 17 00:00:00 2001 From: aalehin Date: Thu, 25 May 2023 19:21:50 +0300 Subject: [PATCH 1/6] http://jira.mfd.msk:8088/browse/CLS-284 --- bug fix --- .../company/config/validation/RelationValidationConfig.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/config/validation/RelationValidationConfig.java b/clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/config/validation/RelationValidationConfig.java index 1bc83df1e..1f3d7b6de 100644 --- a/clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/config/validation/RelationValidationConfig.java +++ b/clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/config/validation/RelationValidationConfig.java @@ -5,7 +5,7 @@ import org.springframework.context.annotation.Configuration; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.company.relation.Relation; import ru.clearing.platform.dictionary.ClearingCategoryDictionary; -import ru.clearing.platform.dictionary.WorkflowStatusDictionary; +import ru.clearing.platform.dictionary.ServiceStatusDictionary; import ru.spcex.clearing.company.error.CompanyErrors; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; @@ -53,7 +53,7 @@ public class RelationValidationConfig { DictionaryPresentRule.instance("serviceStatus", RelationNewRequest::getServiceStatus, IMDGDistributedNames.Map_ServiceStatusDictionary, - WorkflowStatusDictionary.class, + ServiceStatusDictionary.class, CompanyErrors.RequiredFieldEmpty, CompanyErrors.WrongFieldValue) ); @@ -104,7 +104,7 @@ public class RelationValidationConfig { DictionaryPresentRule.instance("serviceStatus", RelationUpdateRequest::getServiceStatus, IMDGDistributedNames.Map_ServiceStatusDictionary, - WorkflowStatusDictionary.class, + ServiceStatusDictionary.class, CompanyErrors.RequiredFieldEmpty, CompanyErrors.WrongFieldValue) ); From ca30893ed28d39ea6fc4f9ce41bad2ae30a9b496 Mon Sep 17 00:00:00 2001 From: AKurakin Date: Thu, 25 May 2023 19:33:31 +0300 Subject: [PATCH 2/6] =?UTF-8?q?backend-api=20http://jira.mfd.msk:8088/brow?= =?UTF-8?q?se/CLS-331=20=D0=B2=D0=B0=D0=BB=D0=B8=D0=B4=D0=B0=D1=86=D0=B8?= =?UTF-8?q?=D1=8F=20=D1=80=D0=B5=D0=BA=D1=81=D0=B5=D1=81=D1=82=D0=BE=D0=B2?= =?UTF-8?q?,=20=D0=BF=D0=BE=D0=BF=D1=80=D0=B0=D0=B2=D0=B8=D0=BB=20=D1=80?= =?UTF-8?q?=D0=B5=D0=BA=D0=B2=D0=B5=D1=81=D1=82=D1=8B,=20=D0=B4=D0=BE?= =?UTF-8?q?=D0=B1=D0=B0=D0=B2=D0=B8=D0=BB=20=D1=82=D0=B5=D1=81=D1=82=D0=B8?= =?UTF-8?q?=D1=80=D0=B2=D0=BE=D0=B0=D0=BD=D0=B8=D0=B5=20=D0=B8=20=D0=B8?= =?UTF-8?q?=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D0=B5=20(todo)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../cud/account/BankAccountNewAction.java | 8 ++++ .../validation/ActionMetaValidation.java | 42 +++++++++++++++---- .../validation/ActionMetaValidationTest.java | 35 ++++++++++++++++ 3 files changed, 78 insertions(+), 7 deletions(-) diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java index 234cbd25c..694729b3e 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java @@ -159,4 +159,12 @@ public class BankAccountNewAction implements IAction { public void setAccount(String account) { this.account = account; } + + public Long getCompanyId() { + return companyId; + } + + public void setCompanyId(Long companyId) { + this.companyId = companyId; + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidation.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidation.java index 6e2331892..a3eb2fdc6 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidation.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidation.java @@ -1,11 +1,13 @@ package ru.spcex.clearing.backendapi.service.validation; import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.exception.ExceptionUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; +import ru.spcex.clearing.backendapi.controller.request.cud.securities.MoneyMarketSecurityUpdateAction; import ru.spcex.clearing.backendapi.domain.actions.IAction; import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.backendapi.meta.FieldExtracted; @@ -28,8 +30,8 @@ import java.util.function.Function; */ @Component public class ActionMetaValidation implements InitializingBean { - protected final Logger log = LoggerFactory.getLogger(getClass()); - private final Map> validators; + protected static final Logger log = LoggerFactory.getLogger(ActionMetaValidation.class); + protected final Map> validators; protected final MetaServer meta; @Autowired @@ -67,6 +69,26 @@ public class ActionMetaValidation implements InitializingBean { // нет обязательных полей для валидации return null; } + // Тестирование getter + { + Object object; + try { + object = metaAction.getClazz().getDeclaredConstructor().newInstance(); + } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) { + throw new RuntimeException("Error self-test validator on class " + metaAction.getClazz(), e); + } + for (FieldExtracted field : metaAction.getFields()) { + try { + if (field.getField().isRequired() != null && field.getField().isRequired()) { + Object value = field.extractValue(object); + } + } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) { + log.warn("Error self-test validator on class {} and field {}: {}", + metaAction.getClazz(), field.getMemberName(), ExceptionUtils.getStackTrace(e)); + ); + } + } + } final MetaValidatorRule metaValidatorRule = new MetaValidatorRule(metaAction); return iAcc -> { ImdgValidationContext ctx = new ImdgValidationContext<>(); @@ -88,8 +110,8 @@ public class ActionMetaValidation implements InitializingBean { @Override public Optional validate(ImdgValidationContext context) { IAction object = context.getValidatedObject(); - try { - for (FieldExtracted field : metaAction.getFields()) { + for (FieldExtracted field : metaAction.getFields()) { + try { if (field.getField().isRequired() != null && field.getField().isRequired()) { Object value = field.extractValue(object); if (value == null) @@ -97,10 +119,16 @@ public class ActionMetaValidation implements InitializingBean { // if (value instanceof String && ((String)value).isEmpty()) // пустое поле, но не null // return of(BackEndError.ValidationError, field.getMemberName()); } + } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { + if (object instanceof MoneyMarketSecurityUpdateAction) { + //todo в мете для moneyMarketSecurity / actions / put / для поля lotSize field="securityId" исключение - там надо оставить field, требуется для frontend + if (((MoneyMarketSecurityUpdateAction) object).getLotSize() == null) + return of(BackEndError.ValidationError, "LotSize"); + } else { + log.warn("Error apply meta-validator {} for {} : {}", + metaAction, object, e.toString()); + } } - - } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { - throw new RuntimeException("Validator error verify " + object + " by " + metaAction); } return empty(); } diff --git a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidationTest.java b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidationTest.java index 9f4484cbf..568ea0fd8 100644 --- a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidationTest.java +++ b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidationTest.java @@ -6,6 +6,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.spcex.clearing.backendapi.controller.request.cud.account.BankAccountNewAction; import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction; import ru.spcex.clearing.backendapi.controller.request.cud.company.ListingNewAction; import ru.spcex.clearing.backendapi.domain.actions.IAction; @@ -56,4 +57,38 @@ class ActionMetaValidationTest { assertEquals("[]", vResult.toString()); } } + + @Test + void testForBankAccountNewAction() { + ActionMetaValidation metaValidator = new ActionMetaValidation(meta); + metaValidator.afterPropertiesSet(); + + { + BankAccountNewAction action = new BankAccountNewAction(); + assertTrue(action.validate().isEmpty()); + IValidator v = metaValidator.getValidator(null, action); + assertNotNull(v); + Collection vResult = v.validateAll(); + assertEquals("[EnumMessage{subject=ValidationError, args: [currency]}]", vResult.toString()); + } + { + BankAccountNewAction action = new BankAccountNewAction(); + action.setBankIdentificationCode("Hello world"); + action.setBankName("Hello world"); + action.setCorrespondentAccount("Hello world"); + action.setCorrespondentAccountName("Hello world"); + action.setCurrency("Hello world"); + action.setDestination("Hello world"); + action.setTaxpayerIdentificationNumber("Hello world"); + action.setTaxRegistrationReasonCode("Hello world"); + action.setAccount("Hello world"); + action.setCompanyId(123L); + + IValidator v = metaValidator.getValidator(null, action); + assertNotNull(v); + Collection vResult = v.validateAll(); + assertEquals("[]", vResult.toString()); + } + } + } \ No newline at end of file From d3a8aaff7a23d55aa14ba7569813c9a6df0dab1f Mon Sep 17 00:00:00 2001 From: AKurakin Date: Thu, 25 May 2023 19:39:49 +0300 Subject: [PATCH 3/6] =?UTF-8?q?backend-api=20http://jira.mfd.msk:8088/brow?= =?UTF-8?q?se/CLS-331=20=D0=B2=D0=B0=D0=BB=D0=B8=D0=B4=D0=B0=D1=86=D0=B8?= =?UTF-8?q?=D1=8F=20=D1=80=D0=B5=D0=BA=D1=81=D0=B5=D1=81=D1=82=D0=BE=D0=B2?= =?UTF-8?q?,=20=D0=BF=D0=BE=D0=BF=D1=80=D0=B0=D0=B2=D0=B8=D0=BB=20=D1=80?= =?UTF-8?q?=D0=B5=D0=BA=D0=B2=D0=B5=D1=81=D1=82=D1=8B,=20=D0=B4=D0=BE?= =?UTF-8?q?=D0=B1=D0=B0=D0=B2=D0=B8=D0=BB=20=D1=82=D0=B5=D1=81=D1=82=D0=B8?= =?UTF-8?q?=D1=80=D0=B2=D0=BE=D0=B0=D0=BD=D0=B8=D0=B5=20=D0=B8=20=D0=B8?= =?UTF-8?q?=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D0=B5=20(todo)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../backendapi/service/validation/ActionMetaValidation.java | 1 - 1 file changed, 1 deletion(-) diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidation.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidation.java index a3eb2fdc6..c9d171354 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidation.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidation.java @@ -85,7 +85,6 @@ public class ActionMetaValidation implements InitializingBean { } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) { log.warn("Error self-test validator on class {} and field {}: {}", metaAction.getClazz(), field.getMemberName(), ExceptionUtils.getStackTrace(e)); - ); } } } From 61d7570b3599052365bdaa5945ddb3a9ad802088 Mon Sep 17 00:00:00 2001 From: etreshenkov Date: Thu, 25 May 2023 20:15:52 +0300 Subject: [PATCH 4/6] remove stage 8 --- .../clearing/config/SdfExecutorsConfig.java | 10 +- .../clearing/service/StatementService.java | 85 ++++++++++---- .../service/executors/Sdf04Executor.java | 98 ++++++++++++++++ .../service/executors/Sdf13Executor.java | 105 ++++++++++++++++++ 4 files changed, 274 insertions(+), 24 deletions(-) create mode 100644 clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf04Executor.java create mode 100644 clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf13Executor.java diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java index 86a1142e9..7058e98d2 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java @@ -2,9 +2,7 @@ package ru.spcex.clearing.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import ru.spcex.clearing.service.executors.AbstractExecutor; -import ru.spcex.clearing.service.executors.Sdf01Executor; -import ru.spcex.clearing.service.executors.Sdf57Executor; +import ru.spcex.clearing.service.executors.*; import ru.spcex.platform.enumeration.SdfTable; import java.util.HashMap; @@ -15,10 +13,14 @@ public class SdfExecutorsConfig { @Bean("sdfExecutors") public Map> executorsMap(Sdf01Executor sdf01Executor, - Sdf57Executor sdf57Executor) { + Sdf57Executor sdf57Executor, + Sdf04Executor sdf04Executor, + Sdf13Executor sdf13Executor) { Map> executors = new HashMap<>(); executors.put(SdfTable.SDF_01, sdf01Executor); executors.put(SdfTable.SDF_57, sdf57Executor); + executors.put(SdfTable.SDF_04, sdf04Executor); + executors.put(SdfTable.SDF_13, sdf13Executor); return executors; } } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java index d5fb99007..00bd44fee 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java @@ -8,6 +8,8 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; import ru.clearing.classes.statics.data.sdf.SDf01; +import ru.clearing.classes.statics.data.sdf.SDf04; +import ru.clearing.classes.statics.data.sdf.SDf13; import ru.clearing.classes.statics.data.sdf.SDf57; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.BaseRequest; @@ -41,7 +43,7 @@ public class StatementService extends QueueConsumer implements InitializingBean /** * Пары sdf запросов пришедшие с модуля dbf-import */ - private final List> pairOfSdfRequest = new LinkedList<>(); + private final Map> pairOfSdfRequest = new HashMap<>(); @Autowired public StatementService(Consumer kafkaQueue, @@ -55,6 +57,8 @@ public class StatementService extends QueueConsumer implements InitializingBean this.executorsMap = executorsMap; this.sdfImdgs.put(SdfTable.SDF_01, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class)); this.sdfImdgs.put(SdfTable.SDF_57, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf57, SDf57.class)); + this.sdfImdgs.put(SdfTable.SDF_04, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf04, SDf04.class)); + this.sdfImdgs.put(SdfTable.SDF_13, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf13, SDf13.class)); } @Override @@ -67,16 +71,15 @@ public class StatementService extends QueueConsumer implements InitializingBean private void process(BaseRequest systemRequest) { StatementRequest statementRequest = systemRequest.getRequestPayload(); - Collection sdfGroup; SdfTable table = statementRequest.getTable(); - Imdg sdfImdg = sdfImdgs.get(table); - Optional> completePairOpt = saveRequest(statementRequest); - if (completePairOpt.isPresent()) { + Optional completePairKey = saveRequest(statementRequest); + if (completePairKey.isPresent()) { if (List.of(SdfTable.SDF_01, SdfTable.SDF_57).contains(table)) { { //всегда сначала обработаем sdf57 - Pair pair = completePairOpt.get(); + Long key = completePairKey.get(); + Pair pair = pairOfSdfRequest.get(key); processSdf57(pair.getSecond()); //затем sdf01 @@ -84,9 +87,23 @@ public class StatementService extends QueueConsumer implements InitializingBean //теперь можем продолжить сессию с шага 1 ContinueSessionBnRequest continueSessionBn = new ContinueSessionBnRequest(); kafkaSender.sendRequestToQueue(Consts.CONTINUE_SESSION_BN_FIRST_PART, continueSessionBn); + pairOfSdfRequest.remove(key); } } else if (List.of(SdfTable.SDF_08, SdfTable.SDF_13).contains(table)) { //not implemented part; it's actually stage number 8 from any session + { + //всегда сначала обработаем sdf04 + Long key = completePairKey.get(); + Pair pair = pairOfSdfRequest.get(key); + processSdf04(pair.getFirst()); + + //затем sdf01 + processSdf13(pair.getSecond()); + //теперь можем продолжить сессию с шага 1 + ContinueSessionBnRequest continueSessionBn = new ContinueSessionBnRequest(); + kafkaSender.sendRequestToQueue(Consts.CONTINUE_SESSION_BN_SECOND_PART, continueSessionBn); + pairOfSdfRequest.remove(key); + } } } } @@ -99,6 +116,22 @@ public class StatementService extends QueueConsumer implements InitializingBean service.execute(sdfGroup, statementRequest); } + private void processSdf04(StatementRequest statementRequest) { + Imdg sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf04, SDf04.class); + Collection sdfGroup = sdfImdg.getCollectionObjectsByFieldValues(Map.of( + "generationId", statementRequest.getGroupId())); + AbstractExecutor service = executorsMap.get(SdfTable.SDF_04); + service.execute(sdfGroup, statementRequest); + } + + private void processSdf13(StatementRequest statementRequest) { + Imdg sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf13, SDf13.class); + Collection sdfGroup = sdfImdg.getCollectionObjectsByFieldValues(Map.of( + "generationId", statementRequest.getGroupId())); + AbstractExecutor service = executorsMap.get(SdfTable.SDF_13); + service.execute(sdfGroup, statementRequest); + } + private void processSdf01(StatementRequest statementRequest) { Imdg sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class); Collection sdfGroup; @@ -122,25 +155,31 @@ public class StatementService extends QueueConsumer implements InitializingBean } } - private Optional> saveRequest(StatementRequest statementRequest) { + private Optional saveRequest(StatementRequest statementRequest) { SdfTable sdfTable = statementRequest.getTable(); if (pairOfSdfRequest.isEmpty()) { - pairOfSdfRequest.add(getPairByTableName(sdfTable, statementRequest)); + Long id = imdgProvider.getImdgIdGenerator().nextId(); + ; + pairOfSdfRequest.put(id, getPairByTableName(sdfTable, statementRequest)); } else { //найдем первую неполноценную пару - Optional> uncompletedPairOpt = findUncompletedPairByTableName(sdfTable); - if (uncompletedPairOpt.isPresent()) { - Pair uncompletedPair = uncompletedPairOpt.get(); - if (uncompletedPair.getFirst() == null) { - uncompletedPair.setFirst(statementRequest); + Optional uncompletedPairId = findUncompletedPairByTableName(sdfTable); + if (uncompletedPairId.isPresent()) { + Long key = uncompletedPairId.get(); + Pair completed = pairOfSdfRequest.get(key); + if (completed.getFirst() == null) { + completed.setFirst(statementRequest); } else { - uncompletedPair.setSecond(statementRequest); + completed.setSecond(statementRequest); } + pairOfSdfRequest.put(key, completed); //укомплектованная пара - return Optional.of(uncompletedPair); + return Optional.of(key); } else { //если таких нет, то просто создаем новую с одной частью - pairOfSdfRequest.add(getPairByTableName(sdfTable, statementRequest)); + Long id = imdgProvider.getImdgIdGenerator().nextId(); + ; + pairOfSdfRequest.put(id, getPairByTableName(sdfTable, statementRequest)); } } return Optional.empty(); @@ -151,17 +190,23 @@ public class StatementService extends QueueConsumer implements InitializingBean switch (sdfTable) { case SDF_01 -> pair = new Pair<>(statementRequest, null); case SDF_57 -> pair = new Pair<>(null, statementRequest); + case SDF_04 -> pair = new Pair<>(statementRequest, null); + case SDF_13 -> pair = new Pair<>(null, statementRequest); } return pair; } - private Optional> findUncompletedPairByTableName(SdfTable sdfTable) { - Optional> uncompletedPair = Optional.empty(); + private Optional findUncompletedPairByTableName(SdfTable sdfTable) { + Optional uncompletedPair = Optional.empty(); switch (sdfTable) { case SDF_01 -> - uncompletedPair = pairOfSdfRequest.stream().filter(pair -> pair.getFirst() != null && pair.getSecond() == null).findFirst(); + uncompletedPair = pairOfSdfRequest.entrySet().stream().filter(entry -> entry.getValue().getFirst() != null && entry.getValue().getSecond() == null).findFirst().map(Map.Entry::getKey); case SDF_57 -> - uncompletedPair = pairOfSdfRequest.stream().filter(pair -> pair.getSecond() != null && pair.getFirst() == null).findFirst(); + uncompletedPair = pairOfSdfRequest.entrySet().stream().filter(entry -> entry.getValue().getFirst() == null && entry.getValue().getSecond() != null).findFirst().map(Map.Entry::getKey); + case SDF_04 -> + uncompletedPair = pairOfSdfRequest.entrySet().stream().filter(entry -> entry.getValue().getFirst() != null && entry.getValue().getSecond() == null).findFirst().map(Map.Entry::getKey); + case SDF_13 -> + uncompletedPair = pairOfSdfRequest.entrySet().stream().filter(entry -> entry.getValue().getFirst() == null && entry.getValue().getSecond() != null).findFirst().map(Map.Entry::getKey); } return uncompletedPair; } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf04Executor.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf04Executor.java new file mode 100644 index 000000000..a14733a95 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf04Executor.java @@ -0,0 +1,98 @@ +package ru.spcex.clearing.service.executors; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.clearing.classes.statics.data.sdf.SDf04; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.clearing.service.model.Result; +import ru.spcex.platform.enumeration.RegistryDesignation; +import ru.spcex.platform.enumeration.RegistryInstrumentType; +import ru.spcex.platform.enumeration.RegistryUnit; +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 java.math.BigDecimal; +import java.util.Collection; +import java.util.Collections; + +@Service +public class Sdf04Executor extends AbstractExecutor { + private final Logger log = LoggerFactory.getLogger(getClass()); + + private final ImdgProvider imdgProvider; + private final Imdg registryImdg; + + public Sdf04Executor(ImdgProvider imdgProvider) { + this.imdgProvider = imdgProvider; + this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + } + + @Override + public String exportTableName() { + return ""; + } + + @Override + public boolean isNeedToSendCommand() { + return false; + } + + @Override + public void sendCommand(KafkaSender kafkaSender, Result result) { + } + + public Result execute(Collection sdf, StatementRequest statementRequest) { + Result result = new Result(); + Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId(); + result.setGenerationId(generationIdForGroup); + for (SDf04 sdf04 : sdf) { + //обычно мы ищем по группу sdf04, здесь как будто всегда только одна запись, todo нужно прочекать этот момент + log.debug("Process sdf04 record; sdf04.id: {}", sdf04.getId()); + Collection fullNames = Collections.emptyList(); //fixme что значит registry.fullName=sDf04.(sbanknam1, sbanknam2 и т.д.) + Collection registries = selectRegistryForSDF04(sdf04.getC_acc_cred(), fullNames); + registries.forEach(registry -> unlockRegistry(registry, new BigDecimal(sdf04.getPay_val()))); + } + return result; + } + + protected Collection selectRegistryForSDF04(String account, Collection fullNames) { + ImdgPredicateBuilder pb = registryImdg.predicateBuilder(); + ImdgPredicate query = pb.and( + pb.and( + pb.equals("registryDesignation", RegistryDesignation.A.getKey()), + pb.equals("registryInstrumentType", RegistryInstrumentType.M.getKey()), + pb.or(pb.equals("registryUnit", RegistryUnit.F.getKey()), + pb.equals("registryUnit", RegistryUnit.B.getKey())) + ), + pb.equals("account", account) +// , +// pb.in("fullName", fullNames.toArray(new String[fullNames.size()])) + ); + + Collection result = registryImdg.getCollectionObjectsByPredicate(query); + log.trace("Selected {} registry's by sql: {}", result.size(), query); + return result; + } + + boolean unlockRegistry(Registry registry, BigDecimal value) { + if (RegistryUnit.F.equalsByKey(registry.getRegistryUnit())) { + if (registry.getBalance() == null) registry.setBalance(BigDecimal.ZERO); + registry.setBalance(registry.getBalance().add(value)); + return true; + } else if (RegistryUnit.B.equalsByKey(registry.getRegistryUnit())) { + if (registry.getBalance() == null) registry.setBalance(BigDecimal.ZERO); + registry.setBalance(registry.getBalance().subtract(value)); + return true; + } else { + log.warn("For registry {} registryUnit={} unlock operation not implemented.", + registry.getId(), registry.getRegistryUnit()); + return false; + } + } +} diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf13Executor.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf13Executor.java new file mode 100644 index 000000000..688e17d14 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf13Executor.java @@ -0,0 +1,105 @@ +package ru.spcex.clearing.service.executors; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.clearing.classes.statics.data.sdf.SDf12; +import ru.clearing.classes.statics.data.sdf.SDf13; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.clearing.service.model.Result; +import ru.spcex.platform.enumeration.RegistryDesignation; +import ru.spcex.platform.enumeration.RegistryInstrumentType; +import ru.spcex.platform.enumeration.RegistryUnit; +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 java.math.BigDecimal; +import java.util.Collection; + +@Service +public class Sdf13Executor extends AbstractExecutor { + private final Logger log = LoggerFactory.getLogger(getClass()); + + private final Imdg sdf12Imdg; + private final ImdgProvider imdgProvider; + private final Imdg registryImdg; + + public Sdf13Executor(ImdgProvider imdgProvider) { + this.imdgProvider = imdgProvider; + this.sdf12Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf12, SDf12.class); + this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + } + + @Override + public String exportTableName() { + return ""; + } + + @Override + public boolean isNeedToSendCommand() { + return false; + } + + @Override + public void sendCommand(KafkaSender kafkaSender, Result result) { + } + + public Result execute(Collection sdf, StatementRequest statementRequest) { + Result result = new Result(); + Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId(); + result.setGenerationId(generationIdForGroup); + for (SDf13 sdf13 : sdf) { + //обычно мы ищем по группу sdf04, здесь как будто всегда только одна запись, todo нужно прочекать этот момент + SDf12 sDf12 = selectSdf12bySdf13(sdf13); + log.debug("Process sdf13 record; sdf13.id: {}", sdf13.getId()); + Collection registries = selectRegistryForSDF12(sDf12.getDepoCodeSender(), sDf12.getSecurityCode()); + registries.forEach(registry -> unlockRegistry(registry, new BigDecimal(sDf12.getQuantity()))); + } + return result; + } + + protected SDf12 selectSdf12bySdf13(SDf13 sDf13) { + SDf12 sdf12 = sdf12Imdg.getSingleObjectByID(sDf13.getId()); + log.trace("Selected sdf12 by sdf13"); + return sdf12; + } + + protected Collection selectRegistryForSDF12(String account, String securityCode) { + ImdgPredicateBuilder pb = registryImdg.predicateBuilder(); + ImdgPredicate query = pb.and( + pb.and( + pb.equals("registryDesignation", RegistryDesignation.A.getKey()), + pb.equals("registryInstrumentType", RegistryInstrumentType.M.getKey()), + pb.or(pb.equals("registryUnit", RegistryUnit.F.getKey()), + pb.equals("registryUnit", RegistryUnit.B.getKey())) + ), + pb.equals("account", account), + pb.equals("securityCode", securityCode) + ); + + Collection result = registryImdg.getCollectionObjectsByPredicate(query); + log.trace("Selected {} registry's by sql: {}", result.size(), query); + return result; + } + + boolean unlockRegistry(Registry registry, BigDecimal value) { + if (RegistryUnit.F.equalsByKey(registry.getRegistryUnit())) { + if (registry.getBalance() == null) registry.setBalance(BigDecimal.ZERO); + registry.setBalance(registry.getBalance().add(value)); + return true; + } else if (RegistryUnit.B.equalsByKey(registry.getRegistryUnit())) { + if (registry.getBalance() == null) registry.setBalance(BigDecimal.ZERO); + registry.setBalance(registry.getBalance().subtract(value)); + return true; + } else { + log.warn("For registry {} registryUnit={} unlock operation not implemented.", + registry.getId(), registry.getRegistryUnit()); + return false; + } + } +} From 46a3060ba960a3409082acbb0f9d245eba2e467f Mon Sep 17 00:00:00 2001 From: etreshenkov Date: Thu, 25 May 2023 20:18:01 +0300 Subject: [PATCH 5/6] remove stage 8 --- .../main/java/ru/spcex/clearing/service/StatementService.java | 1 - 1 file changed, 1 deletion(-) diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java index 00bd44fee..e2b076037 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java @@ -159,7 +159,6 @@ public class StatementService extends QueueConsumer implements InitializingBean SdfTable sdfTable = statementRequest.getTable(); if (pairOfSdfRequest.isEmpty()) { Long id = imdgProvider.getImdgIdGenerator().nextId(); - ; pairOfSdfRequest.put(id, getPairByTableName(sdfTable, statementRequest)); } else { //найдем первую неполноценную пару From a220b414438401e97950202566b4c2cfb7802a72 Mon Sep 17 00:00:00 2001 From: etreshenkov Date: Thu, 25 May 2023 20:20:40 +0300 Subject: [PATCH 6/6] http://jira.mfd.msk:8088/browse/CLS-290 --- .../ru/spcex/clearing/session/stage/impl/UnlockResources.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/UnlockResources.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/UnlockResources.java index c9771965d..837461e73 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/UnlockResources.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/UnlockResources.java @@ -27,6 +27,8 @@ import java.util.Collection; @Service @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) +@Deprecated +//не должен использоваться как stage в сессии, данная логика перенесена в statementService public class UnlockResources implements ISessionStage { private final Logger log = LoggerFactory.getLogger(getClass());