add sdf16 executor

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java

@@ -11,7 +11,7 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01Request;
-import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01RequestPart;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.AccountSdfToStatementRequestPart;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
@@ -47,12 +47,12 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         AccountSdf01Request req = userRequest.getRequestPayload();
         log.debug("AccountSdf01Request received");
         List<AccountSdfToStatementRequestPart> accountToStatement = new ArrayList<>();
-        for (AccountSdf01RequestPart accountReq : req.getAccounts()) {
+        for (AccountSdfRequestPart accountReq : req.getAccounts()) {
             Account account = new Account();
             account.setAccount(accountReq.getAccount());
             //fixme account.setCompany();
             accountMap.insert(account);
-            AccountSdfToStatementRequestPart responsePart = responsePart(accountReq.getSdf01Id());
+            AccountSdfToStatementRequestPart responsePart = responsePart(accountReq.getSdfId());
             accountToStatement.add(responsePart);
         }
         sendStatementRequestBack(req.getGroupingSdf01Id(), accountToStatement);

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java

@@ -6,6 +6,7 @@ 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.clearing.classes.statics.data.sdf.SDf16;
 import ru.spcex.clearing.balance.validation.AccountBalanceValidation;
 import ru.spcex.clearing.balance.validation.AccountBalanceValidationRule;
 import ru.spcex.clearing.balance.validation.Sdf01ValidationRule;
@@ -60,6 +61,24 @@ public class ValidationConfig {
         };
     }
 
+    @Bean("sdf16Validator")
+    public Function<SDf16, IValidator> sdf16Validator(ImdgProvider imdgProvider) {
+        return sDf16 -> {
+            ImdgValidationContext<SDf16> context = new ImdgValidationContext<>();
+            context.setValidatedObject(sDf16);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, getImdg(s));
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            return new ValidatorImpl<>(context,
+                    Sdf01ValidationRule.CompanyPresent,
+                    Sdf01ValidationRule.AccountPresent,
+                    Sdf01ValidationRule.CurrencyCode,
+                    Sdf01ValidationRule.CurrentDateOnly,
+                    Sdf01ValidationRule.Market,
+                    Sdf01ValidationRule.accountType);
+        };
+    }
+
     @Autowired
     @Bean("accountBalanceValidator")
     public Function<AccountBalanceValidation, IValidator> accountBalanceValidator(ImdgProvider imdgProvider) {

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/Result.java

@@ -1,19 +1,19 @@
 package ru.spcex.clearing.balance.service;
 
-import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01RequestPart;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class Result {
-    private List<AccountSdf01RequestPart> accountRequests = new ArrayList<>();
+    private List<AccountSdfRequestPart> accountRequests = new ArrayList<>();
     private Long generationId;
 
-    public List<AccountSdf01RequestPart> getAccountRequests() {
+    public List<AccountSdfRequestPart> getAccountRequests() {
         return accountRequests;
     }
 
-    public void setAccountRequests(List<AccountSdf01RequestPart> accountRequests) {
+    public void setAccountRequests(List<AccountSdfRequestPart> accountRequests) {
         this.accountRequests = accountRequests;
     }
 

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/Sdf01Executor.java

@@ -12,7 +12,7 @@ import ru.clearing.classes.statics.data.statement.Statement;
 import ru.spcex.clearing.balance.errors.BalanceError;
 import ru.spcex.clearing.balance.validation.ValidationStored;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01RequestPart;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
@@ -139,11 +139,11 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
         statementImdg.update(statement);
     }
 
-    private AccountSdf01RequestPart createAccountRequestPart(Long sdf01Id, String account, Long companyId) {
+    private AccountSdfRequestPart createAccountRequestPart(Long sdf01Id, String account, Long companyId) {
-        AccountSdf01RequestPart req = new AccountSdf01RequestPart();
+        AccountSdfRequestPart req = new AccountSdfRequestPart();
         req.setAccount(account);
         req.setCompanyId(companyId);
-        req.setSdf01Id(sdf01Id);
+        req.setSdfId(sdf01Id);
         return req;
     }
 

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/Sdf16Executor.java

@@ -0,0 +1,191 @@
+package ru.spcex.clearing.balance.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+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.SDf16;
+import ru.clearing.classes.statics.data.sdf.SDf17;
+import ru.clearing.classes.statics.data.statement.Statement;
+import ru.spcex.clearing.balance.errors.BalanceError;
+import ru.spcex.clearing.balance.validation.ValidationStored;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
+import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
+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.validation.IValidator;
+
+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.Function;
+
+@Service
+public class Sdf16Executor extends AbstractExecutor<SDf16> {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
+    private final Imdg<Statement> statementImdg;
+    private final Function<SDf16, IValidator> sDf16Validator;
+    private final LoggingService errorLogger;
+    private final Imdg<SDf17> sdf17Imdg;
+    private final ImdgProvider imdgProvider;
+    private final AccountBalanceService accountBalanceService;
+    private final IMessageResolver errorResolver;
+    private final Imdg<AccountBalance> accountBalanceImdg;
+
+    public Sdf16Executor(Function<SDf16, IValidator> sDf16Validator,
+                         LoggingService errorLogger,
+                         ImdgProvider imdgProvider,
+                         AccountBalanceService accountBalanceService,
+                         IMessageResolver errorResolver) {
+        this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
+        this.sdf17Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf17, SDf17.class);
+        this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);;
+        this.sDf16Validator = sDf16Validator;
+        this.errorLogger = errorLogger;
+        this.imdgProvider = imdgProvider;
+        this.accountBalanceService = accountBalanceService;
+        this.errorResolver = errorResolver;
+    }
+
+    public Result execute(Collection<SDf16> sdf, StatementRequest statementRequest){
+        Result result = new Result();
+        Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId();
+        result.setGenerationId(generationIdForGroup);
+        for (SDf16 sdfItem : sdf) {
+            IValidator validator = sDf16Validator.apply(sdfItem);
+            Optional<EnumMessage> error = validator.tillFirstError();
+            Company company = validator.getStored(ValidationStored.Company);
+            if (statementRequest.getAccountCreationResults().size() == 0
+                    && BalanceError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
+                //на данном шаге company существует -> getId ok
+                //формируем пакетный запрос на добавление account
+                //ответ придет в этот же метод, process
+                result.getAccountRequests().add(createAccountRequestPart(sdfItem.getId(), sdfItem.getAccount(), company.getId()));
+                log.info("account {} for sdf01.id={} not found - send request for creation", sdfItem.getAccount(), sdfItem.getId());
+                continue;
+            } else if (BalanceError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
+                log.error("fatal error: resumed processing after generating accounts, but no account found for sdf01.id={}", sdfItem.getId());
+            }
+            if (error.isPresent()) {
+                errorLogger.logError("sdf01.id={}", error.get(), sdfItem.getId());
+                sdf17Imdg.insert(createErrorSdfRes(sdfItem, error.get(), generationIdForGroup));
+                continue;
+            }
+            Statement statement = statementImdg.getSingleObjectByFieldValues(Map.of("account", sdfItem.getAccount()));
+            if (statement == null) {
+                statement = createFlow(sdfItem,
+                        company,
+                        validator.getStored(ValidationStored.Account));
+            } else {
+                updateFlow(statement, sdfItem,
+                        validator.getStored(ValidationStored.Account));
+            }
+            SDf17 sdfNew = createSuccessSdfRes(sdfItem, generationIdForGroup);
+            sdf17Imdg.insert(sdfNew);
+            statement.setOutSDfId(sdfNew.getId());
+            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.setOperationStatus(OperationStatus.Executed.getKey());
+            }
+            statementImdg.update(statement);
+        }
+        return result;
+    }
+
+    private Statement createFlow(SDf16 sdf, Company company, Account account) {
+        Statement statement = new Statement();
+        statement.setAddresseeId(company.getId());
+        statement.setSenderId(Sender.Prc.getId());
+        statement.setCreated(Instant.now());
+        statement.setClearingDate(LocalDate.now());
+        statement.setStatementType(StatementType.full.getKey());
+        statement.setAccountId(account.getId());
+        statement.setAccount(sdf.getAccount());
+        statement.setInOutDirection(InOutDirection.in.getKey());
+//        statement.setSettlementDate(LocalDate.parse(sdf.getDat(), datFormatter));
+//        statement.setAmount(BigDecimalUtil.parse(sdf.getRemainder()));
+        statement.setCashMovementCurrencyCode(CurrencyCode.RUB.getKey());
+        statement.setOperationStatus(OperationStatus.Pending.getKey());
+        statement.setInSDfId(sdf.getId());
+        statement.setInOutSDfType(InOutSDfType.type1.getKey());
+        statementImdg.insert(statement);
+        return statement;
+    }
+
+    private void updateFlow(Statement statement, SDf16 sdf, Account account) {
+        statement.setUpdated(Instant.now());
+        statement.setAccountId(account.getId());
+        statement.setAccount(sdf.getAccount());
+        statement.setInOutDirection(InOutDirection.in.getKey());
+//        statement.setSettlementDate(LocalDate.parse(sdf.getDat(), datFormatter));
+//        statement.setAmount(BigDecimalUtil.parse(sdf.getRemainder()));
+        statement.setCashMovementCurrencyCode(CurrencyCode.RUB.getKey());
+        statementImdg.update(statement);
+    }
+
+    private AccountSdfRequestPart createAccountRequestPart(Long sdfId, String account, Long companyId) {
+        AccountSdfRequestPart req = new AccountSdfRequestPart();
+        req.setAccount(account);
+        req.setCompanyId(companyId);
+        req.setSdfId(sdfId);
+        return req;
+    }
+
+    private SDf17 createErrorSdfRes(SDf16 sdf, EnumMessage error, Long generationIdForGroup) {
+        SDf17 errorSdf = new SDf17();
+//        errorSdf.setCurr_code(sdf.getCurr_code());
+        errorSdf.setAccount(sdf.getAccount());
+//        errorSdf.setRemainder(sdf.getRemainder());
+//        errorSdf.setDeal(sdf.getDeal());
+//        errorSdf.setAcc_code(sdf.getAcc_code());
+//        errorSdf.setDat(sdf.getDat());
+        errorSdf.setMarket(sdf.getMarket());
+//        errorSdf.setAcc_name(sdf.getAcc_name());
+//        errorSdf.setAcc_type(sdf.getAcc_type());
+//        errorSdf.setSumengage(sdf.getSumengage());
+//        errorSdf.setSumunblock(sdf.getSumunblock());
+//        errorSdf.setFile_type(sdf.getFile_type());
+//        errorSdf.setInSDf01Id(sdf.getId());
+//        String errorId = error.getSubject().getId().toString();
+//        errorSdf.setResult(errorId.substring(errorId.length() - 3));
+        errorSdf.setGenerationId(generationIdForGroup);
+        errorSdf.setGenerationTime(Instant.now());
+        return errorSdf;
+    }
+
+    private SDf17 createSuccessSdfRes(SDf16 sdf, Long generationIdForGroup) {
+        SDf17 successSdf = new SDf17();
+//        successSdf.setCurr_code(sdf.getCurr_code());
+        successSdf.setAccount(sdf.getAccount());
+//        successSdf.setRemainder(sdf.getRemainder());
+//        successSdf.setDeal(sdf.getDeal());
+//        successSdf.setAcc_code(sdf.getAcc_code());
+//        successSdf.setDat(sdf.getDat());
+        successSdf.setMarket(sdf.getMarket());
+//        successSdf.setAcc_name(sdf.getAcc_name());
+//        successSdf.setAcc_type(sdf.getAcc_type());
+//        successSdf.setSumengage(sdf.getSumengage());
+//        successSdf.setSumunblock(sdf.getSumunblock());
+//        successSdf.setFile_type(sdf.getFile_type());
+//        successSdf.setInSDf01Id(sdf.getId());
+        successSdf.setGenerationId(generationIdForGroup);
+        successSdf.setGenerationTime(Instant.now());
+//        successSdf.setResult("OK!");
+        return successSdf;
+    }
+}

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java

@@ -12,7 +12,7 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01Request;
-import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01RequestPart;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.ExportToFileRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
@@ -86,7 +86,7 @@ public class StatementService extends QueueConsumer implements InitializingBean
         }
     }
 
-    private AccountSdf01Request createAccountsRequest(Long sdf01GroupingId, List<AccountSdf01RequestPart> accountRequests) {
+    private AccountSdf01Request createAccountsRequest(Long sdf01GroupingId, List<AccountSdfRequestPart> accountRequests) {
         AccountSdf01Request r = new AccountSdf01Request();
         r.setGroupingSdf01Id(sdf01GroupingId);
         r.setAccounts(accountRequests);

platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/account/sdf01/AccountSdf01Request.java

@@ -9,13 +9,13 @@ public class AccountSdf01Request {
     private Long groupingSdf01Id;
 
     @JsonProperty("accounts")
-    List<AccountSdf01RequestPart> accounts;
+    List<AccountSdfRequestPart> accounts;
 
-    public List<AccountSdf01RequestPart> getAccounts() {
+    public List<AccountSdfRequestPart> getAccounts() {
         return accounts;
     }
 
-    public void setAccounts(List<AccountSdf01RequestPart> accounts) {
+    public void setAccounts(List<AccountSdfRequestPart> accounts) {
         this.accounts = accounts;
     }
 

platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/account/sdf01/AccountSdfRequestPart.java

@@ -2,20 +2,20 @@ package ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 
-public class AccountSdf01RequestPart {
+public class AccountSdfRequestPart {
     @JsonProperty
-    private Long sdf01Id;
+    private Long sdfId;
     @JsonProperty
     private String account;
     @JsonProperty
     private Long companyId;
 
-    public Long getSdf01Id() {
+    public Long getSdfId() {
-        return sdf01Id;
+        return sdfId;
     }
 
-    public void setSdf01Id(Long sdf01Id) {
+    public void setSdfId(Long sdfId) {
-        this.sdf01Id = sdf01Id;
+        this.sdfId = sdfId;
     }
 
     public String getAccount() {