SDF20 inDocument NONREF fix, registries copying clearing_date/trading_date/created fix

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

@@ -24,6 +24,8 @@ import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.importexport.SwtExporterRequest;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.clearing.service.model.Result;
+import ru.spcex.clearing.service.registry.AssetTBFProcessing;
+import ru.spcex.clearing.service.registry.RegistryManager;
 import ru.spcex.clearing.service.validation.ValidationStored;
 import ru.spcex.clearing.session.stage.util.RegistryUtil;
 import ru.spcex.platform.enumeration.*;
@@ -48,8 +50,6 @@ 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());
@@ -63,12 +63,13 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
     private final Imdg<DepoAccount> depoAccountImdg;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
     private final Imdg<Company> companyImdg;
+    private final AssetTBFProcessing assets;
     private final Imdg<SDf09> sdf09Imdg;
     private final IMessageResolver messageResolver;
 
     public Sdf08Executor(@Qualifier("sdf08ValidatorNew") Function<SDf08, IValidator> sDf08Validator,
                          ImdgProvider imdgProvider,
-                         IMessageResolver messageResolver) {
+                         AssetTBFProcessing assets, IMessageResolver messageResolver) {
         this.imdgProvider = imdgProvider;
         this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
@@ -79,6 +80,7 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.sdf09Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf09, SDf09.class);
         this.sDf08Validator = sDf08Validator;
+        this.assets = assets;
         this.messageResolver = messageResolver;
     }
 
@@ -169,27 +171,23 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
                         rgs = reg.get();
                         updateReg(stmt, rgs);
                         Registry registryUnitB = findRegByUnit(company.getId(), account.getId(), stmt.getSecurityId(), stmt.getContract(), rgs, RegistryUnit.B).orElse(copyRegB(rgs));
-                        Registry registryUnitF = findRegByUnit(company.getId(), account.getId(), stmt.getSecurityId(), stmt.getContract(), rgs, RegistryUnit.F).orElse(copyRegF(rgs, null)); //передаю null т.к. отнимется ниже по коду
+                        Registry registryUnitF = findRegByUnit(company.getId(), account.getId(), stmt.getSecurityId(), stmt.getContract(), rgs, RegistryUnit.F).orElse(copyRegF(rgs)); //передаю null т.к. отнимется ниже по коду
-                        registryUnitF.setBalance(rgs.getBalance().subtract(registryUnitB.getBalance()));
-                        registryUnitF.setUpdated(Instant.now());
                         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());
                         }
+                        assets.process(registryUnitB, rgs, registryUnitF, BigDecimal.ZERO);
                         registryImdg.update(rgs);
                     } else {
                         rgs = createRegistryByStatement(stmt, company, account);
                         calcBalance(rgs, stmt);
                         Registry registryB = copyRegB(rgs);
-                        Registry registryF = copyRegF(rgs, registryB.getBalance());
+                        Registry registryF = copyRegF(rgs);
                         registryImdg.insert(rgs);
                         registryImdg.insert(registryB);
                         registryImdg.insert(registryF);
@@ -361,22 +359,15 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
         Registry rgsB = rgs.clone();
         rgsB.setRegistryUnit(RegistryUnit.B.getKey());
         rgsB.setRegistryCode(RegistryUtil.clearingCode(rgsB));
-        rgsB.setBalance(BigDecimal.ZERO);
+        RegistryManager.zeroState(rgsB);
-        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) {
+    private Registry copyRegF(Registry rgs) {
         Registry rgsF = rgs.clone();
         rgsF.setRegistryUnit(RegistryUnit.F.getKey());
         rgsF.setRegistryCode(RegistryUtil.clearingCode(rgsF));
-        rgsF.setBalance(safeBD(rgs.getBalance()).subtract(safeBD(rgsBBalance)));
+        RegistryManager.zeroState(rgsF);
-        rgsF.setCredit(BigDecimal.ZERO);
-        rgsF.setDiffBalance(BigDecimal.ZERO);
-        rgsF.setCheckBalance(BigDecimal.ZERO);
         return rgsF;
     }
 

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

@@ -16,6 +16,8 @@ import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.text.TextUtil;
 
 import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
 import java.util.Optional;
 
 import static ru.spcex.platform.enumeration.RegistryTradingParams.DM_T;
@@ -178,12 +180,18 @@ public class RegistryManager {
     }
 
     public static void zeroState(Registry rgs) {
+        //балансы
         rgs.setBalance(BigDecimal.ZERO);
         rgs.setDebit(BigDecimal.ZERO);
         rgs.setCredit(BigDecimal.ZERO);
         rgs.setDiffBalance(BigDecimal.ZERO);
         rgs.setCheckBalance(BigDecimal.ZERO);
         rgs.setPlanBalance(BigDecimal.ZERO);
+        //даты
+        rgs.setCreated(Instant.now());
+        LocalDate now = LocalDate.now();
+        rgs.setClearingDate(now);
+        rgs.setTradingDate(now);
     }
 
 

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

@@ -13,6 +13,7 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.service.AssetTrio;
 import ru.spcex.clearing.service.registry.RegistryManager;
 import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.NoRef;
 import ru.spcex.platform.enumeration.OperationCode;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
@@ -137,6 +138,9 @@ public enum Sdf20ValidationRule implements IValidationRule<ImdgValidationContext
             if (TextUtil.isEmpty(transactionNumber) || TextUtil.isEmpty(security) || acc == null) {
                 return of(ClearingError.RecordNotFound, "DS*I");
             }
+            if (NoRef.NONREF.equalsByKey(sDf20.getInDocument())) {
+                return empty();
+            }
             Imdg<Registry> rgsImdg = context.obtainMap(IMDGDistributedNames.Map_Registry, Registry.class);
             ImdgPredicateBuilder pb = rgsImdg.predicateBuilder();
             ImdgPredicate dstPrdct = pb.and(

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/executors/Sdf08ExecutorTest.java

@@ -5,14 +5,15 @@ import org.mockito.Mockito;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.SimpleMessageResolver;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 class Sdf08ExecutorTest {
 
     @Test
     void parseAccountType() {
         ImdgProvider imdgP = Mockito.mock(ImdgProvider.class);
-        Sdf08Executor sdf08Executor = new Sdf08Executor(null, imdgP, new SimpleMessageResolver());
+        Sdf08Executor sdf08Executor = new Sdf08Executor(null, imdgP, null, new SimpleMessageResolver());
 
         assertNull(sdf08Executor.parseAccountType(null));
         assertNull(sdf08Executor.parseAccountType("."));

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/NoRef.java

@@ -0,0 +1,19 @@
+package ru.spcex.platform.enumeration;
+
+import ru.spcex.platform.utils.enumeration.IEnumKey;
+
+public enum NoRef implements IEnumKey {
+    NONREF("NONREF")
+    ;
+
+    private final String key;
+
+    NoRef(String key) {
+        this.key = key;
+    }
+
+    @Override
+    public String getKey() {
+        return key;
+    }
+}