clearing-service SDF01 filename

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

@@ -288,7 +288,7 @@ public class StatementService extends QueueConsumer implements InitializingBean
             //todo могут ли тут реквесты бегать по кругу, если да, то у нас проблемы
             sdfGroup = statementRequest.getAccountCreationResults()
                     .stream()
-                    .filter(part -> part.getErrorCode() == null) //fixme эти случае должны попадать в ошибочный sdf02
+//                    .filter(part -> part.getErrorCode() == null) //fixme эти случае должны попадать в ошибочный sdf02
                     .map(part -> sdfImdg.getSingleObjectByID(part.getSdfId()))
                     .collect(Collectors.toList());
         }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/AbstractExecutor.java

@@ -3,21 +3,12 @@ package ru.spcex.clearing.service.executors;
 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.classes.base.interfaces.WithFileName;
 
 import java.util.Collection;
-import java.util.Objects;
 
 public abstract class AbstractExecutor<T> {
     public abstract Result execute(Collection<T> sdf, StatementRequest statementRequest);
     public abstract String exportTableName();
     public abstract boolean isNeedToSendCommand();
     public abstract void sendCommand(KafkaSender kafkaSender, Result result);
-    public static String getFileName(Collection<? extends WithFileName> sdfs) {
-        return sdfs.stream()
-                .map(WithFileName::getFileName)
-                .filter(Objects::nonNull)
-                .findFirst()
-                .orElse(null);
-    }
 }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/FilenameObtainer.java

@@ -0,0 +1,40 @@
+package ru.spcex.clearing.service.executors;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import ru.spcex.platform.classes.base.interfaces.WithFileName;
+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.util.Collection;
+import java.util.Objects;
+
+@Component
+public class FilenameObtainer {
+    private final ImdgProvider imdgProvider;
+
+    @Autowired
+    public FilenameObtainer(ImdgProvider imdgProvider) {
+        this.imdgProvider = imdgProvider;
+    }
+
+    public String getFilename(Collection<? extends WithFileName> sdfs, Imdg<? extends WithFileName> imdg, Long groupId) {
+        String nameFromSdfs = sdfs.stream()
+                .map(WithFileName::getFileName)
+                .filter(Objects::nonNull)
+                .findFirst()
+                .orElse(null);
+        if (nameFromSdfs != null) {
+            return nameFromSdfs;
+        }
+        ImdgPredicateBuilder pb = imdg.predicateBuilder();
+        ImdgPredicate prdct = pb.equals("generationId", groupId);
+        WithFileName sdf = imdg.getFirstObjectByPredicate(prdct);
+        if (sdf != null) {
+            return sdf.getFileName();
+        }
+        return null;
+    }
+}

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

@@ -15,7 +15,6 @@ import ru.clearing.classes.statics.data.sdf.SDf02;
 import ru.clearing.classes.statics.data.security.Security;
 import ru.clearing.classes.statics.data.statement.Statement;
 import ru.spcex.clearing.error.ClearingError;
-import ru.spcex.clearing.error.ClearingErrorInternal;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
@@ -61,14 +60,16 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
     private final Imdg<Security> securityImdg;
     private final Imdg<Currency> currencyImdg;
+    private final Imdg<SDf01> sdf01Imdg;
     private final Imdg<SDf02> sdf02Imdg;
     private final IMessageResolver messageResolver;
     private final KafkaSender kafkaSender;
+    private final FilenameObtainer filenameObtainer;
 
     public Sdf01Executor(@Qualifier("sdf01ValidatorNew") Function<SDf01, IValidator> sDf01Validator,
                          LoggingService errorLogger,
                          ImdgProvider imdgProvider,
-                         IMessageResolver errorResolver, IMessageResolver messageResolver, KafkaSender kafkaSender) {
+                         IMessageResolver errorResolver, IMessageResolver messageResolver, KafkaSender kafkaSender, FilenameObtainer filenameObtainer) {
         this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
@@ -79,7 +80,9 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
         this.messageResolver = messageResolver;
         this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);
+        this.sdf01Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class);
         this.kafkaSender = kafkaSender;
+        this.filenameObtainer = filenameObtainer;
     }
 
     //todo доделать контроль sdf01 и sdf57
@@ -107,7 +110,7 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
         Result result = new Result();
         Long generationIdForGroup = statementRequest.getChildGenerationId() != null ? statementRequest.getChildGenerationId() : imdgProvider.getImdgIdGenerator().nextId();
         result.setChildGenerationId(generationIdForGroup);
-        result.setFileName(getFileName(sdf));
+        result.setFileName(filenameObtainer.getFilename(sdf, sdf01Imdg, statementRequest.getGroupId()));
         log.info("SDF01 execution: sdf01 file={} number={}, groupId={}", result.getFileName(), sdf.size(), sdf.stream().findFirst().map(SDf01::getGenerationId).orElse(null));
         for (SDf01 sdf01 : sdf) {
             IValidator validator = sDf01Validator.apply(sdf01);
@@ -115,7 +118,7 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
             Company company = validator.getStored(ValidationStored.Sdf01Company);
             Account account = validator.getStored(ValidationStored.Sdf01Account);
             if (statementRequest.getAccountCreationResults().size() == 0
-                    && ClearingErrorInternal.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
+                    && ClearingError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
                 //на данном шаге company существует -> getId ok
                 //формируем пакетный запрос на добавление account
                 //ответ придет в этот же метод, process
@@ -126,7 +129,7 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
                     log.debug("account {} for sdf01.id={} not found - send request for creation", sdf01.getAccount(), sdf01.getId());
                 }
                 continue;
-            } else if (ClearingErrorInternal.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
+            } else if (ClearingError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
                 log.error("fatal error: resumed processing after generating accounts, but no account found for sdf01.id={}", sdf01.getId());
             }
             if (error.isPresent()) {
@@ -276,7 +279,11 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
         sDf02.setFile_type(sdf01.getFile_type());
         sDf02.setInSDfId(sdf01.getId());
         String errorId = error.getSubject().getId().toString();
-        sDf02.setResult(errorId.substring(errorId.length() - 3));
+        if (errorId.length() > 3) {
+            sDf02.setResult(errorId.substring(errorId.length() - 3));
+        } else {
+            sDf02.setResult(errorId);
+        }
         sDf02.setGenerationId(generationIdForGroup);
         sDf02.setGenerationTime(Instant.now());
         return sDf02;

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf06Executor.java

@@ -64,6 +64,7 @@ public class Sdf06Executor {
     private final IMessageResolver messageResolver;
     private final Function<SDf06, IValidator> sDf06Validator;
     private final KafkaSender kafkaSender;
+    private final FilenameObtainer filenameObtainer;
 
     private final static BigDecimal successResult = BigDecimal.ZERO;
     //ошибка проверок
@@ -83,7 +84,7 @@ public class Sdf06Executor {
     public Sdf06Executor(ImdgProvider imdgProvider,
                          IMessageResolver messageResolver,
                          @Qualifier("sdf06ValidatorNew") Function<SDf06, IValidator> sDf06Validator,
-                         KafkaSender kafkaSender) {
+                         KafkaSender kafkaSender, FilenameObtainer filenameObtainer) {
         this.imdgProvider = imdgProvider;
         this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
@@ -98,6 +99,7 @@ public class Sdf06Executor {
         this.kafkaSender = kafkaSender;
         this.sdf06Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf06, SDf06.class);
         this.sdf07Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf07, SDf07.class);
+        this.filenameObtainer = filenameObtainer;
     }
 
     public void createStatementAndSendGatewayCommand(BaseRequest<StatementRequest> systemRequest) {
@@ -106,7 +108,7 @@ public class Sdf06Executor {
         Collection<SDf06> sdfs = sdfImdg.getCollectionObjectsByFieldValues(Map.of(
                 "generationId", groupId
         ));
-        String fileName = AbstractExecutor.getFileName(sdfs);
+        String fileName = filenameObtainer.getFilename(sdfs, sdf06Imdg, groupId);
         log.info("start processing SDF06: groupId={} file={}", groupId, fileName);
         Instant now = Instant.now();
         Long sdf07GroupId = idGenerator.nextId();

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf01NewValidationRule.java

@@ -4,7 +4,6 @@ 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.error.ClearingError;
-import ru.spcex.clearing.error.ClearingErrorInternal;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.enumeration.AccType;
 import ru.spcex.platform.enumeration.CurrencyCode;
@@ -55,7 +54,7 @@ public enum Sdf01NewValidationRule implements IValidationRule<ImdgValidationCont
             Account acc = accountImdg.getFirstObjectBySQL("account = '" + sdf01.getAccount()
                     + "' and accountType='" + ru.spcex.platform.enumeration.AccountType.Clrn.getKey() + "'");
             if (acc == null) {
-                return of (ClearingErrorInternal.AccountNotPresent, sdf01.getAccount());
+                return of (ClearingError.AccountNotPresent, sdf01.getAccount());
             }
             context.storeObject(ValidationStored.Sdf01Account, acc);
             return empty();