SDF55/PaymentInstructionOutboundService

clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/registry/Registry.java

@@ -204,10 +204,16 @@ public class Registry extends BusinessObject implements Cloneable {
     }
 
     public BigDecimal getBalance() {
+        if (balance == null) {
+            balance = BigDecimal.ZERO;
+        }
         return balance;
     }
 
     public void setBalance(BigDecimal balance) {
+        if (balance == null) {
+            balance = BigDecimal.ZERO;
+        }
         this.balance = balance;
     }
 

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

@@ -13,6 +13,7 @@ import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
 import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
 import ru.clearing.classes.statics.data.misc.STrades;
 import ru.clearing.classes.statics.data.misc.Session;
+import ru.clearing.classes.statics.data.payment.PaymentInstruction;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.clearing.classes.statics.data.sdf.*;
@@ -23,6 +24,7 @@ import ru.clearing.platform.dictionary.InOutDirectionDictionary;
 import ru.clearing.platform.dictionary.SectionDictionary;
 import ru.spcex.clearing.error.ClearingError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.payment.PIClearingOutbondActionNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistryChangeRefundDateRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistryChangeStatusExtractRequest;
@@ -66,6 +68,9 @@ public class ValidationConfig {
     Imdg<SectionDictionary> imdgSectionDictionary;
     Imdg<Statement> imdgStatement;
     Imdg<InOutDirectionDictionary> imdgInOutDirection;
+    Imdg<SDf55> sDf55Imdg;
+    Imdg<SDf54> sDf54Imdg;
+    Imdg<PaymentInstruction> pmtImdg;
     ImdgProvider imdgProvider;
 
     public ValidationConfig(ImdgProvider imdgProvider) {
@@ -85,6 +90,9 @@ public class ValidationConfig {
         this.imdgStatement = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         this.imdgDepoAccount = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
         this.imdgInOutDirection = imdgProvider.getImdg(IMDGDistributedNames.Map_InOutDirectionDictionary, InOutDirectionDictionary.class);
+        this.sDf55Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf55, SDf55.class);
+        this.sDf54Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf54, SDf54.class);
+        this.pmtImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
         this.imdgProvider = imdgProvider;
     }
 
@@ -432,6 +440,26 @@ public class ValidationConfig {
         };
     }
 
+    @Bean
+    public Function<StatementRequest, IValidator> sdf55ExecutorValidation() {
+        return req -> {
+            ImdgValidationContext<StatementRequest> ctx = new ImdgValidationContext<>();
+            ctx.setValidatedObject(req);
+            ctx.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
+            ctx.addImdg(IMDGDistributedNames.Map_SDf55, sDf55Imdg);
+            ctx.addImdg(IMDGDistributedNames.Map_SDf54, sDf54Imdg);
+            ctx.addImdg(IMDGDistributedNames.Map_PaymentInstruction, pmtImdg);
+            ctx.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
+            return new ValidatorImpl<>(ctx,
+                    Sdf55ValidationRule.Fields,
+                    Sdf55ValidationRule.GenerationIdFound,
+                    Sdf55ValidationRule.Sdf54Present,
+                    Sdf55ValidationRule.PaymentInstructionPresent,
+                    Sdf55ValidationRule.TcrPresent,
+                    Sdf55ValidationRule.AssetsPresent);
+        };
+    }
+
     @Bean("userRoleVerification")
     public UserRoleVerification userRoleVerification(ImdgProvider imdgProvider, IMessageResolver msgs) {
         return new UserRoleVerification(imdgProvider, msgs, ClearingError.UserVerifyDenial);

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/error/RgsError.java

@@ -0,0 +1,20 @@
+package ru.spcex.clearing.error;
+
+import ru.spcex.platform.utils.enumeration.IErrorEnumId;
+
+public enum RgsError implements IErrorEnumId {
+
+    A__tNotFound(5700L)
+
+    ;
+    private final Long id;
+
+    RgsError(Long id) {
+        this.id = id;
+    }
+
+    @Override
+    public Long getId() {
+        return id;
+    }
+}

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

@@ -159,7 +159,7 @@ public class Sdf06Executor {
                     dmiService.setProc(tcr.getId(),
                             CurrencyCode.RUB.getKey(),
                             safeBD(sDf06.getSum()),
-                            sDf06.getNumber());
+                            sDf06.getNumber().toString());
                 }
                 sdf07WasCreated = true;
             }
@@ -266,7 +266,7 @@ public class Sdf06Executor {
                 dmiService.setProc(searchTcrOnGatewayResponse(sdf06).map(SpcexObjectBase::getId).orElse(null),
                         CurrencyCode.RUB.getKey(),
                         safeBD(sdf06.getSum()),
-                        sdf06.getNumber()
+                        sdf06.getNumber().toString()
                 );
             } else {
                 log.trace("statement.id={}, sdf07.id={}, sdf06.id={} rejected (by gateway answer)",

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

@@ -2,18 +2,31 @@ package ru.spcex.clearing.service.executors;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.payment.PaymentInstruction;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.clearing.classes.statics.data.sdf.SDf54;
 import ru.clearing.classes.statics.data.sdf.SDf55;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
+import ru.spcex.clearing.service.AssetTrio;
+import ru.spcex.clearing.service.registry.AssetTBFProcessing;
+import ru.spcex.clearing.service.registry.DmiService;
+import ru.spcex.clearing.service.validation.ValidationStored;
+import ru.spcex.platform.enumeration.CurrencyCode;
 import ru.spcex.platform.enumeration.TransactionStatus;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.math.BigDecimal;
 import java.time.Instant;
+import java.util.Optional;
+import java.util.function.Function;
 
 @Service
 public class Sdf55Executor {
@@ -21,35 +34,46 @@ public class Sdf55Executor {
     private final Imdg<SDf54> sDf54Imdg;
     private final Imdg<SDf55> sDf55Imdg;
     private final Imdg<PaymentInstruction> pmtImdg;
+    private final Function<StatementRequest, IValidator> validation;
+    private final IMessageResolver msgRslv;
+    private final DmiService dmiService;
+    private final AssetTBFProcessing assets;
 
-
+    public Sdf55Executor(ImdgProvider imdgProvider,
-    public Sdf55Executor(ImdgProvider imdgProvider) {
+                         @Qualifier("sdf55ExecutorValidation") Function<StatementRequest, IValidator> validation, IMessageResolver msgRslv, DmiService dmiService, AssetTBFProcessing assets) {
         this.sDf54Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf54, SDf54.class);
         this.sDf55Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf55, SDf55.class);
         this.pmtImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
+        this.validation = validation;
+        this.msgRslv = msgRslv;
+        this.dmiService = dmiService;
+        this.assets = assets;
     }
 
     public void execute(BaseRequest<StatementRequest> systemRequest) {
         StatementRequest payload = systemRequest.getRequestPayload();
         log.debug("executing {}.generationId={}", payload.getTable(), payload.getGroupId());
-        SDf55 sDf55 = sDf55Imdg.getFirstObjectBySQL("generationId = %d".formatted(payload.getGroupId()));
+        IValidator validator = validation.apply(payload);
-        if (sDf55 == null) {
+        Optional<EnumMessage> err = validator.tillFirstError();
-            log.error("sDf55 not found for generationId={}", payload.getGroupId());
+        if (err.isPresent()) {
-            return;
+            log.error(msgRslv.resolve(err.get()));
-        }
-        SDf54 sDf54 = sDf54Imdg.getFirstObjectBySQL("docnm_ref = '%s'".formatted(sDf55.getDocnm_ref()));
-        if (sDf54 == null) {
-            log.error("sDf54 not found for sDf55.id={} docnm_ref={}", sDf55.getId(), sDf55.getDocnm_ref());
-            return;
-        }
-        PaymentInstruction pmt = pmtImdg.getSingleObjectByID(sDf54.getGenerationId());
-        if (pmt == null) {
-            log.error("pmt not found for sDf54.id={} generationId={}", sDf54.getId(), sDf54.getGenerationId());
             return;
         }
+        SDf55 sDf55 = validator.getStored(ValidationStored.Sdf55ByGroupId);
+        SDf54 sDf54 = validator.getStored(ValidationStored.Sdf55Sdf54ByDocnmRef);
+        PaymentInstruction pmt = validator.getStored(ValidationStored.Sdf55PaymentInstruction);
+        TradingClearingRegistry tcr = validator.getStored(ValidationStored.Sdf55Tcr);
+        AssetTrio assetTrio = validator.getStored(ValidationStored.Sdf55Assets);
         log.debug("sdf55.id={}, found sdf54.id={}, PaymentInstruction.id={}", sDf55.getId(), sDf54.getId(), pmt.getId());
         pmt.setTransactionStatus(TransactionStatus.ok.getKey());
         pmt.setUpdated(Instant.now());
         pmtImdg.update(pmt);
+        if (tcr != null) {
+            dmiService.setOk(tcr.getId(), CurrencyCode.RUB.getKey(), sDf54.getDocnm_ref());
+            assets.process(assetTrio.a__b(),
+                    assetTrio.a__t(),
+                    assetTrio.a__f(),
+                    BigDecimal.ZERO);
+        }
     }
 }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/payment/PaymentInstructionOutboundService.java

@@ -25,6 +25,7 @@ import ru.spcex.clearing.service.AssetTrio;
 import ru.spcex.clearing.service.Sdf54Creator;
 import ru.spcex.clearing.service.builder.PaymentInstructionBuilderV2;
 import ru.spcex.clearing.service.registry.AssetTBFProcessing;
+import ru.spcex.clearing.service.registry.DmiService;
 import ru.spcex.clearing.service.registry.RegistryManager;
 import ru.spcex.clearing.service.validation.ValidationStored;
 import ru.spcex.clearing.util.security.UserRoleVerification;
@@ -37,7 +38,6 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumId;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
-import ru.spcex.platform.utils.number.BigDecimalUtil;
 import ru.spcex.platform.utils.validation.IValidator;
 
 import java.math.BigDecimal;
@@ -45,6 +45,8 @@ import java.time.Instant;
 import java.util.Optional;
 import java.util.function.Function;
 
+import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
+
 @Service
 public class PaymentInstructionOutboundService {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -64,12 +66,13 @@ public class PaymentInstructionOutboundService {
     private final Sdf54Creator sdf54Creator;
     private final KafkaSender kafkaSender;
     private final AssetTBFProcessing assetsMng;
+    private final DmiService dmiService;
 
     @Autowired
     public PaymentInstructionOutboundService(UserRoleVerification rights,
                                              IMessageResolver msgs,
                                              ImdgProvider imdgProvider,
-                                             Function<PIClearingOutbondActionNewRequest, IValidator> validation, RegistryManager rgsMng, KafkaSender kafkaSender, AssetTBFProcessing assetsMng) {
+                                             Function<PIClearingOutbondActionNewRequest, IValidator> validation, RegistryManager rgsMng, KafkaSender kafkaSender, AssetTBFProcessing assetsMng, DmiService dmiService) {
         this.imdgProvider = imdgProvider;
         this.rights = rights;
         this.msgs = msgs;
@@ -86,6 +89,7 @@ public class PaymentInstructionOutboundService {
         this.rgsMng = rgsMng;
         this.kafkaSender = kafkaSender;
         this.assetsMng = assetsMng;
+        this.dmiService = dmiService;
     }
 
     public RequestInfoUpdate sendOutBoundPayment(BaseRequest<PIClearingOutbondActionNewRequest> req) {
@@ -104,7 +108,7 @@ public class PaymentInstructionOutboundService {
         Account accDeb = validator.getStored(ValidationStored.PIOutboundAccountDeb);
         Company addressee = cmpImdg.getSingleObjectByID(payload.getAddresseeId());
         Company sender = cmpImdg.getSingleObjectByID(payload.getSenderId());
-        BigDecimal amount = BigDecimalUtil.safeBD(payload.getCreditLeg_amount());
+        BigDecimal amount = safeBD(payload.getCreditLeg_amount());
         log.debug("all checks passed, accCred.id={}, accDeb.id={}, addressee.id={}, sender.id={}, amount: {}",
                 accCred.getId(), accDeb.getId(), addressee.getId(), sender.getId(), amount);
 
@@ -153,12 +157,18 @@ public class PaymentInstructionOutboundService {
         }
         log.debug("assets found and balance is ok. am*b.id={}, am*t.id={}, am*f.id={}",
                 assets.get().a__b().getId(), assets.get().a__t().getId(), assets.get().a__f().getId());
-        assetsMng.process(assets.get().a__b(), assets.get().a__t(), assets.get().a__f(), amount.negate());
         SDf54 sDf54 = sdf54Creator.create(pmt);
         sDf54.setId(idGenerator.nextId());
         sDf54.setGenerationId(pmt.getId());
         sdf54Imdg.insert(sDf54);
         log.debug("new sdf54.id: {}", sDf54.getId());
+        if (tcr != null) {
+            dmiService.setProc(tcr.getId(),
+                    CurrencyCode.RUB.getKey(),
+                    safeBD(amount).negate(),
+                    sDf54.getDocnm_ref());
+            assetsMng.process(assets.get().a__b(), assets.get().a__t(), assets.get().a__f(), BigDecimal.ZERO);
+        }
         SdfClearingRequest exp = new SdfClearingRequest();
         exp.setGroupId(sDf54.getGenerationId());
         kafkaSender.sendRequestToQueue(Consts.SDF54_PROCESS, exp);

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

@@ -2,6 +2,7 @@ package ru.spcex.clearing.service.registry;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.company.Company;
@@ -33,11 +34,17 @@ public class AssetTBFProcessing {
     private final Imdg<Registry> rgsImdg;
     private final RegistryManager rgsMng;
 
+    @Autowired
     public AssetTBFProcessing(ImdgProvider imdgProvider, RegistryManager rgsMng) {
         this.rgsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.rgsMng = rgsMng;
     }
 
+    public AssetTBFProcessing(Imdg<Registry> rgsImdg) {
+        this.rgsImdg = rgsImdg;
+        this.rgsMng = new RegistryManager(rgsImdg);
+    }
+
     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);

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

@@ -34,7 +34,7 @@ public class DmiService {
     public void setProc(Long tcrId,
                         String securitySymbol,
                         BigDecimal balance,
-                        BigDecimal contract) {
+                        String contract) {
         findDmi(tcrId, securitySymbol, contract.toString()).ifPresentOrElse(d__i -> {
             d__i.setRegistryStatus(RegistryStatus.PROC.getKey());
             d__i.setUpdated(Instant.now());

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

@@ -0,0 +1,113 @@
+package ru.spcex.clearing.service.validation;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import ru.clearing.classes.statics.data.payment.PaymentInstruction;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.sdf.SDf54;
+import ru.clearing.classes.statics.data.sdf.SDf55;
+import ru.spcex.clearing.error.ClearingError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
+import ru.spcex.clearing.service.AssetTrio;
+import ru.spcex.clearing.service.registry.AssetTBFProcessing;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidationRule;
+
+import java.util.Optional;
+
+public enum Sdf55ValidationRule implements IValidationRule<ImdgValidationContext<StatementRequest>> {
+    Fields() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<StatementRequest> context) {
+            StatementRequest validatedObject = context.getValidatedObject();
+            if (validatedObject.getGroupId() == null) {
+                return of(ClearingError.WrongField, "groupId");
+            }
+            return empty();
+        }
+    },
+    GenerationIdFound() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<StatementRequest> context) {
+            StatementRequest validatedObject = context.getValidatedObject();
+            Long groupId = validatedObject.getGroupId();
+            Imdg<SDf55> sDf55Imdg = context.obtainMap(IMDGDistributedNames.Map_SDf55, SDf55.class);
+            SDf55 sDf55 = sDf55Imdg.getFirstObjectBySQL("generationId = %d".formatted(groupId));
+            if (sDf55 == null) {
+                return of(ClearingError.RecordNotFound, "SDf55.id=%d".formatted(groupId));
+            }
+            context.storeObject(ValidationStored.Sdf55ByGroupId, sDf55);
+            return empty();
+        }
+    },
+    Sdf54Present() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<StatementRequest> context) {
+            SDf55 sDf55 = context.getStoredObject(ValidationStored.Sdf55ByGroupId);
+            Imdg<SDf54> sDf54Imdg = context.obtainMap(IMDGDistributedNames.Map_SDf54, SDf54.class);
+            SDf54 sDf54 = sDf54Imdg.getFirstObjectBySQL("docnm_ref = '%s'".formatted(sDf55.getDocnm_ref()));
+            if (sDf54 == null) {
+                return of(ClearingError.RecordNotFound, "SDf54.docnm_ref=%s".formatted(sDf55.getDocnm_ref()));
+            }
+            context.storeObject(ValidationStored.Sdf55Sdf54ByDocnmRef, sDf54);
+            return empty();
+        }
+    },
+    PaymentInstructionPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<StatementRequest> context) {
+            SDf54 sDf54 = context.getStoredObject(ValidationStored.Sdf55Sdf54ByDocnmRef);
+            Imdg<PaymentInstruction> pmtImdg = context.obtainMap(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
+            PaymentInstruction paymentInstruction = pmtImdg.getSingleObjectByID(sDf54.getGenerationId());
+            if (paymentInstruction == null) {
+                return of(ClearingError.RecordNotFound, "PaymentInstruction.id=%d".formatted(sDf54.getGenerationId()));
+            }
+            context.storeObject(ValidationStored.Sdf55PaymentInstruction, paymentInstruction);
+            return empty();
+        }
+    },
+    TcrPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<StatementRequest> context) {
+            Imdg<TradingClearingRegistry> tcrImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+            PaymentInstruction pmt = context.getStoredObject(ValidationStored.Sdf55PaymentInstruction);
+            Long accCredId = pmt.getCreditLeg_accountId();
+            Long addresseeId = pmt.getSenderId();
+            if (accCredId == null || addresseeId == null) return empty();
+            TradingClearingRegistry tcr = tcrImdg.getFirstObjectBySQL(
+                    "moneyAccountId = '%d' and companyId = %d".formatted(accCredId, addresseeId)
+            );
+            if (tcr != null) {
+                context.storeObject(ValidationStored.Sdf55Tcr, tcr);
+            }
+            return empty();
+        }
+    },
+    AssetsPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<StatementRequest> context) {
+            Imdg<Registry> rgsImdg = context.obtainMap(IMDGDistributedNames.Map_Registry, Registry.class);
+            PaymentInstruction pmt = context.getStoredObject(ValidationStored.Sdf55PaymentInstruction);
+            Long accCredId = pmt.getCreditLeg_accountId();
+            Long addresseeId = pmt.getSenderId();
+
+            AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg);
+            Optional<AssetTrio> assetTrio = assets.searchMoneyByAccAndCompany(addresseeId, accCredId);
+            if (assetTrio.isEmpty()) {
+                return of(ClearingError.RecordNotFound, "AM*F/AM*B/AM*T");
+            }
+            context.storeObject(ValidationStored.Sdf55Assets, assetTrio.get());
+            return empty();
+        }
+    }
+    ;
+    private final static Logger log = LoggerFactory.getLogger(Sdf55ValidationRule.class);
+    @Override
+    public String ruleName() {
+        return "Sdf55ValidationRule." + name();
+    }
+}

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

@@ -26,6 +26,8 @@ public enum ValidationStored {
 
     Sdf20Account, Sdf20Company, Sdf20Tcr, Sdf20Dst, Sdf20Ast, Sdf20Security,
 
+    Sdf55ByGroupId, Sdf55Sdf54ByDocnmRef, Sdf55PaymentInstruction, Sdf55Tcr, Sdf55Assets,
+
     SecurityBySecurityCode,
 
     RegistrysByContract

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/FinalMkrSession.java

@@ -108,6 +108,7 @@ public class FinalMkrSession extends AbstractSession implements InitializingBean
         inclusionObligations.setSessionType(sessionType());
         inspectionObligationsReturn.setSessionType(sessionType());
         inspectionObligations.setSessionType(sessionType());
+        inspectionObligations.setSection(section());
         formingPaymentInstructionDeals.setSection(section());
         formingPaymentInstructionDeals.setSessionType(sessionType());
         imdgProvider.waitAvailable();

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/IntermediateMkrSession.java

@@ -102,6 +102,7 @@ public class IntermediateMkrSession extends AbstractSession implements Initializ
         );
         inclusionObligations.setSessionType(sessionType());
         inspectionObligations.setSessionType(sessionType());
+        inspectionObligations.setSection(section());
         formingPaymentInstructionDeals.setSection(section());
         imdgProvider.waitAvailable();
         initSessionIfPresent();

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/InspectionObligations.java

@@ -10,6 +10,7 @@ import org.springframework.context.annotation.Scope;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.error.ClearingError;
+import ru.spcex.clearing.error.RgsError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.service.registry.AssetTBFProcessing;
 import ru.spcex.clearing.service.registry.RegistryManager;
@@ -35,6 +36,7 @@ import java.time.Instant;
 import java.time.LocalDate;
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static ru.spcex.platform.enumeration.RegistryTradingParams.*;
 import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
@@ -98,6 +100,7 @@ public class InspectionObligations implements ISessionStage {
                 .toList();
 
         log.info("found {} ({} groups) registries by sql: {}", registriesToProcess.size(), registriesByGroupSorted.size(), sqlCondition);
+        GROUP:
         for (Map.Entry<Long, List<Registry>> entry : registriesByGroupSorted) {
             List<Registry> group = entry.getValue();
             List<Registry> obligationsInGroup = group.stream().filter(registry ->
@@ -141,6 +144,30 @@ public class InspectionObligations implements ISessionStage {
                             .ifPresent(chk -> chk.isUncovered = true);
                 }
             }
+            for (Registry rgs : group) {
+                Runnable failGroup = () -> Stream.concat(group.stream(), getRefundDateRgsIfPresent(group).stream())
+                        .forEach(registry -> {
+                            registry.setComment(msgResolver.resolve(RgsError.A__tNotFound));
+                            updateRegistryStatus(registry, RegistryStatus.FAIL);
+                        });
+                RegistryInstrumentType mOrS = IEnumKey.getEnumByKey(RegistryInstrumentType.class, rgs.getRegistryInstrumentType());
+                if (mOrS == null) {
+                    log.error("RegistryInstrumentType is null for groupId {} {}.id={}", entry.getKey(),
+                            rgs.getRegistryCode(), rgs.getId());
+                    failGroup.run();
+                    continue;
+                }
+                if (Section.MKR.equals(section) && mOrS.equals(RegistryInstrumentType.S)) {
+                    continue;
+                }
+                Optional<Registry> a__t = assets.searchByTcrCompanyAccount(rgs, A__T.type(mOrS));
+                if (a__t.isEmpty()) {
+                    log.debug("groupId {}, {}.id={} - A**T not found. settings FAIL to group",
+                            entry.getKey(), rgs.getRegistryCode(), rgs.getId());
+                    failGroup.run();
+                    continue GROUP;
+                }
+            }
             defineStatusAndUpdateRegistry(checkResults, group);
             if (checkResults.stream().noneMatch(checkResult -> checkResult.isUncovered)) {
                 Instant now = Instant.now();
@@ -152,14 +179,14 @@ public class InspectionObligations implements ISessionStage {
                         Optional<Registry> a__t = assets.searchByTcrCompanyAccount(registry, A__T.type(mOrS));
                         Optional<Registry> a__b = a__t.map(a__tFound -> assets
                                 .searchByTcrCompanyAccount(a__tFound, A__B.type(mOrS))
-                                .orElse(copyB(a__tFound)));
+                                .orElseGet(() -> copyB(a__tFound)));
                         Optional<Registry> a__f = a__t.map(a__tFound -> assets
                                 .searchByTcrCompanyAccount(a__tFound, A__F.type(mOrS))
-                                .orElse(copyF(a__tFound)));
+                                .orElseGet(() -> copyF(a__tFound)));
                         log.debug("registry {}.id={}: {}", registry.getRegistryCode(), registry.getId(),
                                 a__t.map(r -> "A**T.id=%d/A**B.id=%d/A**F.id=%d"
                                                 .formatted(a__t.get().getId(), a__b.get().getId(), a__f.get().getId()))
-                                                .orElse("not found"));
+                                                .orElse("A**T/A**B/A**F not found"));
                         if (a__t.isPresent()) {
                             BigDecimal amount = safeBD(registry.getBalance());
                             if (IEnumKey.getEnumByKey(RegistryDesignation.class, registry.getRegistryDesignation()) == RegistryDesignation.O) {
@@ -283,28 +310,32 @@ foreach( at: rgsAT)
                 }
             }
             //проверяем есть ли второй день для сделки (он не входит в пул, поэтому ищем отдельно)
-            if (registries.stream().anyMatch(rgs -> rgs.getRefundDate() != null) && !SessionType.MEDM.equals(sessionType)) {
+            getRefundDateRgsIfPresent(registries).forEach(rgs -> updateRegistryStatus(rgs, RegistryStatus.FAIL));
-                Optional<Pair<Long, LocalDate>> groupIdAndSettleDate = registries.stream()
-                        .map(rgs -> new Pair<>(rgs.getGroupId(), rgs.getSettlementDate()))
-                        .filter(pair -> pair.getFirst() != null)
-                        .filter(pair -> pair.getSecond() != null)
-                        .findFirst();
-                if (groupIdAndSettleDate.isEmpty())
-                    return;
-                ImdgPredicateBuilder pb = registryImdg.predicateBuilder();
-                Collection<Registry> refundRgs = registryImdg.getCollectionObjectsByPredicate(
-                        pb.and(
-                                pb.equals("groupId", groupIdAndSettleDate.get().getFirst()),
-                                pb.not(pb.equals("settlementDate", groupIdAndSettleDate.get().getSecond()))
-                        )
-                );
-                refundRgs.forEach(rgs -> updateRegistryStatus(rgs, RegistryStatus.FAIL));
-            }
         } else {
             registries.forEach(registry -> updateRegistryStatus(registry, RegistryStatus.OK));
         }
     }
 
+    private Collection<Registry> getRefundDateRgsIfPresent(List<Registry> registries) {
+        if (registries.stream().anyMatch(rgs -> rgs.getRefundDate() != null) && !SessionType.MEDM.equals(sessionType)) {
+            Optional<Pair<Long, LocalDate>> groupIdAndSettleDate = registries.stream()
+                    .map(rgs -> new Pair<>(rgs.getGroupId(), rgs.getSettlementDate()))
+                    .filter(pair -> pair.getFirst() != null)
+                    .filter(pair -> pair.getSecond() != null)
+                    .findFirst();
+            if (groupIdAndSettleDate.isEmpty()) {
+                return Collections.emptyList();
+            }
+            ImdgPredicateBuilder pb = registryImdg.predicateBuilder();
+            return registryImdg.getCollectionObjectsByPredicate(
+                    pb.and(
+                            pb.equals("groupId", groupIdAndSettleDate.get().getFirst()),
+                            pb.not(pb.equals("settlementDate", groupIdAndSettleDate.get().getSecond()))
+                    )
+            );
+        } else return Collections.emptyList();
+    }
+
     private void updateRegistryStatus(Registry registry, RegistryStatus registryStatus) {
         log.debug("Update registry.id: {} to {}", registry.getId(), registryStatus.getKey());
         registry.setRegistryStatus(registryStatus.getKey());

clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/config/validation/CompanyValidationConfig.java

@@ -1,5 +1,6 @@
 package ru.spcex.clearing.company.config.validation;
 
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import ru.clearing.classes.statics.data.company.Company;
@@ -41,7 +42,8 @@ public class CompanyValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary);
             addImdg.accept(IMDGDistributedNames.Map_Company);
             return new ValidatorImpl<>(context,
-                    FieldRequiredRule.instance("shortName", CompanyNewRequest::getShortName, CompanyErrors.RequiredFieldEmpty),
+                    FieldRequiredRule.instance("shortName", CompanyNewRequest::getShortName, CompanyErrors.RequiredFieldEmpty,
+                            shortName -> StringUtils.isBlank(shortName) ? CompanyErrors.RequiredFieldEmpty : null),
                     FieldRequiredRule.instance("companySymbol", CompanyNewRequest::getCompanySymbol, CompanyErrors.RequiredFieldEmpty),
                     FieldRequiredRule.instance("companySymbolValue", CompanyNewRequest::getCompanySymbolValue, CompanyErrors.RequiredFieldEmpty),
                     DictionaryPresentRule.instance("workflowStatus",
@@ -73,7 +75,8 @@ public class CompanyValidationConfig {
             return new ValidatorImpl<>(context,
                     FieldRequiredRule.instance("id", CompanyNewRequest::getId, CompanyErrors.RequiredFieldEmpty),
 
-                    FieldRequiredRule.instance("shortName", CompanyNewRequest::getShortName, CompanyErrors.RequiredFieldEmpty),
+                    FieldRequiredRule.instance("shortName", CompanyNewRequest::getShortName, CompanyErrors.RequiredFieldEmpty,
+                            shortName -> StringUtils.isBlank(shortName) ? CompanyErrors.RequiredFieldEmpty : null),
 //                    FieldRequiredRule.instance("companySymbol", CompanyNewRequest::getCompanySymbol, CompanyErrors.RequiredFieldEmpty),
 //                    FieldRequiredRule.instance("companySymbolValue", CompanyNewRequest::getCompanySymbolValue, CompanyErrors.RequiredFieldEmpty),
                     FieldRequiredRule.instance("workflowStatus", CompanyNewRequest::getWorkflowStatus, CompanyErrors.RequiredFieldEmpty),

clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/service/CompanyInfoService.java

@@ -1,5 +1,6 @@
 package ru.spcex.clearing.company.service;
 
+import org.apache.commons.lang3.StringUtils;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -87,8 +88,10 @@ public class CompanyInfoService extends QueueConsumer implements InitializingBea
                 return requestHelper.makeErrorResponse(companyInfoReq, CompanyErrors.CompanyNotFound, companyInfoReq.getId());
             }
             company.setUpdated(Instant.now());
-            company.setShortName(req.getShortName());
+            if (StringUtils.isNotEmpty(req.getShortName()))
-            company.setFullName(req.getFullName());
+                company.setShortName(req.getShortName());
+            if (StringUtils.isNotEmpty(req.getFullName()))
+                company.setFullName(req.getFullName());
             CompanyInfo companyInfo = company.getProfile();
 
             companyInfo.setCountryCode(req.getCountryCode());

clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/service/CompanyService.java

@@ -1,5 +1,6 @@
 package ru.spcex.clearing.company.service;
 
+import org.apache.commons.lang3.StringUtils;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -211,8 +212,10 @@ public class CompanyService extends QueueConsumer implements InitializingBean {
 //            }
 
             company.setUpdated(Instant.now());
-            company.setShortName(updateRequest.getShortName());
+            if (StringUtils.isNotEmpty(updateRequest.getShortName()))
-            company.setFullName(updateRequest.getFullName());
+                company.setShortName(updateRequest.getShortName());
+            if (StringUtils.isNotEmpty(updateRequest.getFullName()))
+                company.setFullName(updateRequest.getFullName());
 
             if (updateRequest.getCompanySymbol() != null || updateRequest.getCompanySymbolValue() != null) {
                 log.trace("Request field CompanySymbol, CompanySymbolValue ignore for update company request.");

clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/service/MultiCompanyService.java

@@ -206,7 +206,7 @@ public class MultiCompanyService
                 txOk = true;
             } catch (ValidationException vex) {
                 log.error("For gateway request.id={}, companyId={} error validate: {}", baseRequest.getId(), companyId, messageResolver.resolve(vex.getEnumMsg()));
-                log.debug("For companyId={} error validation: {}", companyId, ExceptionUtils.getStackTrace(vex));
+                log.trace("For companyId={} error validation: {}", companyId, ExceptionUtils.getStackTrace(vex));
             }
         }
         if (txOk) {

platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/enumeration/IMessageResolver.java

@@ -2,4 +2,7 @@ package ru.spcex.platform.utils.enumeration;
 
 public interface IMessageResolver {
     String resolve(EnumMessage errorMessage);
+    default String resolve(IEnumId subject, Object... args) {
+        return resolve(new EnumMessage(subject, args));
+    }
 }