From 10fa81015185df33dcf7af3bc082014a37712420 Mon Sep 17 00:00:00 2001 From: ialbert Date: Wed, 5 Oct 2022 20:19:16 +0300 Subject: [PATCH] http://jira.mfd.msk:8088/browse/CLS-36 --- .../balance/config/ValidationConfig.java | 20 +++++ .../clearing/balance/errors/BalanceError.java | 4 +- .../service/AccountBalanceService.java | 79 +++++++++++++++++++ .../balance/service/AccountResult.java | 25 ++++++ .../balance/service/StatementService.java | 46 +++++------ .../validation/AccountBalanceValidation.java | 3 + .../AccountBalanceValidationRule.java | 55 +++++++++++++ .../validation/Sdf01ValidationRule.java | 6 +- .../balance/validation/ValidationStored.java | 2 +- .../enumeration/BalanceAccountType.java | 18 +++++ platform-parent/platform-imdg-api/pom.xml | 4 + .../validation}/ImdgValidationContext.java | 6 +- 12 files changed, 235 insertions(+), 33 deletions(-) create mode 100644 clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AccountBalanceService.java create mode 100644 clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AccountResult.java create mode 100644 clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceValidation.java create mode 100644 clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceValidationRule.java create mode 100644 platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/BalanceAccountType.java rename {clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config => platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/validation}/ImdgValidationContext.java (90%) diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java index dcdd3693d..72446bfdc 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java @@ -6,10 +6,13 @@ import org.springframework.context.annotation.Configuration; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.sdf.SDf01; +import ru.spcex.clearing.balance.validation.AccountBalanceValidation; +import ru.spcex.clearing.balance.validation.AccountBalanceValidationRule; import ru.spcex.clearing.balance.validation.Sdf01ValidationRule; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; import ru.spcex.platform.utils.validation.IValidator; import ru.spcex.platform.utils.validation.ValidatorImpl; @@ -38,4 +41,21 @@ public class ValidationConfig { }; } + @Autowired + @Bean("accountBalanceValidator") + public Function accountBalanceValidator(ImdgProvider imdgProvider) { + return fieldsToValidateWrapper -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(fieldsToValidateWrapper); + BiConsumer> addImdg = (s, aClass) -> context.addImdg(s, imdgProvider.getImdg(s, aClass)); + addImdg.accept(IMDGDistributedNames.Map_Account, Account.class); + addImdg.accept(IMDGDistributedNames.Map_Company, Company.class); + return new ValidatorImpl<>(context, + AccountBalanceValidationRule.CompanyPresent, + AccountBalanceValidationRule.AccountOk); + }; + } + + + } diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java index 1a02ebb7b..2cd8704de 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java @@ -8,7 +8,9 @@ public enum BalanceError implements IEnumId { CurrentDateOnly(5214L), WrongMarket(5215L), WrongAccount(5215L), - AccountNotPresent(-1L); + AccountNotPresent(5217L), + AccountNotActive(5218L) + ; private final Long id; BalanceError(Long id) { diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AccountBalanceService.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AccountBalanceService.java new file mode 100644 index 000000000..3eff4627f --- /dev/null +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AccountBalanceService.java @@ -0,0 +1,79 @@ +package ru.spcex.clearing.balance.service; + +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.account.AccountBalance; +import ru.clearing.classes.statics.data.company.Company; +import ru.spcex.clearing.balance.validation.AccountBalanceValidation; +import ru.spcex.clearing.balance.validation.ValidationStored; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.enumeration.BalanceAccountType; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.validation.IValidator; + +import java.math.BigDecimal; +import java.time.Instant; +import java.time.LocalDate; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; + +@Component +public class AccountBalanceService { + private final ImdgProvider imdgProvider; + private final Imdg accountBalanceImdg; + private final Function validationFactory; + + public AccountBalanceService(ImdgProvider imdgProvider, + @Qualifier("accountBalanceValidator") Function validationFactory) { + this.imdgProvider = imdgProvider; + this.validationFactory = validationFactory; + this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); + } + + public AccountResult createAccountBalance(Long addresseeId, Long accountId, BigDecimal amount, + String cashMovementCurrencyCode) { + IValidator validator = validationFactory.apply(new AccountBalanceValidation(addresseeId, accountId)); + Optional validationError = validator + .tillFirstError(); + if (validationError.isPresent()) return new AccountResult(validationError.get()); + Account account = validator.getStored(ValidationStored.Account); + Company company = validator.getStored(ValidationStored.Company); + //которой accountBalance.accountId=statement.accountId и accountBalance.companyId=statement.companyId: + + AccountBalance accountBalance = accountBalanceImdg.getSingleObjectByFieldValues( + Map.of("accountId", accountId, "companyId", addresseeId) + ); + if (accountBalance == null) { + accountBalance = new AccountBalance(); + accountBalance.setCompanyId(addresseeId); + accountBalance.setCreated(Instant.now()); + accountBalance.setAccountId(accountId); +//fixme accountBalance.setAccountType(account.getAccountType()); + accountBalance.setAccount(account.getAccount()); + accountBalance.setOpenBalanceAmount(amount); + accountBalance.setFreeBalanceAmount(amount); + accountBalance.setBalanceAmount(amount); + accountBalance.setBalanceAccountType(BalanceAccountType.Active.getKey()); + accountBalance.setClearingDate(LocalDate.now()); + accountBalance.setCurrencyCode(cashMovementCurrencyCode); + accountBalance.setTradingCode(company.getTradingCode()); + accountBalance.setShortName(company.getShortName()); + accountBalance.setFullName(company.getFullName()); + return new AccountResult(accountBalance); + } else { + accountBalance.setUpdated(Instant.now()); + accountBalance.setAccountId(accountId); + //fixme accountBalance.setAccountType(account.getAccountType()); + accountBalance.setAccount(account.getAccount()); + accountBalance.setOpenBalanceAmount(amount); + accountBalance.setFreeBalanceAmount(amount); + accountBalance.setBalanceAmount(amount); + accountBalance.setCurrencyCode(cashMovementCurrencyCode); + return new AccountResult(accountBalance); + } + } +} diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AccountResult.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AccountResult.java new file mode 100644 index 000000000..0e38e0dde --- /dev/null +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AccountResult.java @@ -0,0 +1,25 @@ +package ru.spcex.clearing.balance.service; + +import ru.clearing.classes.statics.data.account.AccountBalance; +import ru.spcex.platform.utils.enumeration.EnumMessage; + +public class AccountResult { + private EnumMessage error; //if was + private AccountBalance account; + + public AccountResult(EnumMessage validationError) { + this.error = validationError; + } + + public AccountResult(AccountBalance account) { + this.account = account; + } + + public EnumMessage getError() { + return error; + } + + public AccountBalance getAccount() { + return account; + } +} diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java index 80a178ac5..0506c16f0 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java @@ -8,6 +8,7 @@ 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.account.Account; +import ru.clearing.classes.statics.data.account.AccountBalance; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.sdf.SDf01; import ru.clearing.classes.statics.data.sdf.SDf02; @@ -28,6 +29,7 @@ import ru.spcex.platform.enumeration.*; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.enumeration.IMessageResolver; import ru.spcex.platform.utils.time.TimeUtil; import ru.spcex.platform.utils.validation.IValidator; @@ -51,19 +53,25 @@ public class StatementService extends QueueConsumer implements InitializingBean private final Imdg accountBalanceImdg; private final Imdg statementImdg; private final Function sDf01Validator; + private final AccountBalanceService accountBalanceService; + private final IMessageResolver errorResolver; @Autowired public StatementService(Consumer kafkaQueue, ImdgProvider imdgProvider, KafkaSender kafkaReqProducer, LoggingService errorLogger, - @Qualifier("sdf01Validator") Function sDf01Validator) { + @Qualifier("sdf01Validator") Function sDf01Validator, + AccountBalanceService accountBalanceService, + IMessageResolver errorResolver) { super(kafkaQueue); this.imdgProvider = imdgProvider; this.sdf01Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class); - this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);; + this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class); + this.accountBalanceService = accountBalanceService; this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class); this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); this.kafkaReqProducer = kafkaReqProducer; this.errorLogger = errorLogger; this.sDf01Validator = sDf01Validator; + this.errorResolver = errorResolver; } @Override @@ -95,7 +103,7 @@ public class StatementService extends QueueConsumer implements InitializingBean for (SDf01 sdf01 : sdf01Group) { IValidator validator = sDf01Validator.apply(sdf01); Optional error = validator.tillFirstError(); - Company company = validator.getStored(ValidationStored.Sdf01Company); + Company company = validator.getStored(ValidationStored.Company); if (statementRequest.getAccountCreationResults().size() == 0 && BalanceError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) { //на данном шаге company существует -> getId ok @@ -115,18 +123,22 @@ public class StatementService extends QueueConsumer implements InitializingBean if (statement == null) { statement = createFlow(sdf01, company, - validator.getStored(ValidationStored.Sdf01Account)); + validator.getStored(ValidationStored.Account)); } else { updateFlow(statement, sdf01, - validator.getStored(ValidationStored.Sdf01Account)); + validator.getStored(ValidationStored.Account)); } SDf02 sdf02New = createSuccessSdf02(sdf01, generationIdForGroup); sdf02Imdg.insert(sdf02New); statement.setOutSDfId(sdf02New.getId()); - AccountBalance accountBalance = createSuccessAccountBalance(); - accountBalanceImdg.insert(accountBalance); - //fixme possible error from accountBalanceCreation -> other status + errorCode, errorText - statement.setStatus(OperationStatus.Executed.getKey()); + AccountResult accountResult = accountBalanceService.createAccountBalance(statement.getAddresseeId(), statement.getAccountId(), statement.getAmount(), statement.getCashMovementCurrencyCode()); + if (accountResult.getError() != null) { + statement.setErrorCode(accountResult.getError().getSubject().getId().toString()); + statement.setErrorText(errorResolver.resolve(accountResult.getError())); + } else { + accountBalanceImdg.insert(accountResult.getAccount()); //insert == update? + statement.setStatus(OperationStatus.Executed.getKey()); + } statementImdg.update(statement); if (accountRequests.size() > 0) { @@ -227,20 +239,4 @@ public class StatementService extends QueueConsumer implements InitializingBean sDf02.setResult("OK!"); return sDf02; } - - private AccountBalance createSuccessAccountBalance() { - return new AccountBalance(); - } - - private static class AccountBalance extends SpcexObjectBase { - private String message = "AccountBalance"; - - public String getMessage() { - return message; - } - - public void setMessage(String message) { - this.message = message; - } - } } diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceValidation.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceValidation.java new file mode 100644 index 000000000..5bfbbe358 --- /dev/null +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceValidation.java @@ -0,0 +1,3 @@ +package ru.spcex.clearing.balance.validation; + +public record AccountBalanceValidation(Long addresseeId, Long accountId) {} diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceValidationRule.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceValidationRule.java new file mode 100644 index 000000000..5861ebd63 --- /dev/null +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceValidationRule.java @@ -0,0 +1,55 @@ +package ru.spcex.clearing.balance.validation; + +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; +import ru.spcex.clearing.balance.errors.BalanceError; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.Status; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.validation.IValidationRule; + +import java.time.format.DateTimeFormatter; +import java.util.Map; +import java.util.Optional; + +public enum AccountBalanceValidationRule implements IValidationRule> { + CompanyPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + AccountBalanceValidation validatedObject = context.getValidatedObject(); + Imdg companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class); + Company company = companyImdg.getSingleObjectByID(validatedObject.addresseeId()); + if (company == null) { + return of( BalanceError.CompanyNotFound); + } + context.storeObject(ValidationStored.Company, company); + return empty(); + } + }, + AccountOk() { + @Override + public Optional validate(ImdgValidationContext context) { + AccountBalanceValidation validatedObject = context.getValidatedObject(); + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Account account = accountImdg.getSingleObjectByFieldValues(Map.of("id", validatedObject.accountId(), + "accountType", AccountType.Clrn.getKey())); + if (account == null) { + return of(BalanceError.AccountNotPresent); + } + if (!Status.Active.equalsByKey(account.getStatus())) { + return of(BalanceError.AccountNotActive, account.getId()); + } + context.storeObject(ValidationStored.Account, account); + return empty(); + } + }; + private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy"); + + @Override + public String ruleName() { + return "Sdf01ValidationRule." + name(); + } +} diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java index 78ebb937d..855184e0e 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java @@ -3,11 +3,11 @@ package ru.spcex.clearing.balance.validation; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.sdf.SDf01; -import ru.spcex.clearing.balance.config.ImdgValidationContext; import ru.spcex.clearing.balance.errors.BalanceError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.platform.enumeration.AccountType; import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.validation.IValidationRule; @@ -26,7 +26,7 @@ public enum Sdf01ValidationRule implements IValidationRuleru.spcex.platform platform-classes-base + + ru.spcex.platform + platform-utils + \ No newline at end of file diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ImdgValidationContext.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/validation/ImdgValidationContext.java similarity index 90% rename from clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ImdgValidationContext.java rename to platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/validation/ImdgValidationContext.java index 40a5f805e..3d853cff4 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ImdgValidationContext.java +++ b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/validation/ImdgValidationContext.java @@ -1,4 +1,4 @@ -package ru.spcex.clearing.balance.config; +package ru.spcex.platform.imdg.validation; import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.imdg.api.Imdg; @@ -17,11 +17,11 @@ public class ImdgValidationContext implements IValidatorContext { this.storedObjects = new HashMap<>(); } - void addImdg(String key, Imdg imdg) { + public void addImdg(String key, Imdg imdg) { imdgs.put(key, imdg); } - void setValidatedObject(T validatedObject) { + public void setValidatedObject(T validatedObject) { this.validatedObject = validatedObject; }