вынесены рассчет блокировок

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

@@ -0,0 +1,66 @@
+package ru.spcex.clearing.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.enumeration.RegistryUnit;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.number.BigDecimalUtil;
+
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+@Service
+public class AssetTBFProcessing {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final Imdg<Registry> registryImdg;
+    private final RegistryManager rgsMng;
+
+    public AssetTBFProcessing(ImdgProvider imdgProvider, RegistryManager rgsMng) {
+        this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        this.rgsMng = rgsMng;
+    }
+
+    public void process(Registry am_b, Registry am_t, Registry am_f, BigDecimal sum) {
+        safeWrapField(am_t::getBalance, am_t::setBalance);
+        safeWrapField(am_b::getBalance, am_b::setBalance);
+        safeWrapField(am_f::getBalance, am_f::setBalance);
+        Instant now = Instant.now();
+
+        am_b.setBalance(am_b.getBalance().subtract(sum));
+        am_f.setBalance(am_t.getBalance().subtract(am_b.getBalance()));
+        am_b.setUpdated(now);
+        am_f.setUpdated(now);
+
+        registryImdg.update(am_b);
+        registryImdg.update(am_f);
+    }
+
+    public void processByAm_b(Registry am_b, BigDecimal sum) {
+        Optional<Registry> am_f = rgsMng.findRegByUnit(am_b.getCompanyId(),
+                am_b.getAccountId(),
+                am_b.getContract(),
+                am_b,
+                RegistryUnit.F);
+        Optional<Registry> am_t = rgsMng.findRegByUnit(am_b.getCompanyId(),
+                am_b.getAccountId(),
+                am_b.getContract(),
+                am_b,
+                RegistryUnit.T);
+        if (am_f.isPresent() && am_t.isPresent()) {
+            process(am_b, am_t.get(), am_f.get(), sum);
+        }
+    }
+
+    //точно будет аналогично и с другими полями
+    private void safeWrapField(Supplier<BigDecimal> getter, Consumer<BigDecimal> setter) {
+        BigDecimal fieldValue = getter.get();
+        setter.accept(BigDecimalUtil.safeBD(fieldValue));
+    }
+}

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

@@ -99,6 +99,7 @@ public class RegistryManager {
         );
     }
 
+    //todo refactor
     public Optional<Registry> findRegByUnit(Long companyId, Long accountId, String contract, Registry registry, RegistryUnit unit) {
         RegistryTradingParams p = new RegistryTradingParams(
                 IEnumKey.getEnumByKey(RegistryDesignation.class, registry.getRegistryDesignation()),

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

@@ -11,6 +11,7 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.clearing.service.AnltSearcher;
+import ru.spcex.clearing.service.AssetTBFProcessing;
 import ru.spcex.clearing.service.RegistryManager;
 import ru.spcex.clearing.service.model.Result;
 import ru.spcex.platform.enumeration.*;
@@ -39,8 +40,9 @@ public class Sdf04Executor extends AbstractExecutor<SDf04> {
     private final IMessageResolver msgRslv;
     protected final Imdg<Session> sessionImdg;
     private RegistryManager registryManager;
+    private final AssetTBFProcessing assets;
 
-    public Sdf04Executor(ImdgProvider imdgProvider, AnltSearcher anltSearcher, IMessageResolver msgRslv, RegistryManager registryManager) {
+    public Sdf04Executor(ImdgProvider imdgProvider, AnltSearcher anltSearcher, IMessageResolver msgRslv, RegistryManager registryManager, AssetTBFProcessing assets) {
         this.imdgProvider = imdgProvider;
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
@@ -48,6 +50,7 @@ public class Sdf04Executor extends AbstractExecutor<SDf04> {
         this.anltSearcher = anltSearcher;
         this.msgRslv = msgRslv;
         this.registryManager = registryManager;
+        this.assets = assets;
     }
 
     @Override
@@ -96,7 +99,7 @@ public class Sdf04Executor extends AbstractExecutor<SDf04> {
                     registries = selectRegistryForSDF04(anltSearch.getAccount().getAccount());
                 }
             }
-            registries.forEach(registry -> unlockRegistry(registry, parseString(sdf04.getSum_deb())));
+            registries.forEach(am_b -> assets.processByAm_b(am_b, parseString(sdf04.getSum_deb())));
         }
         //todo переписать логику поиска на аналогичную по счетам(TRAN)
         Session activeSession = sessionImdg.getSingleObjectByFieldValues(Map.of("workflowStatus", Status.Active.getKey()));