DM*I поиск по TCR#id

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

@@ -268,6 +268,7 @@ public class ValidationConfig {
                     Sdf06NewValidationRule.Fields,
                     Sdf06NewValidationRule.CompanySymbolAndCompanyPresent,
                     Sdf06NewValidationRule.AccountPresent,
+                    Sdf06NewValidationRule.CompanyAndAccountMatch,
                     Sdf06NewValidationRule.Session,
                     Sdf06NewValidationRule.Balance,
                     Sdf06NewValidationRule.TcrPresent

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

@@ -161,9 +161,7 @@ public class Sdf06Executor {
                 requests.add(GatewayRequestCreator.gatewayRequestPart(stmt, company.getTradingCode(), tcr.getCode()));
             } else {
                 processedApproved(stmt, sDf06, now, sdf07GroupId);
-                dmiService.setProc(stmt.getAccountId(),
+                dmiService.setProc(tcr.getId(),
-                        company.getId(),
-                        tcr.getId(),
                         CurrencyCode.RUB.getKey(),
                         safeBD(sDf06.getSum()),
                         sDf06.getNumber());
@@ -261,9 +259,7 @@ public class Sdf06Executor {
             Instant updatedTime = Instant.now();
             if (gatewayMsg.isApproved()) {
                 processedApproved(stmt, sdf06, updatedTime);
-                dmiService.setProc(stmt.getAccountId(),
+                dmiService.setProc(searchTcrOnGatewayResponse(sdf06).map(SpcexObjectBase::getId).orElse(null),
-                        stmt.getAddresseeId(),
-                        searchTcrOnGatewayResponse(sdf06).map(SpcexObjectBase::getId).orElse(null),
                         CurrencyCode.RUB.getKey(),
                         safeBD(sdf06.getSum()),
                         sdf06.getNumber()

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

@@ -189,7 +189,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                     statementDeb.map(SpcexObjectBase::getId).orElse(null),
                     statementCred.map(SpcexObjectBase::getId).orElse(null));
 
-            Consumer<StmtCmpAcc> createRegistryIfNeeded = stmtCmpAcc -> {
+            Function<StmtCmpAcc, Optional<Long>> createRegistryIfNeeded = stmtCmpAcc -> {
                 Statement stmt = stmtCmpAcc.statement();
                 Company company = stmtCmpAcc.company();
                 Account account = stmtCmpAcc.account();
@@ -327,18 +327,20 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                                         amtCached.get().getTradingClearingRegistry()));
 
                     }
+                    return Optional.ofNullable(amtCached.get().getTradingClearingRegistryId());
                 } else {
                     log.debug("statement.id={} activness validation failed {}", stmt.getId(), messageResolver.resolve(err.get()));
                     stmt.setErrorCodeId(err.get().getSubject().getId()); // fixme ErrorText insert
                     stmt.setOperationStatus(OperationStatus.Rejected.getKey());
                     statementImdg.update(stmt);
+                    return Optional.empty();
                 }
             };
             Consumer<StmtCmpAcc> registersUpdate = stmtCmpAcc -> {
                 Statement stmt = stmtCmpAcc.statement();
                 Company cmp = stmtCmpAcc.company();
                 Account acc = stmtCmpAcc.account();
-                createRegistryIfNeeded.accept(stmtCmpAcc);
+                Optional<Long> tcrId = createRegistryIfNeeded.apply(stmtCmpAcc);
                 if (accountIsAnlt(acc)) {
                     AnltSearcher.AnltSearch searchResult = anltSearcher.loadByAnlt(stmt.getComment());
                     if (searchResult.isFound()) {
@@ -347,11 +349,12 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                                 stmt.getComment(),
                                 searchResult.getAccount().getId(),
                                 searchResult.getCompany().getId());
-                        createRegistryIfNeeded.accept(new StmtCmpAcc(stmt, searchResult.getCompany(), searchResult.getAccount()));
+                        createRegistryIfNeeded.apply(new StmtCmpAcc(stmt, searchResult.getCompany(), searchResult.getAccount()));
-                        dmiService.setOk(searchResult.getAccount().getId(),
+                        if (OperationStatus.Executed.equalsByKey(stmt.getOperationStatus())) {
-                                searchResult.getCompany().getId(),
+                            dmiService.setOk(searchResult.getTcr().getId(),
-                                CurrencyCode.RUB.getKey(),
+                                    CurrencyCode.RUB.getKey(),
-                                sdf57.getDbfId().toString());
+                                    sdf57.getDbfId().toString());
+                        }
                     } else {
                         log.debug("stmt.id={} comment='{}' error: {}. Operating through DMAU registry",
                                 stmt.getId(),
@@ -382,11 +385,16 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                         });
                         //DMAU подразумевает увеличение остатка поля balance и credit registry.code=DMAU
                     }
-                } else {
+                } else if (OperationStatus.Executed.equalsByKey(stmt.getOperationStatus())) {
-                    dmiService.setOk(acc.getId(),
+                    if (tcrId.isPresent()) {
-                            cmp.getId(),
+                        dmiService.setOk(tcrId.get(),
-                            CurrencyCode.RUB.getKey(),
+                                CurrencyCode.RUB.getKey(),
-                            sdf57.getDbfId().toString());
+                                sdf57.getDbfId().toString());
+                    } else {
+                        log.error("stmt.id={} operationStatus={} but couldn't extract TCR.id for DM*I update",
+                                stmt.getId(),
+                                stmt.getOperationStatus());
+                    }
                 }
             };
             statementDeb.map(stmt -> new StmtCmpAcc(stmt, companyDeb, accountDeb)).ifPresent(registersUpdate);

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

@@ -31,43 +31,39 @@ public class DmiService {
         this.rgsMng = rgsMng;
     }
 
-    public void setProc(Long accountId,
+    public void setProc(Long tcrId,
-                        Long companyId,
-                        Long tcrId,
                         String securitySymbol,
                         BigDecimal balance,
                         BigDecimal contract) {
-        findDmi(companyId, accountId, securitySymbol, contract.toString()).ifPresentOrElse(d__i -> {
+        findDmi(tcrId, securitySymbol, contract.toString()).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, balance, contract.toString()));
+        }, () -> createDmi(tcrId, securitySymbol, balance, contract.toString()));
     }
 
 
-    public void setOk(Long accountId,
+    public void setOk(Long tcrId,
-                      Long companyId,
                       String securitySymbol,
                       String contract) {
-        findDmi(companyId, accountId, securitySymbol, contract).ifPresentOrElse(d__i -> {
+        findDmi(tcrId, securitySymbol, contract).ifPresentOrElse(d__i -> {
             d__i.setRegistryStatus(RegistryStatus.OK.getKey());
             d__i.setUpdated(Instant.now());
             log.trace("updating {} status to {}", d__i.getRegistryCode(), d__i.getRegistryStatus());
             rgsImdg.update(d__i);
         }, () -> {
-            log.trace("didn't find DM*I by companyId={} accountId={} securitySymbol={} contract={}",
+            log.trace("didn't find DM*I by tcr.id={} securitySymbol={} contract={}",
-                    companyId, accountId, securitySymbol, contract);
+                    tcrId, securitySymbol, contract);
         });
     }
 
-    private Optional<Registry> findDmi(Long companyId, Long accountId, String securitySymbol, String contract) {
+    private Optional<Registry> findDmi(Long tcrId, String securitySymbol, String contract) {
         ImdgPredicateBuilder pb = rgsImdg.predicateBuilder();
         RegistryTradingParams rgsCde = RegistryTradingParams.D__I;
         ImdgPredicate prdct = pb.and(
                 pb.sql(RegistryCodeSqlBuilder.getInstance(rgsCde).build()),
-                pb.equals("companyId", companyId),
+                pb.equals("tradingClearingRegistryId", tcrId),
-                pb.equals("accountId", accountId),
                 pb.equals("securitySymbol", securitySymbol),
                 pb.equals("contract", contract)
         );
@@ -76,22 +72,24 @@ public class DmiService {
         return Optional.ofNullable(d__i);
     }
 
-    private void createDmi(Long companyId,
+    private void createDmi(Long tcrId,
-                           Long tcrId,
                            String securitySymbol,
                            BigDecimal summ,
                            String outDocument) {
         RegistryTradingParams rgsCde = RegistryTradingParams.AM_T;
-        Optional<Registry> am_t = rgsMng.findRelatedAsset(tcrId,
+        ImdgPredicateBuilder pb = rgsImdg.predicateBuilder();
-                companyId,
+        ImdgPredicate prdct = pb.and(
-                securitySymbol,
+                pb.equals("tradingClearingRegistryId", tcrId),
-                rgsCde);
+                pb.equals("securitySymbol", securitySymbol),
-        if (am_t.isEmpty()) {
+                pb.sql(RegistryCodeSqlBuilder.getInstance(rgsCde).build())
-            log.error("AM*T not found for tcr.id={} company.id={} security.symbol={}",
+        );
-                    tcrId, companyId, securitySymbol);
+        Registry am_t = rgsImdg.getSingleObjectByPredicate(prdct);
-            return;// Optional.empty();
+        if (am_t == null) {
+            log.error("AM*T not found for tcr.id={} security.symbol={}",
+                    tcrId, securitySymbol);
+            return;
         }
-        Registry rgsD = am_t.get().clone();
+        Registry rgsD = am_t.clone();
         rgsD.setRegistryDesignation(RegistryDesignation.D.getKey());
         rgsD.setRegistryUnit(RegistryUnit.I.getKey());
         rgsD.setRegistryCode(RegistryUtil.clearingCode(rgsD));

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

@@ -27,6 +27,7 @@ import ru.spcex.platform.utils.validation.IValidationRule;
 import java.math.BigDecimal;
 import java.util.Collection;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
 
@@ -84,6 +85,17 @@ public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationCont
             return empty();
         }
     },
+    CompanyAndAccountMatch() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf06> context) {
+            Company company = context.getStoredObject(ValidationStored.Sdf06Company);
+            Account account = context.getStoredObject(ValidationStored.Sdf06Account);
+            if (!Objects.equals(account.getCompanyId(), company.getId())) {
+                return of(ClearingError.WrongField, "account/tradingCode");
+            }
+            return empty();
+        }
+    },
     Session() {
         @Override
         public Optional<EnumMessage> validate(ImdgValidationContext<SDf06> context) {