http://jira.mfd.msk:8088/browse/CLS-612 currencyPairSecurityService

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java

@@ -48,6 +48,9 @@ public class SecurityController {
         all.addAll(stateLoader.getAllMetaTransformSpecificClass(
                 IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class
         ));
+        all.addAll(stateLoader.getAllMetaTransformSpecificClass(
+                IMDGDistributedNames.Map_CurrencyPairSecurity, EquitySecurity.class
+        ));
         CommonGetAllResponse response = new CommonGetAllResponse();
         response.fromEntity(all);
         return response;

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

@@ -29,6 +29,7 @@ import ru.clearing.classes.statics.data.sdf.SDf21;
 import ru.clearing.classes.statics.data.sdf.SDf54;
 import ru.clearing.classes.statics.data.sdf.SDf55;
 import ru.clearing.classes.statics.data.sdf.SDf57;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
 import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
 import ru.clearing.classes.statics.data.security.Security;
 import ru.clearing.classes.statics.data.statement.Statement;
@@ -88,6 +89,7 @@ public class ValidationConfig {
     Imdg<Company> imdgCompany;
     Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
     Imdg<EquitySecurity> equitySecurityImdg;
+    Imdg<CurrencyPairSecurity> currencyPairSecurityImdg;
 
     Imdg<CompanySymbols> imdgCompanySymbols;
     Imdg<Registry> imdgRegistry;
@@ -130,6 +132,7 @@ public class ValidationConfig {
         this.sDf54Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf54, SDf54.class);
         this.pmtImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
         this.ctgrImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class);
+        this.currencyPairSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class);
         this.imdgProvider = imdgProvider;
     }
 
@@ -170,6 +173,7 @@ public class ValidationConfig {
             context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeSecurityImdg);
             context.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, imdgMoneyMarketSecurity);
             context.addImdg(IMDGDistributedNames.Map_EquitySecurity, equitySecurityImdg);
+            context.addImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, currencyPairSecurityImdg);
             context.setLogPrefix(LogPrefixId.INSTANCE);
             return new ValidatorImpl<>(context,
                     STradesValidationRule.SecurityPresentFond,
@@ -261,6 +265,7 @@ public class ValidationConfig {
             context.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, imdgMoneyMarketSecurity);
             context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeSecurityImdg);
             context.addImdg(IMDGDistributedNames.Map_EquitySecurity, equitySecurityImdg);
+            context.addImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, currencyPairSecurityImdg);
             context.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
             context.addImdg(IMDGDistributedNames.Map_SDf20, imdgSdf20);
             context.setLogPrefix(LogPrefixId.INSTANCE);
@@ -344,6 +349,7 @@ public class ValidationConfig {
             context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity , fixedIncomeSecurityImdg);
             context.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity , imdgMoneyMarketSecurity);
             context.addImdg(IMDGDistributedNames.Map_EquitySecurity , equitySecurityImdg);
+            context.addImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, currencyPairSecurityImdg);
             context.addImdg(IMDGDistributedNames.Map_CompanySymbols, imdgCompanySymbols);
             context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
             context.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
@@ -498,6 +504,7 @@ public class ValidationConfig {
             ctx.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity , fixedIncomeSecurityImdg);
             ctx.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity , imdgMoneyMarketSecurity);
             ctx.addImdg(IMDGDistributedNames.Map_EquitySecurity , equitySecurityImdg);
+            ctx.addImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, currencyPairSecurityImdg);
             return new ValidatorImpl<>(ctx,
                     Sdf20ValidationRule.Fields,
                     Sdf20ValidationRule.AccountPresent,

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistryBuilder.java

@@ -8,6 +8,7 @@ import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
 import ru.clearing.classes.statics.data.misc.Currency;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
 import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
 import ru.clearing.classes.statics.data.security.Security;
 import ru.clearing.classes.statics.data.statement.Statement;
@@ -37,6 +38,7 @@ public class RegistryBuilder {
     private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
     private final Imdg<MoneyMarketSecurity> moneyMarketSecurityImdg;
     private final Imdg<EquitySecurity> equitySecurityImdg;
+    private final Imdg<CurrencyPairSecurity> currencyPairSecurityImdg;
     private final Imdg<Currency> currencyImdg;
 
 
@@ -52,6 +54,7 @@ public class RegistryBuilder {
         this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
         this.moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
         this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
+        this.currencyPairSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class);
         this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
     }
 
@@ -138,12 +141,15 @@ public class RegistryBuilder {
     }
 
     private String obtainSecuritySymbol(Long securityId) {
+        // похожий код есть в SecuritySelector
         Security security = fixedIncomeSecurityImdg.getSingleObjectByID(securityId);
         if (security != null) return security.getSecuritySymbol();
         security = moneyMarketSecurityImdg.getSingleObjectByID(securityId);
         if (security != null) return security.getSecuritySymbol();
         security = equitySecurityImdg.getSingleObjectByID(securityId);
         if (security != null) return security.getSecuritySymbol();
+        security = currencyPairSecurityImdg.getSingleObjectByID(securityId);
+        if (security != null) return security.getSecuritySymbol();
         Currency currency = currencyImdg.getSingleObjectByID(securityId);
         if (currency != null) return currency.getCurrencyCode();
         return null;

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java

@@ -8,6 +8,7 @@ import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
 import ru.clearing.classes.statics.data.misc.Currency;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
 import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
 import ru.clearing.classes.statics.data.security.Security;
 import ru.clearing.classes.statics.data.statement.Statement;
@@ -37,6 +38,7 @@ public class RegistrySecurityBuilder {
     private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
     private final Imdg<MoneyMarketSecurity> moneyMarketSecurityImdg;
     private final Imdg<EquitySecurity> equitySecurityImdg;
+    private final Imdg<CurrencyPairSecurity> currencyPairSecurityImdg;
     private final Imdg<Currency> currencyImdg;
 
 
@@ -52,6 +54,7 @@ public class RegistrySecurityBuilder {
         this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
         this.moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
         this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
+        this.currencyPairSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class);
         this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
     }
 
@@ -138,12 +141,15 @@ public class RegistrySecurityBuilder {
     }
 
     private String obtainSecuritySymbol(Long securityId) {
+        // похожий код есть в SecuritySelector
         Security security = fixedIncomeSecurityImdg.getSingleObjectByID(securityId);
         if (security != null) return security.getSecuritySymbol();
         security = moneyMarketSecurityImdg.getSingleObjectByID(securityId);
         if (security != null) return security.getSecuritySymbol();
         security = equitySecurityImdg.getSingleObjectByID(securityId);
         if (security != null) return security.getSecuritySymbol();
+        security = currencyPairSecurityImdg.getSingleObjectByID(securityId);
+        if (security != null) return security.getSecuritySymbol();
         Currency currency = currencyImdg.getSingleObjectByID(securityId);
         if (currency != null) return currency.getCurrencyCode();
         return null;

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

@@ -33,7 +33,8 @@ public enum STradesValidationRule implements IValidationRule<ImdgValidationConte
             SecuritySelector<Security> slctr = new SecuritySelector<>(
                     context.obtainMap(IMDGDistributedNames.Map_FixedIncomeSecurity, Security.class),
                     context.obtainMap(IMDGDistributedNames.Map_MoneyMarketSecurity, Security.class),
-                    context.obtainMap(IMDGDistributedNames.Map_EquitySecurity, Security.class)
+                    context.obtainMap(IMDGDistributedNames.Map_EquitySecurity, Security.class),
+                    context.obtainMap(IMDGDistributedNames.Map_CurrencyPairSecurity, Security.class)
             );
             Security security = slctr.selectSecurityBySymbol(validatedObject.getSecCode().trim());
             if (security == null) {

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

@@ -7,6 +7,7 @@ import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.clearing.classes.statics.data.sdf.SDf20;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
 import ru.clearing.classes.statics.data.security.Security;
 import ru.spcex.clearing.error.ClearingError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
@@ -107,7 +108,8 @@ public enum Sdf20ValidationRule implements IValidationRule<ImdgValidationContext
             SecuritySelector<Security> slctr = new SecuritySelector<>(
                     context.obtainMap(IMDGDistributedNames.Map_FixedIncomeSecurity, Security.class),
                     context.obtainMap(IMDGDistributedNames.Map_MoneyMarketSecurity, Security.class),
-                    context.obtainMap(IMDGDistributedNames.Map_EquitySecurity, Security.class)
+                    context.obtainMap(IMDGDistributedNames.Map_EquitySecurity, Security.class),
+                    context.obtainMap(IMDGDistributedNames.Map_CurrencyPairSecurity, Security.class)
             );
             Security securityFound = slctr.selectSecurityBySymbol(security);
             if (securityFound == null) {

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

@@ -36,7 +36,8 @@ public class SecurityBySecurityCodeValidationRule<T> implements IValidationRule<
         SecuritySelector<Security> secSel = new SecuritySelector<>(
                 context.obtainMap(IMDGDistributedNames.Map_FixedIncomeSecurity, Security.class),
                 context.obtainMap(IMDGDistributedNames.Map_MoneyMarketSecurity, Security.class),
-                context.obtainMap(IMDGDistributedNames.Map_EquitySecurity, Security.class)
+                context.obtainMap(IMDGDistributedNames.Map_EquitySecurity, Security.class),
+                context.obtainMap(IMDGDistributedNames.Map_CurrencyPairSecurity, Security.class)
         );
         Security security = secSel.selectSecurityBySymbol(securitySymbol);
         if (security == null) {

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/SecurityService.java

@@ -7,10 +7,12 @@ import ru.spcex.clearing.gatewayapi.controller.inbound.request.WithSecurityId;
 import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.*;
 import ru.spcex.clearing.gatewayapi.service.adapter.SecurityRequestAdapter;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.company.CurrencyPairSecurityGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.company.EquitySecurityGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.company.FixedIncomeGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.company.SecurityFondGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.*;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.platform.enumeration.InstrumentType;
 import ru.spcex.platform.utils.log.ExceptionUtils;
@@ -68,13 +70,22 @@ public class SecurityService {
                     fillRequest(securityGatewayRequest, security, listingRequests, couponPeriodRequests, cashFlowRequests);
                     log.debug("Send request to DESTINATION_SECURITY_BOND_GATEWAY");
                     kafkaSender.sendRequestToQueue(Consts.DESTINATION_SECURITY_BOND_GATEWAY, securityGatewayRequest);
-                } else {
+                } else if (InstrumentType.EQTY.equalsByKey(security.getInstrumentType())) {
                     EquitySecurityNewRequest equitySecurityNewRequest = securityRequestAdapter.toEquitySecurityNewRequest(security);
                     securityGatewayRequest = new EquitySecurityGatewayRequest(equitySecurityNewRequest);
                     fillRequest(securityGatewayRequest, security, listingRequests, couponPeriodRequests, cashFlowRequests);
                     log.debug("Send request to DESTINATION_SECURITY_BOND_GATEWAY");
                     kafkaSender.sendRequestToQueue(Consts.DESTINATION_SECURITY_EQTY_GATEWAY, securityGatewayRequest);
+//                } else if (InstrumentType.CRNC.equalsByKey(security.getInstrumentType())) { // todo будет отдельная задача
+//                    CurrencyPairSecurityNewRequest currencyPairSecurityNewRequest = securityRequestAdapter.toCurrencyPairSecurityNewRequest(security);
+//                    securityGatewayRequest = new CurrencyPairSecurityGatewayRequest(currencyPairSecurityNewRequest);
+//                    fillRequest(securityGatewayRequest, security, listingRequests, couponPeriodRequests, cashFlowRequests);
+//                    log.debug("Send request to DESTINATION_SECURITY_BOND_GATEWAY");
+//                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_SECURITY_CURRENCY_GATEWAY, securityGatewayRequest);
+                } else {
+                    log.error("Unknown instrumentType={}", security.getInstrumentType());
                 }
+
             } catch (Throwable e) {
                 log.error("{}", ExceptionUtils.getStackTrace(e));
             }

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/SecurityRequestAdapter.java

@@ -6,6 +6,7 @@ import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.Fond
 import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.IncomeListing;
 import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.Nominal;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.*;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest;
 import ru.spcex.platform.utils.text.TextUtil;
 
 @Service
@@ -46,6 +47,25 @@ public class SecurityRequestAdapter {
         return equitySecurityNewRequest;
     }
 
+    public CurrencyPairSecurityNewRequest toCurrencyPairSecurityNewRequest(FondSecurity fondSecurity) {
+//        CurrencyPairSecurityNewRequest currencyPairSecurityNewRequest = new CurrencyPairSecurityNewRequest();
+//        currencyPairSecurityNewRequest.setInstrumentType(fondSecurity.getInstrumentType());
+//        currencyPairSecurityNewRequest.setSecuritySymbol(fondSecurity.getSecuritySymbol());
+//        currencyPairSecurityNewRequest.setShortName(fondSecurity.getShortName());
+//        currencyPairSecurityNewRequest.setFullName(fondSecurity.getFullName());
+//        currencyPairSecurityNewRequest.setMarket(fondSecurity.getMarket());
+//        currencyPairSecurityNewRequest.setCurrencyPairId(fondSecurity.getCurrencyPairId());
+//        currencyPairSecurityNewRequest.setLotSize(fondSecurity.getLotSize());
+//        currencyPairSecurityNewRequest.setMinStep(fondSecurity.getMinStep());
+//        currencyPairSecurityNewRequest.setBaseUnitSize(fondSecurity.getBaseUnitSize());
+//        currencyPairSecurityNewRequest.setSettlementType(fondSecurity.getSettlementType());
+//        currencyPairSecurityNewRequest.setWorkflowStatus(fondSecurity.getWorkflowStatus());
+//        currencyPairSecurityNewRequest.setSettlementOrganization(fondSecurity.getSettlementOrganization());
+//        currencyPairSecurityNewRequest.setClearingOrganization(fondSecurity.getClearingOrganization());
+//        return currencyPairSecurityNewRequest;
+        throw new IllegalStateException("TODO currency pair");
+    }
+
     public ListingNewRequest toIncomeListing(IncomeListing incomeListing) {
         ListingNewRequest listingNewRequest = new ListingNewRequest();
         String code = incomeListing.getCode();
@@ -56,6 +76,7 @@ public class SecurityRequestAdapter {
         listingNewRequest.setSymbolCode(incomeListing.getSymbolCode());
         listingNewRequest.setSymbolName(incomeListing.getSymbolName());
         listingNewRequest.setLotSize(incomeListing.getLotSize());
+//        listingNewRequest.setMinStep(incomeListing.getMinStep());
         listingNewRequest.setTradingCurrency(incomeListing.getTradingCurrency());
         listingNewRequest.setWorkflowStatus(incomeListing.getWorkflowStatus());
         return listingNewRequest;

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

@@ -0,0 +1,201 @@
+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.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityUpdateRequest;
+import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.securities.validation.ValidationProvider;
+import ru.spcex.clearing.util.security.UserRoleVerification;
+import ru.spcex.clearing.util.services.RequestHelper;
+import ru.spcex.clearing.validation.common.ValidationHelper;
+import ru.spcex.platform.enumeration.UserRole;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgId;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.error.ValidationException;
+import ru.spcex.platform.utils.validation.IValidator;
+
+import java.time.Instant;
+import java.util.Optional;
+
+@Service
+public class CurrencyPairSecurityService extends QueueConsumer implements InitializingBean {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final Imdg<CurrencyPairSecurity> currencyPairSecurityImdg;
+    private final ImdgProvider imdgProvider;
+    private final ImdgId idGenerator;
+    private final ValidationProvider validation;
+    private final UserRoleVerification userRoleVerification;
+    private final ValidationHelper validationHelper;
+    private final RequestHelper requestHelper;
+
+    @Autowired
+    public CurrencyPairSecurityService(Consumer<String, Object> kafkaQueue,
+                                       Producer<String, Object> kafkaProducer,
+                                       ImdgProvider imdgProvider,
+                                       ValidationProvider validation,
+                                       UserRoleVerification userRoleVerification,
+                                       ValidationHelper validationHelper,
+                                       RequestHelper requestHelper) {
+        super(kafkaQueue, kafkaProducer);
+        this.validation = validation;
+        this.currencyPairSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class);
+        this.imdgProvider = imdgProvider;
+        this.idGenerator = imdgProvider.getImdgIdGenerator();
+        this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
+        this.validationHelper = validationHelper;
+        this.requestHelper = requestHelper.setLogger(log);
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        callback(CurrencyPairSecurityNewRequest.class)
+                .setFunction(this::newCurrencyPairSecurity)
+                .forDestination(Consts.DESTINATION_CURRENCY_PAIR_SECURITIES_NEW, callbacks::put);
+        callback(CurrencyPairSecurityUpdateRequest.class)
+                .setFunction(this::updateCurrencyPairSecurity)
+                .forDestination(Consts.DESTINATION_CURRENCY_PAIR_SECURITIES_UPDATE, callbacks::put);
+        callback(CommonDeleteRequest.class)
+                .setFunction(this::deleteCurrencyPairSecurity)
+                .forDestination(Consts.DESTINATION_CURRENCY_PAIR_SECURITIES_DELETE, callbacks::put);
+        imdgProvider.waitAvailable();
+        init();
+    }
+
+
+    protected RequestInfoUpdate newCurrencyPairSecurity(BaseRequest<CurrencyPairSecurityNewRequest> userRequest) {
+        log.debug("CurrencyPairSecurityNewRequest received, id={}", userRequest.getId());
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+        CurrencyPairSecurity currencyPair = null;
+        try {
+            currencyPair = newCurrencyPairSecurity0(userRequest.getRequestPayload());
+            log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), currencyPair.getId());
+            return null;
+        } catch (ValidationException e) {
+            return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
+        }
+    }
+
+    protected synchronized CurrencyPairSecurity newCurrencyPairSecurity0(CurrencyPairSecurityNewRequest req) throws ValidationException {
+        IValidator validator = validation.currencyPairSecurityNewValidator().apply(req);
+        Optional<EnumMessage> validationError = validator.tillFirstError();
+        if (validationError.isPresent()) {
+            throw new ValidationException(validationError.get());
+        }
+
+        CurrencyPairSecurity currencyPairSecurity = new CurrencyPairSecurity();
+        currencyPairSecurity.setId(idGenerator.nextId());
+
+        currencyPairSecurity.setInstrumentType(req.getInstrumentType());
+        currencyPairSecurity.setSecuritySymbol(StringUtils.hasText(req.getSecuritySymbol()) ? req.getSecuritySymbol().trim() : null);
+
+        currencyPairSecurity.setBaseUnitSize(req.getBaseUnitSize());
+        currencyPairSecurity.setCurrencyPairId(req.getCurrencyPairId());
+        //todo currencyPairSecurity.setCode(req.getCode());
+        currencyPairSecurity.setSettlementType(req.getSettlementType());
+        currencyPairSecurity.setClearingOrganization(req.getClearingOrganization());
+        currencyPairSecurity.setSettlementOrganization(req.getSettlementOrganization());
+        currencyPairSecurity.setSecurityId(currencyPairSecurity.getId());
+        currencyPairSecurity.setSecuritySymbol(req.getSecuritySymbol());
+        currencyPairSecurity.setShortName(req.getShortName());
+        currencyPairSecurity.setFullName(req.getFullName());
+//        currencyPairSecurity.setShortNameEng(req.getShortNameEng());
+//        currencyPairSecurity.setFullNameEng(req.getFullNameEng());
+        if (req.getWorkflowStatus() == null) {
+            currencyPairSecurity.setWorkflowStatus(WorkflowStatus.Active.getKey());
+        } else {
+            currencyPairSecurity.setWorkflowStatus(req.getWorkflowStatus());
+        }
+
+        currencyPairSecurity.setCreated(Instant.now());
+        currencyPairSecurity.setUpdated(currencyPairSecurity.getCreated());
+        currencyPairSecurityImdg.insert(currencyPairSecurity);
+
+        //todo listing update: listing (добавлены поля minStep и precision) см. ListingBuilder
+
+        return currencyPairSecurity;
+    }
+
+    protected RequestInfoUpdate updateCurrencyPairSecurity(BaseRequest<CurrencyPairSecurityUpdateRequest> userRequest) {
+        log.debug("CurrencyPairSecurityUpdateRequest received id = {} (update object id={})", userRequest.getId(), userRequest.getRequestPayload() == null ? null : userRequest.getRequestPayload().getId());
+        try {
+            userRoleVerification.validateRoleAndThrow(userRequest);
+            CurrencyPairSecurity currencyPairSecurity = updateCurrencyPairSecurity0(userRequest.getRequestPayload());
+            log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), currencyPairSecurity.getId());
+            return null;
+        } catch (ValidationException e) {
+            return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
+        }
+    }
+
+    protected synchronized CurrencyPairSecurity updateCurrencyPairSecurity0(CurrencyPairSecurityUpdateRequest req) throws ValidationException {
+        validationHelper.validateTillFirstErrorAndThrow(req, validation.currencyPairSecurityUpdateValidator());
+
+        CurrencyPairSecurity currencyPairSecurity = currencyPairSecurityImdg.getSingleObjectByID(req.getId());
+        Instant updateTime = Instant.now();
+        currencyPairSecurity.setUpdated(updateTime);
+
+//        currencyPairSecurity.setInstrumentType(req.getInstrumentType());
+        currencyPairSecurity.setSecuritySymbol(StringUtils.hasText(req.getSecuritySymbol()) ? req.getSecuritySymbol().trim() : null);
+
+        currencyPairSecurity.setBaseUnitSize(req.getBaseUnitSize());
+        currencyPairSecurity.setCurrencyPairId(req.getCurrencyPairId());
+        //todo currencyPairSecurity.setCode(req.getCode());
+        currencyPairSecurity.setSettlementType(req.getSettlementType());
+        currencyPairSecurity.setClearingOrganization(req.getClearingOrganization());
+        currencyPairSecurity.setSettlementOrganization(req.getSettlementOrganization());
+        currencyPairSecurity.setSecurityId(currencyPairSecurity.getId());
+        currencyPairSecurity.setSecuritySymbol(req.getSecuritySymbol());
+        currencyPairSecurity.setShortName(req.getShortName());
+        currencyPairSecurity.setFullName(req.getFullName());
+//        currencyPairSecurity.setShortNameEng(req.getShortNameEng());
+//        currencyPairSecurity.setFullNameEng(req.getFullNameEng());
+        if (req.getWorkflowStatus() == null) {
+            currencyPairSecurity.setWorkflowStatus(req.getWorkflowStatus());
+        }
+
+        currencyPairSecurityImdg.update(currencyPairSecurity);
+        return currencyPairSecurity;
+    }
+
+    protected RequestInfoUpdate deleteCurrencyPairSecurity(BaseRequest<CommonDeleteRequest> userRequest) {
+        log.debug("CommonDeleteRequest received id = {} (object id={})", userRequest.getId(), userRequest.getRequestPayload() == null ? null : userRequest.getRequestPayload().getId());
+        try {
+            userRoleVerification.validateRoleAndThrow(userRequest);
+            Long id = deleteCurrencyPairSecurity0(userRequest.getRequestPayload());
+            log.debug("successfully processed, request id {}, delete object id {}", userRequest.getId(), id);
+            return null;
+        } catch (ValidationException e) {
+            return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
+        }
+    }
+
+    protected synchronized Long deleteCurrencyPairSecurity0(CommonDeleteRequest req) throws ValidationException {
+        validationHelper.validateTillFirstErrorAndThrow(req, validation.currencyPairSecurityDeleteValidator());
+
+        Instant updateTime = Instant.now();
+        CurrencyPairSecurity equity = currencyPairSecurityImdg.getSingleObjectByID(req.getId());
+        equity.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
+        equity.setUpdated(updateTime);
+        currencyPairSecurityImdg.update(equity);
+
+        return null;
+    }
+
+}

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

@@ -1,6 +1,7 @@
 package ru.spcex.clearing.securities.service.cud;
 
 import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -20,10 +21,12 @@ import ru.clearing.classes.statics.data.security.Security;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.company.CurrencyPairSecurityGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.company.EquitySecurityGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.company.FixedIncomeGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.company.SecurityFondGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.*;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
 import ru.spcex.clearing.securities.validation.ValidationProvider;
@@ -61,6 +64,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
     private final FixedIncomeSecurityService fixedIncomeSecurityService;
     private final EquitySecurityService equitySecurityService;
     private final MoneyMarketSecurityService moneyMarketSecurityService;
+    private final CurrencyPairSecurityService currencyPairSecurityService;
     private final ListingService listingService;
     private final CouponPeriodService couponPeriodService;
     private final FixedIncomeCashFlowService fixedIncomeCashFlowService;
@@ -84,6 +88,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
                                   FixedIncomeSecurityService fixedIncomeSecurityService,
                                   EquitySecurityService equitySecurityService,
                                   MoneyMarketSecurityService moneyMarketSecurityService,
+                                  CurrencyPairSecurityService currencyPairSecurityService,
                                   ListingService listingService,
                                   CouponPeriodService couponPeriodService,
                                   FixedIncomeCashFlowService fixedIncomeCashFlowService) {
@@ -92,6 +97,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
         this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
         this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
         this.moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
+        this.currencyPairSecurityService = currencyPairSecurityService;
         this.listingImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
         this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
         this.fixedIncomeCashFlowImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class);
@@ -123,6 +129,10 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
         callback(MoneyMarketSecurityNewGatewayRequest.class)
                 .setFunction(this::newMoneyMarketSecurity)
                 .forDestination(Consts.DESTINATION_GATEWAY_MONEY_MARKET_SECURITY, callbacks::put);
+        callback(CurrencyPairSecurityGatewayRequest.class)
+                .setFunction(this::newSecurities)
+                .forDestination(Consts.DESTINATION_SECURITY_CURRENCY_GATEWAY, callbacks::put);
+
         imdgProvider.waitAvailable();
         init();
     }
@@ -226,6 +236,28 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
                     security = equitySecurityService.updateEquity0(updateRequest);
                 }
             }
+            if (InstrumentType.CRNC.equalsByKey(req.getSecurityType())) {
+//                CurrencyPairSecurityGatewayRequest currencyPairSecurityGatewayRequest = (CurrencyPairSecurityGatewayRequest) req;
+//                CurrencyPairSecurityNewRequest currencyPairRequest = currencyPairSecurityGatewayRequest.getSecurity();
+//                if (StringUtils.isEmpty(currencyPairRequest.getSecuritySymbol())) {
+//                    log.warn("Skip creating CurrencyPairSecurity without securityId: uuid: {}", req.getUuid());
+//                    return null;
+//                }
+//                log.debug("Processed request with securitySymbol: {}", currencyPairRequest.getSecuritySymbol());
+//                currencyPairRequest.setIssuerId(companyId);
+//                log.trace("EquitySecurityNewRequest - FOND");
+//                String securitySymbol = currencyPairRequest.getSecuritySymbol();
+//                security = findSecurityBySecuritySymbol(currencyPairSecurityImdg, securitySymbol);
+//
+//                if (security == null) {
+//                    security = currencyPairSecurityService.newEquity0(currencyPairRequest);
+//                } else {
+//                    EquitySecurityUpdateRequest updateRequest = toUpdateRequest(security, currencyPairRequest);
+//                    security = currencyPairSecurityService.updateEquity0(updateRequest);
+//                }
+//                    //fixme currencypair будет отдельная задача
+                throw new IllegalStateException("todo CRNC");
+            }
         } catch (ValidationException expected) {
             if (security == null) {
                 log.error("Error create or update issue: {}", messageResolver.resolve(expected.getEnumMsg()));

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

@@ -1,17 +1,26 @@
 package ru.spcex.clearing.securities.validation;
 
 import org.springframework.stereotype.Component;
+import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeCashFlow;
 import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
+import ru.clearing.classes.statics.data.misc.Market;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
 import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
+import ru.clearing.platform.dictionary.InstrumentTypeDictionary;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.AccountSymbolsNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.*;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityUpdateRequest;
 import ru.spcex.clearing.securities.errors.SecuritiesError;
 import ru.spcex.clearing.securities.validation.rule.*;
-import ru.spcex.clearing.validation.common.rules.EndDtAfterStartDtRule;
+import ru.spcex.clearing.validation.common.rules.*;
-import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.classes.base.interfaces.WithInstrumentType;
+import ru.spcex.platform.enumeration.AccountType;
 import ru.spcex.platform.enumeration.InstrumentType;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
@@ -20,6 +29,8 @@ import ru.spcex.platform.imdg.validation.rule.PresentById;
 import ru.spcex.platform.utils.validation.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
 
+import java.util.Collection;
+import java.util.HashMap;
 import java.util.function.Function;
 
 @Component
@@ -36,6 +47,7 @@ public class ValidationProvider {
     private final Imdg<SpcexObjectBase> companyImdg;
     private final Imdg<SpcexObjectBase> currencyImdg;
     private final Imdg<SpcexObjectBase> couponPeriodImdg;
+    private final Imdg<CurrencyPairSecurity> currencyPairSecurityMap;
 
 
     public ValidationProvider(ImdgProvider imdgProvider) {
@@ -51,6 +63,7 @@ public class ValidationProvider {
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, SpcexObjectBase.class);
         this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, SpcexObjectBase.class);
         this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, SpcexObjectBase.class);
+        this.currencyPairSecurityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class);
     }
 
     public Function<MoneyMarketSecurityNewRequest, IValidator> mmsNewValidator() {
@@ -204,7 +217,6 @@ public class ValidationProvider {
             context.setValidatedObject(equityRequest);
             context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeMap);
             context.addImdg(IMDGDistributedNames.Map_Company, companyImdg);
-            context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeMap);
             context.addImdg(IMDGDistributedNames.Map_InstrumentTypeDictionary, instrumentTypeDictionaryImdg);
             context.addImdg(IMDGDistributedNames.Map_WorkflowStatusDictionary, workflowStatusDictionaryImdg);
             context.addImdg(IMDGDistributedNames.Map_BondTypeDictionary, bondTypeDictionaryImdg);
@@ -226,7 +238,6 @@ public class ValidationProvider {
             ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
             context.setValidatedObject(equityRequest);
             context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeMap);
-            context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeMap);
             return new ValidatorImpl<>(context,
                     new PresentById(IMDGDistributedNames.Map_FixedIncomeSecurity, SecuritiesError.InstrumentNotFound, true),
                     new IsValidInstrumentTypeById(SecuritiesError.InstrumentNotFound, "BOND"),
@@ -294,4 +305,166 @@ public class ValidationProvider {
             );
         };
     }
+
+
+    public Function<CurrencyPairSecurityNewRequest, IValidator> currencyPairSecurityNewValidator() {
+        return equityRequest -> {
+            ImdgValidationContext<CurrencyPairSecurityNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(equityRequest);
+            context.addImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, currencyPairSecurityMap);
+            context.addImdg(IMDGDistributedNames.Map_Company, companyImdg);
+            context.addImdg(IMDGDistributedNames.Map_InstrumentTypeDictionary, instrumentTypeDictionaryImdg);
+            context.addImdg(IMDGDistributedNames.Map_WorkflowStatusDictionary, workflowStatusDictionaryImdg);
+            context.addImdg(IMDGDistributedNames.Map_BondTypeDictionary, bondTypeDictionaryImdg);
+            context.addImdg(IMDGDistributedNames.Map_CurrencyCodeDictionary, currencyCodeDictionaryImdg);
+            return new ValidatorImpl<>(context,
+
+                    DictionaryPresentRule.instance("instrumentType",
+                            WithInstrumentType::getInstrumentType, IMDGDistributedNames.Map_InstrumentTypeDictionary,
+                            InstrumentTypeDictionary.class,
+                            SecuritiesError.RequiredFieldIsEmpty, SecuritiesError.DictionaryNotFound,
+                            true),
+                    new IsValidInstrumentTypeFromRequest(SecuritiesError.RequiredFieldIsEmpty, InstrumentType.CRNC.getKey()),
+                    FieldRequiredRule.instance("securitySymbol",
+                            CurrencyPairSecurityNewRequest::getSecuritySymbol,
+                            SecuritiesError.RequiredFieldIsEmpty,
+                            true
+//                            securitySymbol -> {
+//                                Imdg<CurrencyPairSecurity> currencyPairImdg = context.obtainMap(
+//                                        IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class
+//                                );
+//                                Long securityId = Long.valueOf(securitySymbol);
+//                                Collection<CurrencyPairSecurity> currencyPairs = currencyPairImdg.getCollectionObjectsByFieldValues(query);
+//                                if (!currencyPairs.isEmpty()) return SecuritiesError.CouponPeriodAlreadyExists;
+//                                return null;
+//                            }
+                    ),
+                    FieldNotBlankRequiredRule.instance("shortName",
+                            CurrencyPairSecurityNewRequest::getShortName,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldNotBlankRequiredRule.instance("fullName",
+                            CurrencyPairSecurityNewRequest::getFullName,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldRequiredRule.instance("market",
+                            CurrencyPairSecurityNewRequest::getMarket,
+                            SecuritiesError.RequiredFieldIsEmpty, true),// todo verify in MarketMap?
+                    IdPresentRule.instance("currencyPairId",
+                            CurrencyPairSecurityNewRequest::getCurrencyPairId,
+                            IMDGDistributedNames.Map_CurrencyPairDictionary,
+                            Market.class,
+                            SecuritiesError.RequiredFieldIsEmpty,
+                            SecuritiesError.MarketNotFound
+                    ),
+                    FieldRequiredRule.instance("lotSize",
+                            CurrencyPairSecurityNewRequest::getLotSize,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldRequiredRule.instance("minStep",
+                            CurrencyPairSecurityNewRequest::getMinStep,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldRequiredRule.instance("baseUnitSize",
+                            CurrencyPairSecurityNewRequest::getBaseUnitSize,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldRequiredRule.instance("settlementType",
+                            CurrencyPairSecurityNewRequest::getSettlementType,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    DictionaryPresentRule.instance("workflowStatus",
+                            CurrencyPairSecurityNewRequest::getWorkflowStatus, IMDGDistributedNames.Map_WorkflowStatusDictionary,
+                            InstrumentTypeDictionary.class,
+                            SecuritiesError.RequiredFieldIsEmpty, SecuritiesError.DictionaryNotFound,
+                            true)
+//                    FieldRequiredRule.instance("settlementOrganization",
+//                            CurrencyPairSecurityNewRequest::getSettlementOrganization,
+//                            SecuritiesError.RequiredFieldIsEmpty, true),
+//                    FieldRequiredRule.instance("clearingOrganization",
+//                            CurrencyPairSecurityNewRequest::getClearingOrganization,
+//                            SecuritiesError.RequiredFieldIsEmpty, true),
+            );
+        };
+    }
+
+    public Function<CurrencyPairSecurityUpdateRequest, IValidator> currencyPairSecurityUpdateValidator() {
+        return equityRequest -> {
+            ImdgValidationContext<CurrencyPairSecurityUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(equityRequest);
+            context.addImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, currencyPairSecurityMap);
+            context.addImdg(IMDGDistributedNames.Map_Company, companyImdg);
+            context.addImdg(IMDGDistributedNames.Map_InstrumentTypeDictionary, instrumentTypeDictionaryImdg);
+            context.addImdg(IMDGDistributedNames.Map_WorkflowStatusDictionary, workflowStatusDictionaryImdg);
+            context.addImdg(IMDGDistributedNames.Map_BondTypeDictionary, bondTypeDictionaryImdg);
+            context.addImdg(IMDGDistributedNames.Map_CurrencyCodeDictionary, currencyCodeDictionaryImdg);
+            return new ValidatorImpl<>(context,
+                    DictionaryPresentRule.instance("instrumentType",
+                            CurrencyPairSecurityUpdateRequest::getInstrumentType, IMDGDistributedNames.Map_InstrumentTypeDictionary,
+                            InstrumentTypeDictionary.class,
+                            SecuritiesError.RequiredFieldIsEmpty, SecuritiesError.DictionaryNotFound,
+                            true),
+                    FieldRequiredRule.instance("securitySymbol",
+                            CurrencyPairSecurityUpdateRequest::getSecuritySymbol,
+                            SecuritiesError.RequiredFieldIsEmpty,
+                            true
+//                            securitySymbol -> {
+//                                Imdg<CurrencyPairSecurity> currencyPairImdg = context.obtainMap(
+//                                        IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class
+//                                );
+//                                Long securityId = Long.valueOf(securitySymbol);
+//                                Collection<CurrencyPairSecurity> currencyPairs = currencyPairImdg.getCollectionObjectsByFieldValues(query);
+//                                if (!currencyPairs.isEmpty()) return SecuritiesError.CouponPeriodAlreadyExists;
+//                                return null;
+//                            }
+                    ),
+                    FieldNotBlankRequiredRule.instance("shortName",
+                            CurrencyPairSecurityUpdateRequest::getShortName,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldNotBlankRequiredRule.instance("fullName",
+                            CurrencyPairSecurityUpdateRequest::getFullName,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldRequiredRule.instance("market",
+                            CurrencyPairSecurityUpdateRequest::getMarket,
+                            SecuritiesError.RequiredFieldIsEmpty, true),// todo verify in MarketMap?
+                    IdPresentRule.instance("currencyPairId",
+                            CurrencyPairSecurityUpdateRequest::getCurrencyPairId,
+                            IMDGDistributedNames.Map_CurrencyPairDictionary,
+                            Market.class,
+                            SecuritiesError.RequiredFieldIsEmpty,
+                            SecuritiesError.MarketNotFound
+                    ),
+                    FieldRequiredRule.instance("lotSize",
+                            CurrencyPairSecurityUpdateRequest::getLotSize,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldRequiredRule.instance("minStep",
+                            CurrencyPairSecurityUpdateRequest::getMinStep,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldRequiredRule.instance("baseUnitSize",
+                            CurrencyPairSecurityUpdateRequest::getBaseUnitSize,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    FieldRequiredRule.instance("settlementType",
+                            CurrencyPairSecurityUpdateRequest::getSettlementType,
+                            SecuritiesError.RequiredFieldIsEmpty, true),
+                    DictionaryPresentRule.instance("workflowStatus",
+                            CurrencyPairSecurityUpdateRequest::getWorkflowStatus, IMDGDistributedNames.Map_WorkflowStatusDictionary,
+                            InstrumentTypeDictionary.class,
+                            SecuritiesError.RequiredFieldIsEmpty, SecuritiesError.DictionaryNotFound,
+                            true)
+//                    FieldRequiredRule.instance("settlementOrganization",
+//                            CurrencyPairSecurityNewRequest::getSettlementOrganization,
+//                            SecuritiesError.RequiredFieldIsEmpty, true),
+//                    FieldRequiredRule.instance("clearingOrganization",
+//                            CurrencyPairSecurityNewRequest::getClearingOrganization,
+//                            SecuritiesError.RequiredFieldIsEmpty, true),
+            );
+        };
+    }
+
+    public Function<CommonDeleteRequest, IValidator> currencyPairSecurityDeleteValidator() {
+        return equityRequest -> {
+            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(equityRequest);
+            context.addImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, currencyPairSecurityMap);
+            return new ValidatorImpl<>(context,
+                    new PresentById(IMDGDistributedNames.Map_CurrencyPairSecurity, SecuritiesError.InstrumentNotFound, true),
+                    new IsValidInstrumentTypeById(SecuritiesError.InstrumentNotFound, InstrumentType.CRNC.getKey()),
+                    new WorkflowStatusActv()
+            );
+        };
+    }
 }

platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/SecuritySelector.java

@@ -13,19 +13,23 @@ public class SecuritySelector<T extends SpcexObjectBase> {
     private final Imdg<T> fixedIncomeSecurityImdg;
     private final Imdg<T> moneyMarketSecurityImdg;
     private final Imdg<T> equitySecurity;
+    private final Imdg<T> currencyPairSecurity;
 
     public SecuritySelector(ImdgProvider imdgProvider, Class<T> clazz) {
         this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, clazz);
         this.moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, clazz);
         this.equitySecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, clazz);
+        this.currencyPairSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, clazz);
     }
 
     public SecuritySelector(Imdg<T> fixedIncomeSecurityImdg,
                             Imdg<T> moneyMarketSecurityImdg,
-                            Imdg<T> equitySecurity) {
+                            Imdg<T> equitySecurity,
+                            Imdg<T> currencyPairSecurity) {
         this.fixedIncomeSecurityImdg = fixedIncomeSecurityImdg;
         this.moneyMarketSecurityImdg = moneyMarketSecurityImdg;
         this.equitySecurity = equitySecurity;
+        this.currencyPairSecurity = currencyPairSecurity;
     }
 
     public T selectSecurityById(Long securityId) {
@@ -43,6 +47,8 @@ public class SecuritySelector<T extends SpcexObjectBase> {
         security = retriever.apply(moneyMarketSecurityImdg);
         if (security != null) return security;
         security = retriever.apply(equitySecurity);
+        if (security != null) return security;
+        security = retriever.apply(currencyPairSecurity);
         return security;// null
     }
 }

platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java

@@ -16,6 +16,7 @@ public interface Consts {
 
     String DESTINATION_SECURITY_BOND_GATEWAY = "security-bond-gateway-request-new";
     String DESTINATION_SECURITY_EQTY_GATEWAY = "security-eqty-gateway-request-new";
+    String DESTINATION_SECURITY_CURRENCY_GATEWAY = "security-currency-pair-gateway-request-new";
 
     String DESTINATION_FIXED_INCOME_CASH_FLOW_NEW = "fixed-income-cash-flow-new";
     String DESTINATION_FIXED_INCOME_CASH_FLOW_UPDATE = "fixed-income-cash-flow-update";

platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/company/CurrencyPairSecurityGatewayRequest.java

@@ -0,0 +1,24 @@
+package ru.spcex.clearing.platform.messaging.domain.cud.company;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest;
+
+public class CurrencyPairSecurityGatewayRequest extends SecurityFondGatewayRequest {
+    @JsonProperty
+    private CurrencyPairSecurityNewRequest security;
+
+    public CurrencyPairSecurityGatewayRequest() {
+    }
+
+    public CurrencyPairSecurityGatewayRequest(CurrencyPairSecurityNewRequest security) {
+        this.security = security;
+    }
+
+    public CurrencyPairSecurityNewRequest getSecurity() {
+        return security;
+    }
+
+    public void setSecurity(CurrencyPairSecurityNewRequest security) {
+        this.security = security;
+    }
+}