http://jira.mfd.msk:8088/browse/CLS-849

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

@@ -0,0 +1,58 @@
+package ru.spcex.clearing.gatewayapi.service;
+
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.DigitalCertificate;
+import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.FondDigitalListingsRequest;
+import ru.spcex.clearing.gatewayapi.service.adapter.DigitalSecurityRequestAdapter;
+import ru.spcex.clearing.gatewayapi.service.adapter.SecurityRequestAdapter;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertificateSecurityGatewayRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.ListingNewRequest;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.platform.utils.log.ExceptionUtils;
+
+@Service
+public class DigitalSecurityService {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private final SecurityRequestAdapter securityRequestAdapter;
+    private final DigitalSecurityRequestAdapter digitalSecurityRequestAdapter;
+    private final KafkaSender kafkaSender;
+
+    public DigitalSecurityService(SecurityRequestAdapter securityRequestAdapter,
+                                  DigitalSecurityRequestAdapter digitalSecurityRequestAdapter,
+                                  KafkaSender kafkaSender) {
+        this.securityRequestAdapter = securityRequestAdapter;
+        this.digitalSecurityRequestAdapter = digitalSecurityRequestAdapter;
+        this.kafkaSender = kafkaSender;
+    }
+
+    public void sendRequest(FondDigitalListingsRequest request) {
+        CodeStatusComparator<DigitalCertificate> comparatorBySecSymbolAndWorkflowStatus = CodeStatusComparator.create(
+            DigitalCertificate::getSecuritySymbol,
+            DigitalCertificate::getWorkflowStatus);
+        List<DigitalCertificate> securityList = request.getDigitalCertificates().stream()
+            .filter(r -> {
+                boolean ok = r.getSecuritySymbol() != null && r.getWorkflowStatus() != null;
+                if (!ok) {
+                    log.debug("FondSecurity {}, ignore 1002: required field 'SecuritySymbol' or 'WorkflowStatus'  was empty", r.getId());
+                }
+                return ok;
+            })
+            .sorted(comparatorBySecSymbolAndWorkflowStatus).toList();
+        for (DigitalCertificate security : securityList) {
+            try {
+                DigitalCertificateSecurityGatewayRequest digitalCertificateSecurityRequest = digitalSecurityRequestAdapter.toRequest(security);
+                List<ListingNewRequest> listingRequests = request.getListingList().stream().
+                    map(securityRequestAdapter::toIncomeListing).toList();
+                digitalCertificateSecurityRequest.setListing(listingRequests);
+                kafkaSender.sendRequestToQueue(Consts.DESTINATION_SECURITY_DGCT_GATEWAY, digitalCertificateSecurityRequest);
+            } catch (Throwable e) {
+                log.error("{}", ExceptionUtils.getStackTrace(e));
+            }
+        }
+    }
+}

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

@@ -1,25 +1,31 @@
 package ru.spcex.clearing.gatewayapi.service;
 
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 import ru.spcex.clearing.gatewayapi.controller.inbound.request.WithSecurityId;
-import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.*;
+import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.CouponSchedule;
+import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.FondListingsRequest;
+import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.FondSecurity;
+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.gatewayapi.service.adapter.SecurityRequestAdapter;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 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.securitites.CouponPeriodNewRequest;
-import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.EquitySecurityNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.FixedIncomeCashFlowNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.FixedIncomeSecurityNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.ListingNewRequest;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.platform.enumeration.InstrumentType;
 import ru.spcex.platform.utils.log.ExceptionUtils;
 
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
 @Service
 public class SecurityService {
     private final Logger log = LoggerFactory.getLogger(getClass());

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

@@ -0,0 +1,40 @@
+package ru.spcex.clearing.gatewayapi.service.adapter;
+
+import java.time.LocalDate;
+import java.util.Optional;
+import org.springframework.stereotype.Service;
+import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.DigitalCertificate;
+import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.DigitalNominal;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertificateSecurityGatewayRequest;
+
+@Service
+public class DigitalSecurityRequestAdapter {
+
+    public DigitalCertificateSecurityGatewayRequest toRequest(DigitalCertificate digitalCertificate) {
+        DigitalCertificateSecurityGatewayRequest gatewayRequest = new DigitalCertificateSecurityGatewayRequest();
+        gatewayRequest.setDepoDcId(digitalCertificate.getDepoDcId());
+        gatewayRequest.setInstrumentType(digitalCertificate.getInstrumentType());
+        gatewayRequest.setIssuerId(digitalCertificate.getIssuerId());
+        gatewayRequest.setShortName(digitalCertificate.getShortName());
+        gatewayRequest.setFullName(digitalCertificate.getFullName());
+        gatewayRequest.setShortNameEng(digitalCertificate.getShortNameEng());
+        gatewayRequest.setNumberOfUcp(digitalCertificate.getNumberOfUcp());
+        gatewayRequest.setDeltaPrice(digitalCertificate.getDeltaPrice());
+        gatewayRequest.setSecuritySymbol(digitalCertificate.getSecuritySymbol());
+        gatewayRequest.setWorkflowStatus(digitalCertificate.getWorkflowStatus());
+        gatewayRequest.setTypeCode(digitalCertificate.getTypeCode());
+        gatewayRequest.setSettlementOrganization(digitalCertificate.getSettlementOrganization());
+        gatewayRequest.setSettlementDepository(digitalCertificate.getSettlementDepository());
+
+        Optional<DigitalNominal> digitalNominal = digitalCertificate.getNominal().stream()
+            .filter(
+                nominal -> nominal.getIndexDate().isEqual(LocalDate.now()))
+            .findFirst();
+        digitalNominal.ifPresent(nominal -> {
+            gatewayRequest.setNominalIndexDate(nominal.getIndexDate());
+            gatewayRequest.setNominalDenominationUnitForDate(nominal.getDenominationUnitForDate());
+            gatewayRequest.setNominalIndexFact(nominal.getIndexFact());
+        });
+        return gatewayRequest;
+    }
+}

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

@@ -4,15 +4,19 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.FondDigitalListingsRequest;
+import ru.spcex.clearing.gatewayapi.service.DigitalSecurityService;
 
 @Service
 public class ListingDigitalFondProcessor {
     private final Logger log = LoggerFactory.getLogger(getClass());
+    private final DigitalSecurityService digitalSecurityService;
 
-    public ListingDigitalFondProcessor() {
+    public ListingDigitalFondProcessor(DigitalSecurityService digitalSecurityService) {
+        this.digitalSecurityService = digitalSecurityService;
     }
 
     public void process(FondDigitalListingsRequest request) {
+        digitalSecurityService.sendRequest(request);
         log.debug("process FondListingsRequest done");
     }
 }

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

@@ -1,6 +1,5 @@
 package ru.spcex.clearing.securities.service.cud;
 
-import java.time.Instant;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -8,9 +7,6 @@ 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.DigitalCertificateSecurity;
-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;
@@ -18,13 +14,12 @@ import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertif
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertificateSecurityUpdateRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.securities.service.facade.DigitalCertificateSecurityFacade;
 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.error.ValidationException;
@@ -32,13 +27,13 @@ import ru.spcex.platform.utils.error.ValidationException;
 @Service
 public class DigitalCertificateSecurityService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
-    private final Imdg<DigitalCertificateSecurity> digitalCertificateSecurityImdg;
     private final ImdgProvider imdgProvider;
     private final ImdgId idGenerator;
     private final ValidationProvider validation;
     private final UserRoleVerification userRoleVerification;
     private final ValidationHelper validationHelper;
     private final RequestHelper requestHelper;
+    private final DigitalCertificateSecurityFacade digitalCertificateSecurityFacade;
 
     @Autowired
     public DigitalCertificateSecurityService(Consumer<String, Object> kafkaQueue,
@@ -47,15 +42,16 @@ public class DigitalCertificateSecurityService extends QueueConsumer implements
                                              UserRoleVerification userRoleVerification,
                                              ValidationProvider validation,
                                              ValidationHelper validationHelper,
-                                             RequestHelper requestHelper) {
+                                             RequestHelper requestHelper,
+                                             DigitalCertificateSecurityFacade digitalCertificateSecurityFacade) {
         super(kafkaQueue, kafkaProducer);
         this.validation = validation;
-        this.digitalCertificateSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DigitalCertificateSecurity, DigitalCertificateSecurity.class);
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
         this.validationHelper = validationHelper;
         this.requestHelper = requestHelper;
+        this.digitalCertificateSecurityFacade = digitalCertificateSecurityFacade;
     }
 
     @Override
@@ -77,113 +73,37 @@ public class DigitalCertificateSecurityService extends QueueConsumer implements
         log.debug("DigitalCertificateSecurityNewRequest received, id={}", userRequest.getId());
         try {
             userRoleVerification.validateRoleAndThrow(userRequest);
-            DigitalCertificateSecurity digitalCertificateSecurity = newDigitalCertificate0(userRequest.getRequestPayload());
+            DigitalCertificateSecurityNewRequest req = userRequest.getRequestPayload();
-            log.debug("successfully processed, request id {}, new digital_certificate_security.id {}", userRequest.getId(), digitalCertificateSecurity.getId());
+            validationHelper.validateTillFirstErrorAndThrow(req, validation.digitalCertificateNewValidator());
+            digitalCertificateSecurityFacade.newDigitalCertificate(req);
             return null;
         } catch (ValidationException e) {
             return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
         }
     }
 
-    protected synchronized DigitalCertificateSecurity newDigitalCertificate0(DigitalCertificateSecurityNewRequest req) throws ValidationException {
-        validationHelper.validateTillFirstErrorAndThrow(req, validation.digitalCertificateNewValidator());
-
-        log.debug("DigitalCertificateSecurityNewRequest received");
-        DigitalCertificateSecurity digitalCertificate = new DigitalCertificateSecurity();
-        digitalCertificate.setId(idGenerator.nextId());
-        digitalCertificate.setSecuritySymbol(StringUtils.hasText(req.getSecuritySymbol()) ? req.getSecuritySymbol().trim() : null);
-        digitalCertificate.setShortName(req.getShortName());
-        digitalCertificate.setFullName(req.getFullName());
-        digitalCertificate.setIssuerId(req.getIssuerId());
-        digitalCertificate.setShortNameEng(req.getShortNameEng());
-        digitalCertificate.setFullNameEng(req.getFullNameEng());
-        if (req.getWorkflowStatus() == null) {
-            digitalCertificate.setWorkflowStatus(WorkflowStatus.Active.getKey());
-        } else {
-            digitalCertificate.setWorkflowStatus(req.getWorkflowStatus());
-        }
-        digitalCertificate.setInstrumentType(req.getInstrumentType());
-        digitalCertificate.setSecurityId(digitalCertificate.getId());
-        digitalCertificate.setCreated(Instant.now());
-        digitalCertificate.setUpdated(digitalCertificate.getCreated());
-        digitalCertificate.setBaseCode(req.getBaseCode());
-        digitalCertificate.setBaseUnitSize(req.getBaseUnitSize());
-        digitalCertificate.setPriceVarianceLimit(req.getPriceVarianceLimit());
-        digitalCertificate.setNominalTypeCode(req.getNominalTypeCode());
-        digitalCertificate.setNominalValue(req.getNominalValue());
-        digitalCertificate.setNominalIndexationDate(req.getNominalIndexationDate());
-        digitalCertificate.setNominalIndexationSign(req.getNominalIndexationSign());
-        digitalCertificate.setSettlementHouse(req.getSettlementHouse());
-        digitalCertificate.setDepository(req.getDepository());
-        digitalCertificateSecurityImdg.insert(digitalCertificate);
-        return digitalCertificate;
-    }
-
     protected RequestInfoUpdate updateDigitalCertificate(BaseRequest<DigitalCertificateSecurityUpdateRequest> userRequest) {
         log.debug("DigitalCertificateSecurityUpdateRequest received, id={}", userRequest.getId());
         try {
             userRoleVerification.validateRoleAndThrow(userRequest);
-            DigitalCertificateSecurity digitalCertificateSecurity = updateDigitalCertificate0(userRequest.getRequestPayload());
+            DigitalCertificateSecurityUpdateRequest req = userRequest.getRequestPayload();
-            log.debug("successfully processed, request id {}, updated digital_certificate_security.id {}", userRequest.getId(), digitalCertificateSecurity.getId());
+            validationHelper.validateTillFirstErrorAndThrow(req, validation.digitalCertificateUpdateValidator());
+            digitalCertificateSecurityFacade.updateDigitalCertificate(req);
             return null;
         } catch (ValidationException e) {
             return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
         }
     }
-
-    protected synchronized DigitalCertificateSecurity updateDigitalCertificate0(DigitalCertificateSecurityUpdateRequest req) throws ValidationException {
-        validationHelper.validateTillFirstErrorAndThrow(req, validation.digitalCertificateUpdateValidator());
-
-        DigitalCertificateSecurity digitalCertificate = digitalCertificateSecurityImdg.getSingleObjectByID(req.getId());
-        Instant updateTime = Instant.now();
-        digitalCertificate.setUpdated(updateTime);
-        digitalCertificate.setSecuritySymbol(StringUtils.hasText(req.getSecuritySymbol()) ? req.getSecuritySymbol().trim() : null);
-        digitalCertificate.setShortName(req.getShortName());
-        digitalCertificate.setFullName(req.getFullName());
-        digitalCertificate.setIssuerId(req.getIssuerId());
-        digitalCertificate.setShortNameEng(req.getShortNameEng());
-        digitalCertificate.setFullNameEng(req.getFullNameEng());
-        if (req.getWorkflowStatus() != null) {
-            digitalCertificate.setWorkflowStatus(req.getWorkflowStatus());
-        }
-        digitalCertificate.setInstrumentType(req.getInstrumentType());
-        digitalCertificate.setBaseCode(req.getBaseCode());
-        digitalCertificate.setBaseUnitSize(req.getBaseUnitSize());
-        digitalCertificate.setPriceVarianceLimit(req.getPriceVarianceLimit());
-        digitalCertificate.setNominalTypeCode(req.getNominalTypeCode());
-        digitalCertificate.setNominalValue(req.getNominalValue());
-        digitalCertificate.setNominalIndexationDate(req.getNominalIndexationDate());
-        digitalCertificate.setNominalIndexationSign(req.getNominalIndexationSign());
-        digitalCertificate.setSettlementHouse(req.getSettlementHouse());
-        digitalCertificate.setDepository(req.getDepository());
-        digitalCertificate.setInstrumentType(req.getInstrumentType());
-
-        digitalCertificateSecurityImdg.update(digitalCertificate);
-        return digitalCertificate;
-    }
-
     private RequestInfoUpdate deleteDigitalCertificate(BaseRequest<CommonDeleteRequest> userRequest) {
         log.debug("CommonDeleteRequest received id = {}", userRequest.getId());
         try {
             userRoleVerification.validateRoleAndThrow(userRequest);
-            Long digitalCertificateId = deleteDigitalCertificate0(userRequest.getRequestPayload());
+            CommonDeleteRequest req = userRequest.getRequestPayload();
-            log.debug("successfully processed, request id {}, delete object id {}", userRequest.getId(), digitalCertificateId);
+            validationHelper.validateTillFirstErrorAndThrow(req, validation.digitalCertificateDeleteValidator());
+            digitalCertificateSecurityFacade.deleteDigitalCertificate(req);
             return null;
         } catch (ValidationException e) {
             return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
         }
     }
-
-    protected synchronized Long deleteDigitalCertificate0(CommonDeleteRequest req) throws ValidationException {
-        validationHelper.validateTillFirstErrorAndThrow(req, validation.digitalCertificateDeleteValidator());
-
-        Instant updateTime = Instant.now();
-        DigitalCertificateSecurity digitalCertificate = digitalCertificateSecurityImdg.getSingleObjectByID(req.getId());
-        digitalCertificate.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
-        digitalCertificate.setUpdated(updateTime);
-        digitalCertificateSecurityImdg.update(digitalCertificate);
-
-        return digitalCertificate.getId();
-    }
-
 }

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

@@ -28,12 +28,12 @@ import ru.clearing.platform.dictionary.CurrencyPairDictionary;
 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.DigitalCertificateSecurityGatewayRequest;
 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.CouponPeriodNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodUpdateRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertificateSecurityGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertificateSecurityNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertificateSecurityUpdateRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.EquitySecurityNewRequest;
@@ -52,6 +52,9 @@ import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecu
 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.service.facade.DigitalCertificateSecurityFacade;
+import ru.spcex.clearing.securities.service.facade.ListingFacade;
+import ru.spcex.clearing.securities.validation.ListingValidationProvider;
 import ru.spcex.clearing.securities.validation.ValidationProvider;
 import ru.spcex.clearing.util.security.UserRoleVerification;
 import ru.spcex.clearing.util.services.RequestHelper;
@@ -65,6 +68,7 @@ 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.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.error.ValidationException;
 
@@ -90,7 +94,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
     private final EquitySecurityService equitySecurityService;
     private final MoneyMarketSecurityService moneyMarketSecurityService;
     private final CurrencyPairSecurityService currencyPairSecurityService;
-    private final ListingService listingService;
+    private final ListingFacade listingFacade;
     private final CouponPeriodService couponPeriodService;
     private final FixedIncomeCashFlowService fixedIncomeCashFlowService;
     private final DigitalCertificateSecurityService digitalCertificateSecurityService;
@@ -100,6 +104,9 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
     private final ValidationHelper validationHelper;
     private final IMessageResolver messageResolver;
     private final RequestHelper requestHelper;
+    private final DigitalCertificateSecurityFacade digitalCertificateSecurityFacade;
+    private final ListingValidationProvider listingValidation;
+    private final SecuritySelector<Security> securitySelector;
 
     @Autowired
     public GatewaySecurityService(Consumer<String, Object> kafkaQueue,
@@ -115,10 +122,13 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
                                   EquitySecurityService equitySecurityService,
                                   MoneyMarketSecurityService moneyMarketSecurityService,
                                   CurrencyPairSecurityService currencyPairSecurityService,
-                                  ListingService listingService,
+                                  ListingFacade listingFacade,
                                   CouponPeriodService couponPeriodService,
                                   FixedIncomeCashFlowService fixedIncomeCashFlowService,
-                                  DigitalCertificateSecurityService digitalCertificateSecurityService) {
+                                  DigitalCertificateSecurityService digitalCertificateSecurityService,
+                                  DigitalCertificateSecurityFacade digitalCertificateSecurityFacade,
+                                  ListingValidationProvider listingValidation,
+                                  SecuritySelector<Security> securitySelector) {
         super(kafkaQueue, kafkaProducer);
         this.validation = validation;
         this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
@@ -143,10 +153,13 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
         this.fixedIncomeSecurityService = fixedIncomeSecurityService;
         this.equitySecurityService = equitySecurityService;
         this.moneyMarketSecurityService = moneyMarketSecurityService;
-        this.listingService = listingService;
+        this.listingFacade = listingFacade;
         this.couponPeriodService = couponPeriodService;
         this.fixedIncomeCashFlowService = fixedIncomeCashFlowService;
         this.digitalCertificateSecurityService = digitalCertificateSecurityService;
+        this.digitalCertificateSecurityFacade = digitalCertificateSecurityFacade;
+        this.listingValidation = listingValidation;
+        this.securitySelector = securitySelector;
     }
 
     @Override
@@ -157,8 +170,8 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
         callback(EquitySecurityGatewayRequest.class)
                 .setFunction(this::newSecurities)
                 .forDestination(Consts.DESTINATION_SECURITY_EQTY_GATEWAY, callbacks::put);
-        callback(EquitySecurityGatewayRequest.class)
+        callback(DigitalCertificateSecurityGatewayRequest.class)
-                .setFunction(this::newSecurities)
+                .setFunction(this::newDigitalSecurities)
              .forDestination(Consts.DESTINATION_SECURITY_DGCT_GATEWAY, callbacks::put);
         callback(MoneyMarketSecurityNewGatewayRequest.class)
                 .setFunction(this::newMoneyMarketSecurity)
@@ -275,12 +288,14 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
                     Listing existListing = findListing(listingReq);
                     if (existListing == null) {
                         log.trace("For currency pair security[{}] do new Listing", securityId);
-                        Listing listing = listingService.newListing0(listingReq);
+                        validationHelper.validateTillFirstErrorAndThrow(listingReq, listingValidation.listingNewValidator());
+                        Listing listing = listingFacade.newListing(listingReq);
                         log.debug("New listing.id={}", listing.getId());
                     } else {
                         log.trace("For currency pair security[{}] do update Listing[{}]", securityId, existListing.getId());
                         ListingUpdateRequest partUpdateRequest = toUpdateRequest(existListing, listingReq);
-                        Listing listing = listingService.updateListing0(partUpdateRequest);
+                        validationHelper.validateTillFirstErrorAndThrow(partUpdateRequest, listingValidation.listingUpdateValidator());
+                        Listing listing = listingFacade.updateListing(partUpdateRequest);
                         log.debug("Has updated listing.id={}", listing.getId());
                     }
                 }
@@ -361,26 +376,6 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
                     security = equitySecurityService.updateEquity0(updateRequest);
                 }
             }
-            if (InstrumentType.DGCT.equalsByKey(req.getSecurityType())) {
-                DigitalCertificateSecurityGatewayRequest digitalCertificateSecurityGatewayRequest = (DigitalCertificateSecurityGatewayRequest) req;
-                DigitalCertificateSecurityNewRequest newRequest = digitalCertificateSecurityGatewayRequest.getSecurity();
-                if (StringUtils.isEmpty(newRequest.getSecuritySymbol())) {
-                    log.warn("Skip creating digitalCertificateSecurity without securityId: uuid: {}", req.getUuid());
-                    return null;
-                }
-                log.debug("Processed request with securitySymbol: {}", newRequest.getSecuritySymbol());
-                newRequest.setIssuerId(companyId);
-                log.trace("DigitalCertificateSecurityNewRequest - FOND");
-                String securitySymbol = newRequest.getSecuritySymbol();
-                security = findSecurityBySecuritySymbol(digitalCertificateSecurityImdg, securitySymbol);
-
-                if (security == null) {
-                    security = digitalCertificateSecurityService.newDigitalCertificate0(newRequest);
-                } else {
-                    DigitalCertificateSecurityUpdateRequest updateRequest = toUpdateRequest(security, newRequest);
-                    security = digitalCertificateSecurityService.updateDigitalCertificate0(updateRequest);
-                }
-            }
             if (InstrumentType.CRNC.equalsByKey(req.getSecurityType())) {
                 throw new IllegalStateException("CRNC support in other function"); // см. другой метод.
             }
@@ -416,13 +411,15 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
                 partRequest.setSecurityId(securityId);
                 Listing existListing = findListing(partRequest);
                 if (existListing == null) {
+                    validationHelper.validateTillFirstErrorAndThrow(partRequest, listingValidation.listingNewValidator());
                     log.trace("For company[{}] do new Listing", companyId);
-                    Listing listing = listingService.newListing0(partRequest);
+                    Listing listing = listingFacade.newListing(partRequest);
                     log.debug("New listing.id={}", listing.getId());
                 } else {
                     log.trace("For company[{}] do update Listing[{}]", companyId, existListing.getId());
                     ListingUpdateRequest partUpdateRequest = toUpdateRequest(existListing, partRequest);
-                    Listing listing = listingService.updateListing0(partUpdateRequest);
+                    validationHelper.validateTillFirstErrorAndThrow(partUpdateRequest, listingValidation.listingUpdateValidator());
+                    Listing listing = listingFacade.updateListing(partUpdateRequest);
                     log.debug("Has updated listing.id={}", listing.getId());
                 }
             } catch (ValidationException expected) {
@@ -479,6 +476,63 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
         return null; // default success
     }
 
+    private RequestInfoUpdate newDigitalSecurities(BaseRequest<DigitalCertificateSecurityGatewayRequest> baseRequest) {
+        DigitalCertificateSecurityGatewayRequest request = baseRequest.getRequestPayload();
+        DigitalCertificateSecurityNewRequest newRequest = new DigitalCertificateSecurityNewRequest();
+        newRequest.setBaseCode(request.getDepoDcId());
+        newRequest.setInstrumentType(request.getInstrumentType());
+
+        Map<String, Comparable<?>> query = new HashMap<>();
+        query.put("companySymbol", CompanySymbol.UUID.getKey());
+        query.put("companySymbolValue", request.getIssuerId());
+
+        CompanySymbols companySymbols = companySymbolsImdg.getSingleObjectByFieldValues(query);
+        Long companyId = companySymbols.getCompanyId();
+        newRequest.setIssuerId(companyId);
+
+        newRequest.setShortName(request.getShortName());
+        newRequest.setFullName(request.getFullName());
+        newRequest.setShortNameEng(request.getShortNameEng());
+        newRequest.setFullNameEng(request.getFullNameEng());
+        newRequest.setBaseUnitSize(request.getNumberOfUcp().longValue());
+        newRequest.setPriceVarianceLimit(request.getDeltaPrice());
+        newRequest.setSecuritySymbol(request.getSecuritySymbol());
+        newRequest.setWorkflowStatus(request.getWorkflowStatus());
+        newRequest.setNominalTypeCode(request.getTypeCode());
+        newRequest.setSettlementHouse(request.getSettlementOrganization());
+        newRequest.setDepository(request.getSettlementDepository());
+        newRequest.setNominalIndexationDate(request.getNominalIndexDate());
+        newRequest.setNominalValue(request.getNominalDenominationUnitForDate());
+        newRequest.setNominalIndexationSign(request.getNominalIndexFact());
+
+        digitalCertificateSecurityFacade.newDigitalCertificate(newRequest);
+
+        Security security = securitySelector.selectSecurityBySymbol(request.getSecuritySymbol());
+        Long securityId = security.getId();
+        for (ListingNewRequest listingReq : request.getListing()) {
+            try {
+                listingReq.setSecurityId(securityId);
+                Listing existListing = findListing(listingReq);
+                if (existListing == null) {
+                    validationHelper.validateTillFirstErrorAndThrow(listingReq, listingValidation.listingNewValidator());
+                    log.trace("For company[{}] do new Listing", companyId);
+                    Listing listing = listingFacade.newListing(listingReq);
+                    log.debug("New listing.id={}", listing.getId());
+                } else {
+                    log.trace("For company[{}] do update Listing[{}]", companyId, existListing.getId());
+                    ListingUpdateRequest partUpdateRequest = toUpdateRequest(existListing, listingReq);
+                    validationHelper.validateTillFirstErrorAndThrow(partUpdateRequest, listingValidation.listingUpdateValidator());
+                    Listing listing = listingFacade.updateListing(partUpdateRequest);
+                    log.debug("Has updated listing.id={}", listing.getId());
+                }
+            } catch (ValidationException expected) {
+                log.warn("At request {} for securityId={} has error when create or update listing: {}",
+                    baseRequest.getId(), securityId, messageResolver.resolve(expected.getEnumMsg()));
+            }
+        }
+
+        return null;
+    }
     Listing findListing(ListingNewRequest byRequest) {
         Map<String, Comparable<?>> query = new HashMap<>();
         query.put("securityId", byRequest.getSecurityId());

clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/facade/DigitalCertificateSecurityFacade.java

@@ -0,0 +1,102 @@
+package ru.spcex.clearing.securities.service.facade;
+
+import java.time.Instant;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import ru.clearing.classes.statics.data.security.DigitalCertificateSecurity;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertificateSecurityNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.DigitalCertificateSecurityUpdateRequest;
+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;
+
+@Service
+public class DigitalCertificateSecurityFacade {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final ImdgId idGenerator;
+    private final ImdgProvider imdgProvider;
+    private final Imdg<DigitalCertificateSecurity> digitalCertificateSecurityImdg;
+
+    public DigitalCertificateSecurityFacade(ImdgProvider imdgProvider) {
+        this.idGenerator = imdgProvider.getImdgIdGenerator();
+        this.imdgProvider = imdgProvider;
+        this.digitalCertificateSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DigitalCertificateSecurity, DigitalCertificateSecurity.class);
+    }
+
+    public DigitalCertificateSecurity newDigitalCertificate(DigitalCertificateSecurityNewRequest req) {
+        log.debug("DigitalCertificateSecurityNewRequest received");
+        DigitalCertificateSecurity digitalCertificate = new DigitalCertificateSecurity();
+        digitalCertificate.setId(idGenerator.nextId());
+        digitalCertificate.setSecuritySymbol(StringUtils.hasText(req.getSecuritySymbol()) ? req.getSecuritySymbol().trim() : null);
+        digitalCertificate.setShortName(req.getShortName());
+        digitalCertificate.setFullName(req.getFullName());
+        digitalCertificate.setIssuerId(req.getIssuerId());
+        digitalCertificate.setShortNameEng(req.getShortNameEng());
+        digitalCertificate.setFullNameEng(req.getFullNameEng());
+        if (req.getWorkflowStatus() == null) {
+            digitalCertificate.setWorkflowStatus(WorkflowStatus.Active.getKey());
+        } else {
+            digitalCertificate.setWorkflowStatus(req.getWorkflowStatus());
+        }
+        digitalCertificate.setInstrumentType(req.getInstrumentType());
+        digitalCertificate.setSecurityId(digitalCertificate.getId());
+        digitalCertificate.setCreated(Instant.now());
+        digitalCertificate.setUpdated(digitalCertificate.getCreated());
+        digitalCertificate.setBaseCode(req.getBaseCode());
+        digitalCertificate.setBaseUnitSize(req.getBaseUnitSize());
+        digitalCertificate.setPriceVarianceLimit(req.getPriceVarianceLimit());
+        digitalCertificate.setNominalTypeCode(req.getNominalTypeCode());
+        digitalCertificate.setNominalValue(req.getNominalValue());
+        digitalCertificate.setNominalIndexationDate(req.getNominalIndexationDate());
+        digitalCertificate.setNominalIndexationSign(req.getNominalIndexationSign());
+        digitalCertificate.setSettlementHouse(req.getSettlementHouse());
+        digitalCertificate.setDepository(req.getDepository());
+        digitalCertificateSecurityImdg.insert(digitalCertificate);
+        log.debug("successfully processed new digital_certificate_security.id {}", digitalCertificate.getId());
+        return digitalCertificate;
+    }
+    public DigitalCertificateSecurity updateDigitalCertificate(DigitalCertificateSecurityUpdateRequest req) {
+        DigitalCertificateSecurity digitalCertificate = digitalCertificateSecurityImdg.getSingleObjectByID(req.getId());
+        Instant updateTime = Instant.now();
+        digitalCertificate.setUpdated(updateTime);
+        digitalCertificate.setSecuritySymbol(StringUtils.hasText(req.getSecuritySymbol()) ? req.getSecuritySymbol().trim() : null);
+        digitalCertificate.setShortName(req.getShortName());
+        digitalCertificate.setFullName(req.getFullName());
+        digitalCertificate.setIssuerId(req.getIssuerId());
+        digitalCertificate.setShortNameEng(req.getShortNameEng());
+        digitalCertificate.setFullNameEng(req.getFullNameEng());
+        if (req.getWorkflowStatus() != null) {
+            digitalCertificate.setWorkflowStatus(req.getWorkflowStatus());
+        }
+        digitalCertificate.setInstrumentType(req.getInstrumentType());
+        digitalCertificate.setBaseCode(req.getBaseCode());
+        digitalCertificate.setBaseUnitSize(req.getBaseUnitSize());
+        digitalCertificate.setPriceVarianceLimit(req.getPriceVarianceLimit());
+        digitalCertificate.setNominalTypeCode(req.getNominalTypeCode());
+        digitalCertificate.setNominalValue(req.getNominalValue());
+        digitalCertificate.setNominalIndexationDate(req.getNominalIndexationDate());
+        digitalCertificate.setNominalIndexationSign(req.getNominalIndexationSign());
+        digitalCertificate.setSettlementHouse(req.getSettlementHouse());
+        digitalCertificate.setDepository(req.getDepository());
+        digitalCertificate.setInstrumentType(req.getInstrumentType());
+
+        digitalCertificateSecurityImdg.update(digitalCertificate);
+        log.debug("successfully processed updated digital_certificate_security.id {}", digitalCertificate.getId());
+        return digitalCertificate;
+    }
+
+    public Long deleteDigitalCertificate(CommonDeleteRequest req) {
+        Instant updateTime = Instant.now();
+        DigitalCertificateSecurity digitalCertificate = digitalCertificateSecurityImdg.getSingleObjectByID(req.getId());
+        digitalCertificate.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
+        digitalCertificate.setUpdated(updateTime);
+        digitalCertificateSecurityImdg.update(digitalCertificate);
+        log.debug("successfully processed delete object id {}", digitalCertificate.getId());
+        return digitalCertificate.getId();
+    }
+}

clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/facade/ListingFacade.java

@@ -0,0 +1,97 @@
+package ru.spcex.clearing.securities.service.facade;
+
+import java.time.Instant;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.misc.Listing;
+import ru.clearing.classes.statics.data.security.Security;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.ListingNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.ListingUpdateRequest;
+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.imdg.api.predicate.specific.SecuritySelector;
+
+@Service
+public class ListingFacade {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final SecuritySelector<Security> securitySelector;
+    private final ImdgProvider imdgProvider;
+    private final ImdgId idGenerator;
+    private final Imdg<Listing> listingImdg;
+
+    public ListingFacade(SecuritySelector<Security> securitySelector, ImdgProvider imdgProvider) {
+        this.securitySelector = securitySelector;
+        this.imdgProvider = imdgProvider;
+        this.idGenerator = imdgProvider.getImdgIdGenerator();
+        this.listingImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
+    }
+
+    public Listing newListing(ListingNewRequest req) {
+        Security security = securitySelector.selectSecurityById(req.getSecurityId());
+        if (security == null) { // never
+            log.error("Security not found {}", req.getSecurityId());
+        }
+
+        Listing listing = new Listing();
+        listing.setId(idGenerator.nextId());
+        listing.setCreated(Instant.now());
+        listing.setUpdated(listing.getCreated());
+        listing.setSecurityId(req.getSecurityId());
+        listing.setMarket(req.getMarket());
+        listing.setLotSize(req.getLotSize());
+        if (req.getSymbolCode() != null) {
+            listing.setSymbolCode(req.getSymbolCode()); // listing.setSymbolCode(req.getSymbolCode());
+        } else {
+            if (security != null)
+                listing.setSymbolCode(security.getSecuritySymbol());
+        }
+        if (req.getSymbolName() != null) {
+            listing.setSymbolName(req.getSymbolName()); // api-gateway
+        } else {
+            if (security != null)
+                listing.setSymbolName(security.getFullName()); // req.getSymbolName
+        }
+        listing.setTradingCurrency(req.getTradingCurrency());
+        if (StringUtils.isEmpty(req.getWorkflowStatus())) {
+            listing.setWorkflowStatus(WorkflowStatus.Active.getKey());
+        } else {
+            listing.setWorkflowStatus(req.getWorkflowStatus());
+        }
+        listing.setMinStep(req.getMinStep());
+        listing.setPrecision(req.getPrecision());
+
+        listingImdg.insert(listing);
+        return listing;
+    }
+
+    public Listing updateListing(ListingUpdateRequest req) {
+        Listing listing = listingImdg.getSingleObjectByID(req.getId());
+
+        Security security = securitySelector.selectSecurityById(req.getSecurityId());
+        if (security == null) { // never
+            log.error("Security not found {}", req.getSecurityId());
+        }
+        if (listing == null) { //never
+            log.error("listing not found {}", req.getId());
+        }
+
+        listing.setUpdated(Instant.now());
+        listing.setLotSize(req.getLotSize());
+        if (req.getSymbolCode() != null) listing.setSymbolCode(req.getSymbolCode());
+        if (req.getSymbolName() != null) listing.setSymbolName(req.getSymbolName());
+        listing.setTradingCurrency(req.getTradingCurrency());
+        if (StringUtils.isNotEmpty(req.getWorkflowStatus())) {
+            listing.setWorkflowStatus(req.getWorkflowStatus());
+        }
+        if (req.getMinStep() != null) listing.setMinStep(req.getMinStep());
+        if (req.getPrecision() != null) listing.setPrecision(req.getPrecision());
+
+        listingImdg.update(listing);
+        return listing;
+    }
+}

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

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

platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/DigitalCertificateSecurityGatewayRequest.java

@@ -0,0 +1,198 @@
+package ru.spcex.clearing.platform.messaging.domain.cud.securitites;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
+import ru.spcex.platform.classes.base.interfaces.WithInstrumentType;
+import ru.spcex.platform.classes.base.interfaces.WithSecuritySymbol;
+
+public class DigitalCertificateSecurityGatewayRequest implements WithSecuritySymbol, WithInstrumentType {
+    @JsonProperty
+    private String depoDcId;
+    @JsonProperty
+    private String instrumentType;
+    @JsonProperty
+    private UUID issuerId;
+    @JsonProperty
+    private String shortName;
+    @JsonProperty
+    private String fullName;
+    @JsonProperty
+    private String shortNameEng;
+    @JsonProperty
+    private String fullNameEng;
+    @JsonProperty
+    private BigDecimal numberOfUcp;
+    @JsonProperty
+    private BigDecimal deltaPrice;
+    @JsonProperty
+    private String securitySymbol;
+    @JsonProperty
+    private String workflowStatus;
+    @JsonProperty
+    private String typeCode;
+    @JsonProperty
+    private String settlementOrganization;
+    @JsonProperty
+    private String settlementDepository;
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonProperty
+    private LocalDate nominalIndexDate;
+    @JsonProperty
+    private BigDecimal nominalDenominationUnitForDate;
+    @JsonProperty
+    private String nominalIndexFact;
+    @JsonProperty
+    private List<ListingNewRequest> listing = new ArrayList<>();
+
+    public String getDepoDcId() {
+        return depoDcId;
+    }
+
+    public void setDepoDcId(String depoDcId) {
+        this.depoDcId = depoDcId;
+    }
+
+    @Override
+    public String getInstrumentType() {
+        return instrumentType;
+    }
+
+    public void setInstrumentType(String instrumentType) {
+        this.instrumentType = instrumentType;
+    }
+
+    public UUID getIssuerId() {
+        return issuerId;
+    }
+
+    public void setIssuerId(UUID issuerId) {
+        this.issuerId = issuerId;
+    }
+
+    public String getShortName() {
+        return shortName;
+    }
+
+    public void setShortName(String shortName) {
+        this.shortName = shortName;
+    }
+
+    public String getFullName() {
+        return fullName;
+    }
+
+    public void setFullName(String fullName) {
+        this.fullName = fullName;
+    }
+
+    public String getShortNameEng() {
+        return shortNameEng;
+    }
+
+    public void setShortNameEng(String shortNameEng) {
+        this.shortNameEng = shortNameEng;
+    }
+
+    public String getFullNameEng() {
+        return fullNameEng;
+    }
+
+    public void setFullNameEng(String fullNameEng) {
+        this.fullNameEng = fullNameEng;
+    }
+
+    public BigDecimal getNumberOfUcp() {
+        return numberOfUcp;
+    }
+
+    public void setNumberOfUcp(BigDecimal numberOfUcp) {
+        this.numberOfUcp = numberOfUcp;
+    }
+
+    public BigDecimal getDeltaPrice() {
+        return deltaPrice;
+    }
+
+    public void setDeltaPrice(BigDecimal deltaPrice) {
+        this.deltaPrice = deltaPrice;
+    }
+
+    @Override
+    public String getSecuritySymbol() {
+        return securitySymbol;
+    }
+
+    public void setSecuritySymbol(String securitySymbol) {
+        this.securitySymbol = securitySymbol;
+    }
+
+    public String getWorkflowStatus() {
+        return workflowStatus;
+    }
+
+    public void setWorkflowStatus(String workflowStatus) {
+        this.workflowStatus = workflowStatus;
+    }
+
+    public String getTypeCode() {
+        return typeCode;
+    }
+
+    public void setTypeCode(String typeCode) {
+        this.typeCode = typeCode;
+    }
+
+    public String getSettlementOrganization() {
+        return settlementOrganization;
+    }
+
+    public void setSettlementOrganization(String settlementOrganization) {
+        this.settlementOrganization = settlementOrganization;
+    }
+
+    public String getSettlementDepository() {
+        return settlementDepository;
+    }
+
+    public void setSettlementDepository(String settlementDepository) {
+        this.settlementDepository = settlementDepository;
+    }
+
+    public LocalDate getNominalIndexDate() {
+        return nominalIndexDate;
+    }
+
+    public void setNominalIndexDate(LocalDate nominalIndexDate) {
+        this.nominalIndexDate = nominalIndexDate;
+    }
+
+    public BigDecimal getNominalDenominationUnitForDate() {
+        return nominalDenominationUnitForDate;
+    }
+
+    public void setNominalDenominationUnitForDate(BigDecimal nominalDenominationUnitForDate) {
+        this.nominalDenominationUnitForDate = nominalDenominationUnitForDate;
+    }
+
+    public String getNominalIndexFact() {
+        return nominalIndexFact;
+    }
+
+    public void setNominalIndexFact(String nominalIndexFact) {
+        this.nominalIndexFact = nominalIndexFact;
+    }
+
+    public List<ListingNewRequest> getListing() {
+        return listing;
+    }
+
+    public void setListing(List<ListingNewRequest> listing) {
+        this.listing = listing;
+    }
+}