созданние B и F регистров по sdf08

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

@@ -31,8 +31,9 @@ import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IEnumKey;
 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 java.math.BigDecimal;
@@ -43,6 +44,8 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.function.Function;
 
+import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
+
 @Service
 public class Sdf08Executor extends AbstractExecutor<SDf08> {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -155,10 +158,28 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
                 if (reg.isPresent()) {
                     rgs = reg.get();
                     updateReg(stmt, rgs);
+                    Registry registryUnitB = findRegByUnit(company.getId(), account.getId(), stmt.getContract(), rgs, RegistryUnit.B).orElse(copyRegB(rgs));
+                    Registry registryUnitF = findRegByUnit(company.getId(), account.getId(), stmt.getContract(), rgs, RegistryUnit.F).orElse(copyRegF(rgs, null)); //передаю null т.к. отнимется ниже по коду
+                    if (registryUnitF.getId() == null) {
+                        registryImdg.insert(registryUnitF);
+                        log.debug("stmt.id={}, new AM*F.id={}", stmt.getId(), registryUnitF.getId());
+                    } else {
+                        registryImdg.update(registryUnitF);
+                        log.debug("stmt.id={}, updated AM*F.id={}", stmt.getId(), registryUnitF.getId());
+                    }
+                    //нужно сохранить registry B только если его не было
+                    if (registryUnitB.getId() == null) {
+                        registryImdg.insert(registryUnitB);
+                        log.debug("stmt.id={}, new AM*B.id={}", stmt.getId(), registryUnitB.getId());
+                    }
                     registryImdg.update(rgs);
                 } else {
                     rgs = createRegistryByStatement(stmt, company, account);
+                    Registry registryB = copyRegB(rgs);
+                    Registry registryF = copyRegF(rgs, registryB.getBalance());
                     registryImdg.insert(rgs);
+                    registryImdg.insert(registryB);
+                    registryImdg.insert(registryF);
                 }
                 //todo
                 //2. отправить notification на backend
@@ -295,8 +316,8 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
                 rgs.setSecuritySymbol(security.getSecuritySymbol());
             }
         }
-        rgs.setCheckBalance(BigDecimalUtil.safeBD(statement.getAmount()));
+        rgs.setCheckBalance(safeBD(statement.getAmount()));
-        rgs.setBalance(BigDecimalUtil.safeBD(statement.getAmount()));
+        rgs.setBalance(safeBD(statement.getAmount()));
         rgs.setDiffBalance(rgs.getBalance().subtract(rgs.getCheckBalance()));
         rgs.setBalanceDimension(BalanceDimension.MONY.getKey());
         rgs.setTradingDate(statement.getSettlementDate());
@@ -307,9 +328,53 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
         return rgs;
     }
 
+    private Registry copyRegB(Registry rgs) {
+        Registry rgsB = rgs.clone();
+        rgsB.setRegistryUnit(RegistryUnit.B.getKey());
+        rgsB.setRegistryCode(RegistryUtil.clearingCode(rgsB));
+        rgsB.setBalance(BigDecimal.ZERO);
+        rgsB.setDebit(BigDecimal.ZERO);
+        rgsB.setCredit(BigDecimal.ZERO);
+        rgsB.setDiffBalance(BigDecimal.ZERO);
+        rgsB.setCheckBalance(BigDecimal.ZERO);
+        return rgsB;
+    }
+
+    private Registry copyRegF(Registry rgs, BigDecimal rgsBBalance) {
+        Registry rgsF = rgs.clone();
+        rgsF.setRegistryUnit(RegistryUnit.F.getKey());
+        rgsF.setRegistryCode(RegistryUtil.clearingCode(rgsF));
+        rgsF.setBalance(safeBD(rgs.getBalance()).subtract(safeBD(rgsBBalance)));
+        rgsF.setCredit(BigDecimal.ZERO);
+        rgsF.setDiffBalance(BigDecimal.ZERO);
+        rgsF.setCheckBalance(BigDecimal.ZERO);
+        return rgsF;
+    }
+
+    private Optional<Registry> findRegByUnit(Long companyId, Long accountId, String contract, Registry registry, RegistryUnit unit) {
+        RegistryTradingParams p = new RegistryTradingParams(
+                IEnumKey.getEnumByKey(RegistryDesignation.class, registry.getRegistryDesignation()),
+                IEnumKey.getEnumByKey(RegistryInstrumentType.class, registry.getRegistryInstrumentType()),
+                IEnumKey.getEnumByKey(RegistryCapacity.class, registry.getRegistryCapacity()),
+                unit
+        );
+        String sql = RegistryCodeSqlBuilder.getInstance(p).build();
+        ImdgPredicateBuilder pb = registryImdg.predicateBuilder();
+        ImdgPredicate rgstrPredicate = pb.and(pb.sql(sql),
+                pb.sql(sql),
+                pb.equals("companyId", companyId), //fixme companyId?
+                pb.equals("accountId", accountId)
+
+        );
+        if (RegistryDesignation.D.equalsByKey(registry.getRegistryDesignation()) && !TextUtil.isEmpty(contract)) {
+            rgstrPredicate = pb.and(rgstrPredicate, pb.equals("contract", contract));
+        }
+        return Optional.ofNullable(registryImdg.getSingleObjectByPredicate(rgstrPredicate));
+    }
+
     private void updateReg(Statement s, Registry r) {
         r.setBalance(s.getAmount());
-        r.setCheckBalance(BigDecimalUtil.safeBD(s.getAmount()));
+        r.setCheckBalance(safeBD(s.getAmount()));
         r.setDiffBalance(r.getBalance().subtract(r.getCheckBalance()));
         r.setUpdated(Instant.now());
     }

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

@@ -52,6 +52,8 @@ import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.regex.Pattern;
 
+import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
+
 @Service
 public class Sdf57Executor extends AbstractExecutor<SDf57> {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -628,7 +630,4 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
         R apply(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    private BigDecimal safeBD(BigDecimal value) {
-        return value != null ? value : BigDecimal.ZERO;
-    }
 }