FixedIncomeCashFlowValidationConfig

clearing-parent/clearing-utils/src/main/java/ru/spcex/clearing/validation/common/rules/FieldRequiredRule.java

@@ -29,6 +29,7 @@ public record FieldRequiredRule<R, V>(
      * @param <R> Класс проверяемого объекта
      * @param <V> Класс проверяемого значения
      */
+    @SafeVarargs
     public static <R, V> FieldRequiredRule<R, V> instance(String fieldName,
                                                           Function<R, V> getter,
                                                           IErrorEnumId errorEmptyRequiredValue,

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

@@ -65,12 +65,12 @@ public class ClearingMemberCategoryService extends QueueConsumer implements Init
     }
 
     private RequestInfoUpdate clearingMemberCategoryNew(BaseRequest<ClearingMemberCategoryNewRequest> userRequest) {
-        ClearingMemberCategoryNewRequest req = userRequest.getRequestPayload();
+        log.debug("ClearingMemberCategoryNewRequest received {}", userRequest.getId());
 
         RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, clearingMemberCategoryNewRequestValidator);
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
-        log.debug("ClearingMemberCategoryUpdateRequest received {}", userRequest.getId());
+        ClearingMemberCategoryNewRequest req = userRequest.getRequestPayload();
         ClearingMemberCategory newCategory = new ClearingMemberCategory();
         newCategory.setCompanyId(req.getCompanyId());
         newCategory.setClearingMemberCategory(req.getClearingMemberCategory());

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

@@ -2,13 +2,32 @@ package ru.spcex.clearing.securities.config;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import ru.clearing.platform.dictionary.CountryCodeDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.validation.common.ValidationHelper;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+
 
 @Configuration
 public class ValidationConfig {
 
+    @Bean("imdgForValidation")
+    public Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation(ImdgProvider imdgProvider) {
+        final Map<String, Imdg<? extends SpcexObjectBase>> imdg = new HashMap<>();
+        BiConsumer<String, Class<? extends SpcexObjectBase>> addImdg = (s, aClass) -> imdg.put(s, imdgProvider.getImdg(s, aClass));
+
+        addImdg.accept(IMDGDistributedNames.Map_FixedIncomeCashFlow, CountryCodeDictionary.class);
+
+        return imdg;
+    }
+
     @Bean("validationHelper")
     public ValidationHelper validationHelper(IMessageResolver messageResolver) {
         return new ValidationHelper(messageResolver);

clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/config/validation/FixedIncomeCashFlowValidationConfig.java

@@ -0,0 +1,64 @@
+package ru.spcex.clearing.securities.config.validation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeCashFlow;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.FixedIncomeCashFlowNewRequest;
+import ru.spcex.clearing.securities.errors.SecuritiesError;
+import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
+import ru.spcex.clearing.validation.common.rules.IsLongValueRule;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Configuration
+public class FixedIncomeCashFlowValidationConfig {
+
+    @Bean("fixedIncomeCashFlowNewRequestValidator")
+    public Function<FixedIncomeCashFlowNewRequest, IValidator> fixedIncomeCashFlowNewRequestValidator(
+            Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
+    ) {
+        return fixedIncomeCashFlowNewRequest -> {
+            ImdgValidationContext<FixedIncomeCashFlowNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(fixedIncomeCashFlowNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_ClearingMemberCategory);
+            return new ValidatorImpl<>(context,
+                    IsLongValueRule.instance("securitySymbol",
+                            FixedIncomeCashFlowNewRequest::getSecuritySymbol,
+                            SecuritiesError.RequiredFieldIsEmpty,
+                            SecuritiesError.WrongFieldValue),
+                    FieldRequiredRule.instance("securitySymbol",
+                            FixedIncomeCashFlowNewRequest::getSecuritySymbol,
+                            SecuritiesError.RequiredFieldIsEmpty,
+                            request -> {
+                                Imdg<FixedIncomeCashFlow> fixedIncomeCashFlowImdg = context.obtainMap(
+                                        IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class
+                                );
+                                Long securityId = Long.valueOf(request.getSecuritySymbol());
+                                Collection<FixedIncomeCashFlow> fixedIncomeCashFlows = fixedIncomeCashFlowImdg.getCollectionObjectsByFieldValues(Map.of("securityId", securityId));
+                                if (!fixedIncomeCashFlows.isEmpty()) return SecuritiesError.CouponPeriodAlreadyExists;
+                                return null;
+                            }),
+                    FieldRequiredRule.instance("accruedCoupon",
+                            FixedIncomeCashFlowNewRequest::getAccruedCoupon,
+                             SecuritiesError.RequiredFieldIsEmpty),
+                    FieldRequiredRule.instance("nominalValue",
+                            FixedIncomeCashFlowNewRequest::getNominalValue,
+                            SecuritiesError.RequiredFieldIsEmpty),
+                    FieldRequiredRule.instance("number",
+                            FixedIncomeCashFlowNewRequest::getNumber,
+                            SecuritiesError.RequiredFieldIsEmpty)
+            );
+        };
+    }
+
+}

clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/FixedIncomeCashFlowService.java

@@ -0,0 +1,65 @@
+package ru.spcex.clearing.securities.service.cud;
+
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeCashFlow;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.FixedIncomeCashFlowNewRequest;
+import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.validation.common.ValidationHelper;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+@Service
+public class FixedIncomeCashFlowService  extends QueueConsumer implements InitializingBean {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final Imdg<FixedIncomeCashFlow> fixedIncomeCashFlowImdg;
+    private final ImdgProvider imdgProvider;
+    private final ValidationHelper validationHelper;
+
+    public FixedIncomeCashFlowService(Consumer<String, Object> kafkaQueue,
+                                      Producer<String, Object> kafkaResponseQueue,
+                                      ImdgProvider imdgProvider,
+                                      ValidationHelper validationHelper) {
+        super(kafkaQueue, kafkaResponseQueue);
+        this.imdgProvider = imdgProvider;
+        this.validationHelper = validationHelper;
+        this.fixedIncomeCashFlowImdg = imdgProvider.getImdg(
+                IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class
+        );
+
+    }
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        log.debug("EquitySecurityNewRequest received");
+
+        init();
+    }
+
+    public RequestInfoUpdate fixedIncomeCashFlowNew(BaseRequest<FixedIncomeCashFlowNewRequest> userRequest) {
+        log.debug("FixedIncomeCashFlowNewRequest received {}", userRequest.getId());
+
+        // validation
+
+        FixedIncomeCashFlowNewRequest req = userRequest.getRequestPayload();
+        FixedIncomeCashFlow fixedIncomeCashFlow = new FixedIncomeCashFlow();
+        fixedIncomeCashFlow.setSecurityId(Long.valueOf(req.getSecuritySymbol()));
+        fixedIncomeCashFlow.setAccruedCoupon(req.getAccruedCoupon());
+        fixedIncomeCashFlow.setNominalValue(req.getNominalValue());
+        fixedIncomeCashFlow.setNumber(req.getNumber());
+        fixedIncomeCashFlow.setValueDate(req.getValueDate());
+
+        Long id = fixedIncomeCashFlowImdg.insert(fixedIncomeCashFlow);
+        log.debug("successfully processed, id {}", id);
+
+        return null;
+    }
+}
+