Merge remote-tracking branch 'origin/dev' into dev

clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/config/AppConfig.java

@@ -10,7 +10,6 @@ import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 import ru.spcex.clearing.dflt.management.config.settings.DefaultManagementSettings;
 import ru.spcex.clearing.dflt.management.error.DefaultManagementErrors;
 import ru.spcex.clearing.util.security.UserRoleVerification;
-import ru.spcex.clearing.util.services.IMDGMessageResolver;
 import ru.spcex.platform.enumeration.UserRole;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
@@ -57,9 +56,4 @@ public class AppConfig {
     public UserRoleVerification userRoleVerification(ImdgProvider imdgProvider, IMessageResolver messageResolver) {
         return new UserRoleVerification(imdgProvider, messageResolver, UserRole.Admin, DefaultManagementErrors.UserVerifyDenial);
     }
-
-    @Bean
-    public IMessageResolver messageResolver(ImdgProvider imdgProvider) {
-        return new IMDGMessageResolver(imdgProvider);
-    }
 }

clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/TaskListener.java

@@ -16,7 +16,7 @@ import ru.spcex.clearing.dflt.management.service.SpotOvernightOrderService;
 import ru.spcex.clearing.dflt.management.service.SwapOvernightOrderService;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
-import ru.spcex.clearing.platform.messaging.domain.cud.misc.OvernightSettingsNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.platform.enumeration.OvernightType;
 import ru.spcex.platform.enumeration.Task;
@@ -48,13 +48,13 @@ public class TaskListener extends QueueConsumer implements InitializingBean {
 
     @Override
     public void afterPropertiesSet() {
-        callback(OvernightSettingsNewRequest.class)
+        callback(LauncherCommandRequest.class)
             .setConsumer(this::createOrder)
             .forDestination(Task.CROR.topic(), callbacks::put);
         init();
     }
 
-    private void createOrder(BaseRequest<OvernightSettingsNewRequest> newReq) {
+    private void createOrder(BaseRequest<LauncherCommandRequest> newReq) {
         log.info("CROR createOrder started, request={}", newReq);
 
         Collection<Long> registryIds = imdgQueryService.getCurrencyRegistry();

clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/ImdgQueryService.java

@@ -71,7 +71,7 @@ public class ImdgQueryService {
     public Optional<OvernightSettings> findOvernightSettingsByCompany(Long companyId) {
         ImdgPredicateBuilder builder = overnightSettingsImdg.predicateBuilder();
         ImdgPredicate predicate = builder.and(
-            builder.equals("market", ru.spcex.platform.enumeration.Market.curr),
+            builder.equals("market", ru.spcex.platform.enumeration.Market.curr.getKey()),
             builder.equals("companyId", companyId)
         );
         OvernightSettings overnightSettings = overnightSettingsImdg.getFirstObjectByPredicate(predicate);
@@ -89,7 +89,7 @@ public class ImdgQueryService {
     public CounterpartyInfo getCompanyByRole(CompanyRole role) {
         ImdgPredicateBuilder pb = companyRoleSetImdg.predicateBuilder();
         CompanyRoleSet roleSet = companyRoleSetImdg.getSingleObjectByPredicate(
-            pb.equals("companyRole", role)
+            pb.equals("companyRole", role.getKey())
         );
 
         Company company = companyImdg.getSingleObjectByID(roleSet.getCompanyId());
@@ -126,12 +126,12 @@ public class ImdgQueryService {
 
     public Market getSwapMarket() {
         ImdgPredicateBuilder pb = marketImdg.predicateBuilder();
-        return marketImdg.getSingleObjectByPredicate(pb.equals("marketType", MarketType.SCSW));
+        return marketImdg.getSingleObjectByPredicate(pb.equals("marketType", MarketType.SCSW.getKey()));
     }
 
     public Market getSpotMarket() {
         ImdgPredicateBuilder pb = marketImdg.predicateBuilder();
-        return marketImdg.getSingleObjectByPredicate(pb.equals("marketType", MarketType.SCSP));
+        return marketImdg.getSingleObjectByPredicate(pb.equals("marketType", MarketType.SCSP.getKey()));
     }
 
     public Listing findListing(Registry registry, String marketCode) {
@@ -164,8 +164,7 @@ public class ImdgQueryService {
         RiskParameter riskParameter = riskParameterImdg.getSingleObjectByPredicate(
             pb.and(
                 pb.equals("settlementType", "T0"),
-                pb.equals("currencyPairId", currencyPairDictionaryId),
+                pb.equals("currencyPairId", currencyPairDictionaryId)
-                pb.equals("baseCurrency", baseCurrency)
             )
         );
         return riskParameter.getQuoteValue();
@@ -256,9 +255,9 @@ public class ImdgQueryService {
         ImdgPredicateBuilder pb = registryImdg.predicateBuilder();
         return registryImdg.getSingleObjectByPredicate(
             pb.and(
-                pb.regex("registryCode", "^PM.*T"),
+                pb.regex("registryCode", "^AM.*T"),
                 pb.equals("securitySymbol", securitySymbol),
-                pb.equals("tradingClearingRegistryId", registry.getId()),
+                pb.equals("tradingClearingRegistryId", registry.getTradingClearingRegistryId()),
                 pb.equals("companyId", registry.getCompanyId())
             )
         );

clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCalculationService.java

@@ -12,21 +12,22 @@ import ru.clearing.classes.statics.data.security.Rates;
 import ru.clearing.platform.dictionary.CurrencyPairDictionary;
 import ru.spcex.clearing.dflt.management.model.CalculationResult;
 import ru.spcex.clearing.dflt.management.model.SwapContext;
+import ru.spcex.platform.enumeration.SettleCode;
 
 @Service
-public class SwapCalculationService {
+public class OrderCalculationService {
     private static final MathContext MC = new MathContext(20, RoundingMode.HALF_UP);
 
     private final ImdgQueryService imdgQueryService;
     private final TransferDateService transferDateService;
 
-    public SwapCalculationService(ImdgQueryService imdgQueryService,
+    public OrderCalculationService(ImdgQueryService imdgQueryService,
                                    TransferDateService transferDateService) {
         this.imdgQueryService = imdgQueryService;
         this.transferDateService = transferDateService;
     }
 
-    public void calcAndEnrich(OrderCurrency order,
+    public void calcAndEnrichSwap(OrderCurrency order,
                                   SwapContext context) {
         Registry registry = context.getRegistry();
         Listing listing = context.getListing();
@@ -46,6 +47,35 @@ public class SwapCalculationService {
         order.setQuantityLot(quantityLot);
     }
 
+    public void calcAndEnrichSpot(OrderCurrency order,
+                              SwapContext context) {
+        Registry registry = context.getRegistry();
+        Listing listing = context.getListing();
+
+        CurrencyPairDictionary pair = imdgQueryService.getCurrencyPairDictionaryByListing(listing);
+        BigDecimal s = imdgQueryService.defineTransferRate(pair.getId(), registry.getSecuritySymbol());
+        BigDecimal n = transferDateService.numberOfDaysOfTransfer();
+
+        CalculationResult result = isRub(registry)
+            ? calculationSwapRubSums(registry, listing.getLotSize().intValue(), s, n)
+            : calculationSwapSums(registry, listing.getLotSize().intValue(), s, n);
+
+        Rates rates = imdgQueryService.getRate(pair.getBaseCurrency(), LocalDate.now());
+        BigDecimal quantityLot;
+        BigDecimal price;
+        if (SettleCode.T0.equalsByKey(order.getSettleCode())) {
+            quantityLot = result.sum3().abs();
+            price = rates.getValue();
+        } else {
+            quantityLot = result.sum5().abs();
+            BigDecimal delta = swapPriceCalc(pair.getBaseCurrency(), s, n);
+            price = rates.getValue().add(delta);
+        }
+
+        order.setPrice(price);
+        order.setQuantityLot(quantityLot);
+    }
+
     private CalculationResult calculationSwapSums(Registry registry, Integer lotSize, BigDecimal s, BigDecimal n) {
         BigDecimal planPosition = registry.getBalance();
         BigDecimal sum1 = planPosition.abs();

clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderTemplateBuilder.java

@@ -8,56 +8,61 @@ import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.security.RiskParameter;
 import ru.spcex.clearing.dflt.management.model.CounterpartyInfo;
 import ru.spcex.clearing.dflt.management.model.SwapContext;
+import ru.spcex.platform.enumeration.SettleCode;
+import static ru.spcex.platform.enumeration.SettleCode.T0;
 import ru.spcex.platform.enumeration.Side;
 
 @Service
-public class SwapOrderTemplateBuilder {
+public class OrderTemplateBuilder {
 
-    public OrderCurrency buildPrimaryTransfer(SwapContext context) {
+    public OrderCurrency buildPrimaryTransfer(SwapContext context, SettleCode settleCode) {
         OrderCurrency orderCurrency;
         switch (context.getOrderCategory()) {
             case "PL" -> orderCurrency = buildPrimaryTransferPl(context);
             case "UK" -> orderCurrency = buildPrimaryTransferUk(context);
             default -> throw new IllegalArgumentException("Unsupported order category: " + context.getOrderCategory());
         }
-        Side side = resolvePrimaryTransferSide(context.getRegistry());
+        Side side = resolvePrimaryTransferSide(context.getRegistry(), settleCode);
-        enrichOrder(orderCurrency, context, side, "overnight");
+        enrichOrder(orderCurrency, context, side, "overnight", settleCode);
         return orderCurrency;
     }
 
-    public OrderCurrency buildCounterTransfer(SwapContext context) {
+    public OrderCurrency buildCounterTransfer(SwapContext context, SettleCode settleCode) {
         OrderCurrency orderCurrency;
         switch (context.getOrderCategory()) {
             case "PL" -> orderCurrency = buildCounterTransferPl(context);
             case "UK" -> orderCurrency = buildCounterTransferUk(context);
             default -> throw new IllegalArgumentException("Unsupported order category: " + context.getOrderCategory());
-        };
+        }
-        Side side = resolveCounterTransferSide(context.getRegistry());
+        ;
-        enrichOrder(orderCurrency, context, side, "overnight");
+        Side side = resolveCounterTransferSide(context.getRegistry(), settleCode);
+        enrichOrder(orderCurrency, context, side, "overnight", settleCode);
         return orderCurrency;
     }
 
-    public OrderCurrency buildPrimaryBalancing(SwapContext context) {
+    public OrderCurrency buildPrimaryBalancing(SwapContext context, SettleCode settleCode) {
         OrderCurrency orderCurrency;
         switch (context.getOrderCategory()) {
             case "PL" -> orderCurrency = buildPrimaryBalancingPl(context);
             case "UK" -> orderCurrency = buildPrimaryBalancingUk(context);
             default -> throw new IllegalArgumentException("Unsupported order category: " + context.getOrderCategory());
-        };
+        }
-        Side side = resolvePrimaryBalancingSide(context.getRegistry());
+        ;
-        enrichOrder(orderCurrency, context, side, "balance");
+        Side side = resolvePrimaryBalancingSide(context.getRegistry(), settleCode);
+        enrichOrder(orderCurrency, context, side, "balance", settleCode);
         return orderCurrency;
     }
 
-    public OrderCurrency buildCounterBalancing(SwapContext context) {
+    public OrderCurrency buildCounterBalancing(SwapContext context, SettleCode settleCode) {
         OrderCurrency orderCurrency;
         switch (context.getOrderCategory()) {
             case "PL" -> orderCurrency = buildCounterBalancingPl(context);
             case "UK" -> orderCurrency = buildCounterBalancingUk(context);
             default -> throw new IllegalArgumentException("Unsupported order category: " + context.getOrderCategory());
-        };
+        }
-        Side side = resolveCounterBalancingSide(context.getRegistry());
+        ;
-        enrichOrder(orderCurrency, context, side, "balance");
+        Side side = resolveCounterBalancingSide(context.getRegistry(), settleCode);
+        enrichOrder(orderCurrency, context, side, "balance", settleCode);
         return orderCurrency;
     }
 
@@ -184,7 +189,8 @@ public class SwapOrderTemplateBuilder {
     public void enrichOrder(OrderCurrency order,
                             SwapContext context,
                             Side side,
-                                    String comment) {
+                            String comment,
+                            SettleCode settleCode) {
         Registry registry = context.getRegistry();
         Listing listing = context.getListing();
         Market market = context.getMarket();
@@ -198,26 +204,30 @@ public class SwapOrderTemplateBuilder {
         order.setLotSize(listing.getLotSize());
         order.setRate(riskParameter.getQuoteValue());
         order.setSide(side.getKey());
-        order.setSettleCode("T1");
+        order.setSettleCode(settleCode.getKey());
         order.setStatus("CRET");
         order.setComment(comment);
         order.setRegistryId(registry.getId());
     }
 
-    private Side resolvePrimaryTransferSide(Registry registry) {
+    private Side resolvePrimaryTransferSide(Registry registry, SettleCode settleCode) {
-        return isRub(registry) ? Side.BUY : Side.SELL;
+        Side side = T0 == settleCode ? Side.BUY : Side.SELL;
+        return isRub(registry) ? side : side.revers();
     }
 
-    private Side resolveCounterTransferSide(Registry registry) {
+    private Side resolveCounterTransferSide(Registry registry, SettleCode settleCode) {
-        return isRub(registry) ? Side.SELL : Side.BUY;
+        Side side = T0 == settleCode ? Side.SELL : Side.BUY;
+        return isRub(registry) ? side : side.revers();
     }
 
-    private Side resolvePrimaryBalancingSide(Registry registry) {
+    private Side resolvePrimaryBalancingSide(Registry registry, SettleCode settleCode) {
-        return isRub(registry) ? Side.SELL : Side.BUY;
+        Side side = T0 == settleCode ? Side.SELL : Side.BUY;
+        return isRub(registry) ? side : side.revers();
     }
 
-    private Side resolveCounterBalancingSide(Registry registry) {
+    private Side resolveCounterBalancingSide(Registry registry, SettleCode settleCode) {
-        return isRub(registry) ? Side.BUY : Side.SELL;
+        Side side = T0 == settleCode ? Side.BUY : Side.SELL;
+        return isRub(registry) ? side : side.revers();
     }
 
     private boolean isRub(Registry registry) {

clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/SpotOvernightOrderService.java

@@ -12,6 +12,7 @@ import ru.spcex.clearing.dflt.management.model.CounterpartyInfo;
 import ru.spcex.clearing.dflt.management.model.SwapContext;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.enumeration.CompanyRole;
+import ru.spcex.platform.enumeration.SettleCode;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 
@@ -21,13 +22,13 @@ public class SpotOvernightOrderService {
 
     private final ImdgQueryService imdgQueryService;
     private final Imdg<OrderCurrency> orderCurrencyImdg;
-    private final SwapOrderTemplateBuilder templateBuilder;
+    private final OrderTemplateBuilder templateBuilder;
-    private final SwapCalculationService swapCalculationService;
+    private final OrderCalculationService swapCalculationService;
 
     public SpotOvernightOrderService(ImdgProvider imdgProvider,
                                      ImdgQueryService imdgQueryService,
-                                     SwapOrderTemplateBuilder templateBuilder,
+                                     OrderTemplateBuilder templateBuilder,
-                                     SwapCalculationService swapCalculationService) {
+                                     OrderCalculationService swapCalculationService) {
         this.imdgQueryService = imdgQueryService;
         this.orderCurrencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_OrderCurrency, OrderCurrency.class);
         this.templateBuilder = templateBuilder;
@@ -55,20 +56,35 @@ public class SpotOvernightOrderService {
             .rgcm(rgcm)
             .build();
 
-//        OrderCurrency primaryTransfer = templateBuilder.buildPrimaryTransfer(context);
+        OrderCurrency primaryTransferT0 = templateBuilder.buildPrimaryTransfer(context, SettleCode.T0);
-//        OrderCurrency counterTransfer = templateBuilder.buildCounterTransfer(context);
+        OrderCurrency counterTransferT0 = templateBuilder.buildCounterTransfer(context, SettleCode.T0);
-//        OrderCurrency primaryBalancing = templateBuilder.buildPrimaryBalancing(context);
+        OrderCurrency primaryTransferT1 = templateBuilder.buildPrimaryTransfer(context, SettleCode.T1);
-//        OrderCurrency counterBalancing = templateBuilder.buildCounterBalancing(context);
+        OrderCurrency counterTransferT1 = templateBuilder.buildCounterTransfer(context, SettleCode.T1);
-//
+
-//        swapCalculationService.calcAndEnrich(primaryTransfer, context);
+        OrderCurrency primaryBalancingT0 = templateBuilder.buildPrimaryBalancing(context, SettleCode.T0);
-//        swapCalculationService.calcAndEnrich(counterTransfer, context);
+        OrderCurrency counterBalancingT0 = templateBuilder.buildCounterBalancing(context, SettleCode.T0);
-//        swapCalculationService.calcAndEnrich(primaryBalancing, context);
+        OrderCurrency primaryBalancingT1 = templateBuilder.buildPrimaryBalancing(context, SettleCode.T1);
-//        swapCalculationService.calcAndEnrich(counterBalancing, context);
+        OrderCurrency counterBalancingT1 = templateBuilder.buildCounterBalancing(context, SettleCode.T1);
-//
+
-//        orderCurrencyImdg.insert(primaryTransfer);
+        swapCalculationService.calcAndEnrichSpot(primaryTransferT0, context);
-//        orderCurrencyImdg.insert(counterTransfer);
+        swapCalculationService.calcAndEnrichSpot(counterTransferT0, context);
-//        orderCurrencyImdg.insert(primaryBalancing);
+        swapCalculationService.calcAndEnrichSpot(primaryTransferT1, context);
-//        orderCurrencyImdg.insert(counterBalancing);
+        swapCalculationService.calcAndEnrichSpot(counterTransferT1, context);
+
+        swapCalculationService.calcAndEnrichSpot(primaryBalancingT0, context);
+        swapCalculationService.calcAndEnrichSpot(counterBalancingT0, context);
+        swapCalculationService.calcAndEnrichSpot(primaryBalancingT1, context);
+        swapCalculationService.calcAndEnrichSpot(counterBalancingT1, context);
+
+        orderCurrencyImdg.insert(primaryTransferT0);
+        orderCurrencyImdg.insert(counterTransferT0);
+        orderCurrencyImdg.insert(primaryTransferT1);
+        orderCurrencyImdg.insert(counterTransferT1);
+
+        orderCurrencyImdg.insert(primaryBalancingT0);
+        orderCurrencyImdg.insert(counterBalancingT0);
+        orderCurrencyImdg.insert(primaryBalancingT1);
+        orderCurrencyImdg.insert(counterBalancingT1);
 
         log.info("Spot orders created for registryId={}", registry.getId());
     }

clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/SwapOvernightOrderService.java

@@ -12,6 +12,7 @@ import ru.spcex.clearing.dflt.management.model.CounterpartyInfo;
 import ru.spcex.clearing.dflt.management.model.SwapContext;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.enumeration.CompanyRole;
+import ru.spcex.platform.enumeration.SettleCode;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 
@@ -21,13 +22,13 @@ public class SwapOvernightOrderService {
 
     private final ImdgQueryService imdgQueryService;
     private final Imdg<OrderCurrency> orderCurrencyImdg;
-    private final SwapOrderTemplateBuilder templateBuilder;
+    private final OrderTemplateBuilder templateBuilder;
-    private final SwapCalculationService swapCalculationService;
+    private final OrderCalculationService swapCalculationService;
 
     public SwapOvernightOrderService(ImdgProvider imdgProvider,
                                      ImdgQueryService imdgQueryService,
-                                     SwapOrderTemplateBuilder templateBuilder,
+                                     OrderTemplateBuilder templateBuilder,
-                                     SwapCalculationService swapCalculationService) {
+                                     OrderCalculationService swapCalculationService) {
         this.imdgQueryService = imdgQueryService;
         this.orderCurrencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_OrderCurrency, OrderCurrency.class);
         this.templateBuilder = templateBuilder;
@@ -55,15 +56,15 @@ public class SwapOvernightOrderService {
             .rgcm(rgcm)
             .build();
 
-        OrderCurrency primaryTransfer = templateBuilder.buildPrimaryTransfer(context);
+        OrderCurrency primaryTransfer = templateBuilder.buildPrimaryTransfer(context, SettleCode.T1);
-        OrderCurrency counterTransfer = templateBuilder.buildCounterTransfer(context);
+        OrderCurrency counterTransfer = templateBuilder.buildCounterTransfer(context, SettleCode.T1);
-        OrderCurrency primaryBalancing = templateBuilder.buildPrimaryBalancing(context);
+        OrderCurrency primaryBalancing = templateBuilder.buildPrimaryBalancing(context, SettleCode.T1);
-        OrderCurrency counterBalancing = templateBuilder.buildCounterBalancing(context);
+        OrderCurrency counterBalancing = templateBuilder.buildCounterBalancing(context, SettleCode.T1);
 
-        swapCalculationService.calcAndEnrich(primaryTransfer, context);
+        swapCalculationService.calcAndEnrichSwap(primaryTransfer, context);
-        swapCalculationService.calcAndEnrich(counterTransfer, context);
+        swapCalculationService.calcAndEnrichSwap(counterTransfer, context);
-        swapCalculationService.calcAndEnrich(primaryBalancing, context);
+        swapCalculationService.calcAndEnrichSwap(primaryBalancing, context);
-        swapCalculationService.calcAndEnrich(counterBalancing, context);
+        swapCalculationService.calcAndEnrichSwap(counterBalancing, context);
 
         orderCurrencyImdg.insert(primaryTransfer);
         orderCurrencyImdg.insert(counterTransfer);

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/config/deserializers/LocalDateTimeV2Deserializer.java

@@ -0,0 +1,22 @@
+package ru.spcex.clearing.gatewayapi.config.deserializers;
+
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class LocalDateTimeV2Deserializer extends JsonDeserializer<LocalDateTime> {
+    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss.SSS");
+
+    @Override
+    public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+        String date = p.getText();
+        if (date == null || date.trim().length() == 0) {
+            return null;
+        }
+        return LocalDateTime.parse(date, formatter);
+    }
+}

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/controller/inbound/request/security/CurrencyRate.java

@@ -6,7 +6,7 @@ import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import ru.spcex.clearing.gatewayapi.config.deserializers.LocalDateDeserializer;
-import ru.spcex.clearing.gatewayapi.config.deserializers.LocalDateTimeDeserializer;
+import ru.spcex.clearing.gatewayapi.config.deserializers.LocalDateTimeV2Deserializer;
 
 public class CurrencyRate {
 
@@ -32,11 +32,11 @@ public class CurrencyRate {
 
     private BigDecimal price;
 
-    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
+    @JsonDeserialize(using = LocalDateTimeV2Deserializer.class)
     @JsonProperty("update_date_time")
     private LocalDateTime updateDateTime;
 
-    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
+    @JsonDeserialize(using = LocalDateTimeV2Deserializer.class)
     @JsonProperty("source_date_time")
     private LocalDateTime sourceDateTime;
 

clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/listeners/RatesMessageListener.java

@@ -121,7 +121,7 @@ public class RatesMessageListener extends QueueConsumer implements InitializingB
             ImdgPredicateBuilder predicateBuilder = ratesImdg.predicateBuilder();
             Collection<Long> rateIds = ratesImdg.getCollectionIdsByPredicate(
                 predicateBuilder.and(
-                    predicateBuilder.equals("date", elem.getDate()),
+                    predicateBuilder.equals("valueDate", elem.getDate()),
                     predicateBuilder.equals("currency", elem.getBaseCurrencyLetterCode())
                 ));
             if (rateIds.isEmpty()) {