D**I

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

@@ -22,18 +22,23 @@ import ru.spcex.clearing.platform.messaging.domain.cud.clearing.AssetOperationRe
 import ru.spcex.clearing.platform.messaging.domain.cud.gateway.AssetOperationApprovalRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.gateway.SingleAssetResponse;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.clearing.service.registry.DmiService;
 import ru.spcex.clearing.service.schedule.TradingTimeService;
+import ru.spcex.clearing.service.validation.Sdf06NewValidationRule;
 import ru.spcex.clearing.service.validation.ValidationStored;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgId;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.number.BigDecimalUtil;
 import ru.spcex.platform.utils.text.TextUtil;
 import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
 
 import java.math.BigDecimal;
 import java.time.Instant;
@@ -50,6 +55,8 @@ public class Sdf06Executor {
 
     private final Imdg<Statement> statementImdg;
     private final ImdgProvider imdgProvider;
+    private final Imdg<Account> accImdg;
+    private final Imdg<TradingClearingRegistry> tcrImdg;
     private final Imdg<SDf06> sdf06Imdg;
     private final Imdg<SDf07> sdf07Imdg;
     private final ImdgId idGenerator;
@@ -58,6 +65,7 @@ public class Sdf06Executor {
     private final TradingTimeService tradingTimeService;
     private final KafkaSender kafkaSender;
     private final FilenameObtainer filenameObtainer;
+    private final DmiService dmiService;
 
     private final static BigDecimal successResult = BigDecimal.ZERO;
     //ошибка проверок
@@ -77,7 +85,7 @@ public class Sdf06Executor {
     public Sdf06Executor(ImdgProvider imdgProvider,
                          IMessageResolver messageResolver,
                          @Qualifier("sdf06ValidatorNew") Function<SDf06, IValidator> sDf06Validator,
-                         TradingTimeService tradingTimeService, KafkaSender kafkaSender, FilenameObtainer filenameObtainer) {
+                         TradingTimeService tradingTimeService, KafkaSender kafkaSender, FilenameObtainer filenameObtainer, DmiService dmiService) {
         this.imdgProvider = imdgProvider;
         this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         this.tradingTimeService = tradingTimeService;
@@ -85,9 +93,12 @@ public class Sdf06Executor {
         this.messageResolver = messageResolver;
         this.sDf06Validator = sDf06Validator;
         this.kafkaSender = kafkaSender;
+        this.accImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        this.tcrImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
         this.sdf06Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf06, SDf06.class);
         this.sdf07Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf07, SDf07.class);
         this.filenameObtainer = filenameObtainer;
+        this.dmiService = dmiService;
     }
 
     public void execute(BaseRequest<StatementRequest> systemRequest) {
@@ -146,6 +157,11 @@ public class Sdf06Executor {
                 requests.add(requestFromStatement(stmt, company.getTradingCode(), tcr.getCode()));
             } else {
                 processedApproved(stmt, sDf06, now, sdf07GroupId);
+                dmiService.setProc(stmt.getAccountId(),
+                        company.getId(),
+                        tcr.getId(),
+                        CurrencyCode.RUB.getKey(),
+                        stmt.getAmount());
                 sdf07WasCreated = true;
             }
         }
@@ -240,6 +256,12 @@ public class Sdf06Executor {
             Instant updatedTime = Instant.now();
             if (gatewayMsg.isApproved()) {
                 processedApproved(stmt, sdf06, updatedTime);
+                dmiService.setProc(stmt.getAccountId(),
+                        stmt.getAddresseeId(),
+                        searchTcrOnGatewayResponse(sdf06).map(SpcexObjectBase::getId).orElse(null),
+                        CurrencyCode.RUB.getKey(),
+                        stmt.getAmount()
+                );
             } else {
                 log.trace("statement.id={}, sdf07.id={}, sdf06.id={} rejected (by gateway answer)",
                         statementId,
@@ -327,4 +349,18 @@ public class Sdf06Executor {
         req.setDirection(stmt.getInOutDirection());
         return req;
     }
+
+    private Optional<TradingClearingRegistry> searchTcrOnGatewayResponse(SDf06 sdf06) {
+        ImdgValidationContext<SDf06> ctx = new ImdgValidationContext<>();
+        ctx.addImdg(IMDGDistributedNames.Map_Account, accImdg);
+        ctx.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, tcrImdg);
+        ctx.setValidatedObject(sdf06);
+        ValidatorImpl<ImdgValidationContext<SDf06>> v = new ValidatorImpl<>(ctx,
+                Sdf06NewValidationRule.AccountPresent, Sdf06NewValidationRule.TcrPresent);
+        Optional<EnumMessage> err = v.tillFirstError();
+        if (err.isEmpty()) {
+            return Optional.ofNullable(v.getStored(ValidationStored.Sdf06Tcr));
+        }
+        return Optional.empty();
+    }
 }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/DmiService.java

@@ -31,13 +31,17 @@ public class DmiService {
         this.rgsMng = rgsMng;
     }
 
-    public void setProc(Long accountId, Long companyId, Long tcrId, String securitySymbol) {
+    public void setProc(Long accountId,
+                        Long companyId,
+                        Long tcrId,
+                        String securitySymbol,
+                        BigDecimal balance) {
         findDmi(companyId, accountId, securitySymbol).ifPresentOrElse(d__i -> {
             d__i.setRegistryStatus(RegistryStatus.PROC.getKey());
             d__i.setUpdated(Instant.now());
             log.trace("updating D**I status to {}", d__i.getRegistryStatus());
             rgsImdg.update(d__i);
-        }, () -> createDmi(companyId, tcrId, securitySymbol, BigDecimal.ZERO, "outDocument"));
+        }, () -> createDmi(companyId, tcrId, securitySymbol, balance, "outDocument"));
     }
 
 
@@ -70,16 +74,16 @@ public class DmiService {
                            BigDecimal summ,
                            String outDocument) {
         RegistryTradingParams rgsCde = RegistryTradingParams.AM_T;
-        Optional<Registry> a__t = rgsMng.findRelatedAsset(tcrId,
+        Optional<Registry> am_t = rgsMng.findRelatedAsset(tcrId,
                 companyId,
                 securitySymbol,
                 rgsCde);
-        if (a__t.isEmpty()) {
+        if (am_t.isEmpty()) {
             log.error("{} not found for tcr.id={} company.id={} security.symbol={}",
                     rgsCde, tcrId, companyId, securitySymbol);
             return;// Optional.empty();
         }
-        Registry rgsD = a__t.get().clone();
+        Registry rgsD = am_t.get().clone();
         rgsD.setRegistryDesignation(RegistryDesignation.D.getKey());
         rgsD.setRegistryUnit(RegistryUnit.I.getKey());
         rgsD.setRegistryCode(RegistryUtil.clearingCode(rgsD));