SendMessageToCompanyServiceWithMemberCompanies

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

@@ -10,9 +10,11 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.company.ProfileDocumentNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.company.ProfileDocumentUpdateRequest;
-import ru.spcex.clearing.validation.common.rules.*;
+import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
+import ru.spcex.clearing.validation.common.rules.EndDtAfterStartDtRule;
+import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
+import ru.spcex.clearing.validation.common.rules.IdPresentRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
-import ru.spcex.platform.enumeration.DocumentTypes;
 import ru.spcex.platform.enumeration.WorkflowStatus;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.validation.ImdgValidationContext;
@@ -57,23 +59,18 @@ public class ProfileDocumentValidationConfig {
                     FieldRequiredRule.instance("issuer",
                             ProfileDocumentNewRequest::getIssuer,
                             CompanyErrors.RequiredFieldEmpty),
-                    FieldRequiredRule.instance("issuerCode",
-                            ProfileDocumentNewRequest::getIssuerCode,
-                            CompanyErrors.RequiredFieldEmpty),
-                    FieldRequiredRule.instance("name",
-                            ProfileDocumentNewRequest::getName,
-                            CompanyErrors.RequiredFieldEmpty),
                     FieldRequiredRule.instance("number",
                             ProfileDocumentNewRequest::getNumber,
                             CompanyErrors.RequiredFieldEmpty),
-                    FieldRequiredRule.instance("place",
+                    FieldRequiredRule.instance("validToDate",
-                            ProfileDocumentNewRequest::getPlace,
+                            ProfileDocumentNewRequest::getValidToDate,
                             CompanyErrors.RequiredFieldEmpty),
                     EndDtAfterStartDtRule.instance("validFromDate", "validToDate",
                             ProfileDocumentNewRequest::getValidFromDate,
                             ProfileDocumentNewRequest::getValidToDate,
                             CompanyErrors.RequiredFieldEmpty,
-                            CompanyErrors.WrongFieldValue)
+                            CompanyErrors.WrongFieldValue,
+                            false)
             );
         };
     }

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

@@ -22,8 +22,8 @@ public class PipelineConfiguration {
         pipeline.add(new ValidateIssuerCompanies());
         pipeline.add(new CheckFondSecurityExist(imdgProvider));
         pipeline.add(new CheckIssuerCompanyExist(imdgProvider));
-        pipeline.add(new SendMessageToCompanyService(kafkaSender, imdgProvider));
+        pipeline.add(new SendMessageToCompanyServiceWithIssuerCompanies(kafkaSender, imdgProvider));
-        pipeline.add(new SendMessageToSecurityService(kafkaSender, imdgProvider));
+        pipeline.add(new SendMessageToSecurityServiceWithFondSecurities(kafkaSender, imdgProvider));
         return pipeline;
     }
 

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/companies/CheckMemberCompanyExist.java

@@ -2,7 +2,7 @@ package ru.spcex.clearing.gatewayapi.logic.companies;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ru.clearing.classes.statics.data.account.ClientCode;
+import ru.clearing.classes.statics.data.account.*;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.company.CompanySymbols;
 import ru.clearing.classes.statics.data.profile.Contact;
@@ -29,6 +29,10 @@ public class CheckMemberCompanyExist extends Stage<CompaniesRequestParam> {
     private final Imdg<Contact> contactImdg;
     private final Imdg<ProfileDocument> profileDocumentImdg;
     private final Imdg<ClientCode> clientCodeImdg;
+    private final Imdg<Account> accountImdg;
+    private final Imdg<ClearingAccount> clearingAccountImdg;
+    private final Imdg<InformationAccount> informationAccountImdg;
+    private final Imdg<DepoAccount> depoAccountImdg;
 
     public CheckMemberCompanyExist(ImdgProvider imdgProvider) {
         companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
@@ -36,6 +40,10 @@ public class CheckMemberCompanyExist extends Stage<CompaniesRequestParam> {
         contactImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Contact, Contact.class);
         profileDocumentImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ProfileDocument, ProfileDocument.class);
         clientCodeImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
+        accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
+        informationAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class);
+        depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, DepoAccount.class);
     }
 
 
@@ -239,6 +247,9 @@ public class CheckMemberCompanyExist extends Stage<CompaniesRequestParam> {
                         memberClient.setAlreadyExist(true);
                         memberClient.setMapId(clientCode.getId());
                     }
+
+                    // Определяем соответствующие moneyAccount id из clearingAccount/informationAccount
+                    fillMemberClientMoneyOrDepoAccountId(company, memberClient);
                 }
             }
 
@@ -254,4 +265,58 @@ public class CheckMemberCompanyExist extends Stage<CompaniesRequestParam> {
 
         return null;
     }
+
+    private void fillMemberClientMoneyOrDepoAccountId(MemberCompany company, MemberClient client) {
+        String moneyAccount = client.getMoneyAccount();
+        Collection<Account> accountFromImdg = accountImdg.getCollectionObjectsByFieldValues(
+                Map.of("account", moneyAccount)
+        );
+        if (!accountFromImdg.isEmpty()) {
+            Account account = accountFromImdg.iterator().next();
+            if (accountFromImdg.size() > 1) {
+                log.warn("for client (company.UUID {}) for money_account {} found accounts > 1, use first (id = {})",
+                        company.getId(),
+                        moneyAccount,
+                        account.getId());
+            }
+            Long moneyAccountId = null;
+            InformationAccount informationAccount = informationAccountImdg.getSingleObjectByFieldValues(
+                    Map.of("accountId", account.getId())
+            );
+            if (informationAccount == null) {
+                ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByFieldValues(
+                        Map.of("accountId", account.getId())
+                );
+                if (clearingAccount != null) {
+                    moneyAccountId = clearingAccount.getId();
+                }
+            } else {
+                moneyAccountId = informationAccount.getId();
+            }
+            client.setMoneyAccountId(moneyAccountId);
+            return;
+        }
+
+        String depoAccountValue = client.getDepoAccount();
+        accountFromImdg = accountImdg.getCollectionObjectsByFieldValues(
+                Map.of("account", depoAccountValue)
+        );
+        if (!accountFromImdg.isEmpty()) {
+            Account account = accountFromImdg.iterator().next();
+            if (!accountFromImdg.isEmpty()) {
+                if (accountFromImdg.size() > 1) {
+                    log.warn("for client (company.UUID {}) for depo_account {} found accounts > 1, use first (id = {})",
+                            company.getId(),
+                            depoAccountValue,
+                            account.getId());
+                }
+                DepoAccount depoAccount = depoAccountImdg.getSingleObjectByFieldValues(
+                        Map.of("accountId", account.getId())
+                );
+                if (depoAccount != null) {
+                    client.setDepoAccountId(depoAccount.getId());
+                }
+            }
+        }
+    }
 }

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/companies/SendMessageToCompanyServiceWithMemberCompanies.java

@@ -0,0 +1,175 @@
+package ru.spcex.clearing.gatewayapi.logic.companies;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
+import ru.spcex.clearing.gatewayapi.logic.Stage;
+import ru.spcex.clearing.gatewayapi.request.objects.*;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeUpdateRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.company.*;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.platform.enumeration.CompanySymbol;
+import ru.spcex.platform.enumeration.ServiceStatus;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.IEnumKey;
+
+import java.util.List;
+import java.util.Map;
+
+public class SendMessageToCompanyServiceWithMemberCompanies extends Stage<CompaniesRequestParam> {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private final KafkaSender kafkaSender;
+    private final Imdg<Company> companyImdg;
+
+    public SendMessageToCompanyServiceWithMemberCompanies(KafkaSender kafkaSender, ImdgProvider imdgProvider) {
+        this.kafkaSender = kafkaSender;
+        this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+    }
+    @Override
+    public ProcessResult process(CompaniesRequestParam param) {
+        List<MemberCompany> companyList = param.getMemberCompanyList();
+        for (MemberCompany company : companyList) {
+            if (company.isInvalidData()) continue;
+
+            String companyWorkflowStatus = WorkflowStatus.Active.getKey();
+            if (!company.getCompanyClearingCategoryList().isEmpty()) {
+                MemberCompanyClearingCategory clearingCategory = company.getCompanyClearingCategoryList().get(0);
+                ServiceStatus categoryStatus = IEnumKey.getEnumByKey(ServiceStatus.class, clearingCategory.getWorkflowStatus());
+                if (categoryStatus == ServiceStatus.Active || categoryStatus == ServiceStatus.Appl || categoryStatus == ServiceStatus.Reopened) {
+                    companyWorkflowStatus = WorkflowStatus.Active.getKey();
+                } else {
+                    companyWorkflowStatus = WorkflowStatus.Blocked.getKey();
+                }
+            }
+
+            CompanyNewRequest companyNewRequest = new CompanyNewRequest();
+            if (company.isAlreadyExist()) companyNewRequest.setId(company.getMapId());
+            companyNewRequest.setShortName(company.getShortName());
+            companyNewRequest.setFullName(company.getFullName());
+            companyNewRequest.setCompanySymbol(CompanySymbol.UUID.getKey());
+            companyNewRequest.setCompanySymbolValue(company.getId().toString());
+
+            MemberCompanyInfo companyInfo = company.getCompanyInfo();
+
+            if (company.isAlreadyExist()) {
+                kafkaSender.sendRequestToQueue(Consts.DESTINATION_COMPANY_UPDATE, companyNewRequest);
+            } else {
+                kafkaSender.sendToQueueWaitForAnswer(Consts.DESTINATION_COMPANY_NEW, companyNewRequest);
+                Company companyFromImdg = companyImdg.getSingleObjectByFieldValues(
+                        Map.of(
+                                "shortName", company.getShortName(),
+                                "fullName", company.getFullName(),
+                                "workflowStatus", companyWorkflowStatus
+                        )
+                );
+                if (companyFromImdg == null) {
+                    log.warn("Can't insert company (UUID {}), skipped", company.getId());
+                    company.setInvalidData(true);
+                    continue;
+                }
+                company.setAlreadyExist(true);
+                company.setMapId(companyFromImdg.getId());
+            }
+            Long companyId = company.getMapId();
+
+            CompanyInfoUpdateRequest companyInfoUpdateRequest = new CompanyInfoUpdateRequest();
+            companyInfoUpdateRequest.setId(companyId);
+            companyInfoUpdateRequest.setCountryCode("RUS"); // todo в текущей версии ТЗ присылается в цифровом обозначении
+            companyInfoUpdateRequest.setProfessionalSign(companyInfo.getProfessionalSign());
+            companyInfoUpdateRequest.setLegalKind(companyInfo.getLegalKind());
+            companyInfoUpdateRequest.setOrganizationType(companyInfo.getOrganizationType());
+            companyInfoUpdateRequest.setResidence(companyInfo.getResidence());
+            kafkaSender.sendRequestToQueue(Consts.DESTINATION_COMPANY_UPDATE, companyInfoUpdateRequest);
+
+            for (MemberCompanySymbols companySymbols : company.getMemberCompanySymbolsList()) {
+                if (companySymbols.isInvalidData()) continue;
+                if (!company.isAlreadyExist() || !companySymbols.isAlreadyExist()) {
+                    CompanySymbolNewRequest companySymbolNewRequest = new CompanySymbolNewRequest();
+                    companySymbolNewRequest.setCompanyId(companyId);
+                    companySymbolNewRequest.setCompanySymbol(companySymbols.getCompanySymbol());
+                    companySymbolNewRequest.setCompanySymbolValue(companySymbols.getCompanySymbolValue());
+                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_COMPANY_SYMBOL_NEW, companySymbolNewRequest);
+                } else {
+                    CompanySymbolUpdateRequest companySymbolUpdateRequest = new CompanySymbolUpdateRequest();
+                    companySymbolUpdateRequest.setId(companySymbols.getMapId());
+                    companySymbolUpdateRequest.setCompanyId(companyId);
+                    companySymbolUpdateRequest.setCompanySymbolValue(companySymbols.getCompanySymbolValue());
+                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_COMPANY_SYMBOL_UPDATE, companySymbolUpdateRequest);
+                }
+            }
+
+            for (MemberContact contact : company.getContactList()) {
+                if (contact.isInvalidData()) continue;
+                if (!company.isAlreadyExist() || !contact.isAlreadyExist()) {
+                    ContactNewRequest contactNewRequest = new ContactNewRequest();
+                    contactNewRequest.setCompanyId(companyId);
+                    contactNewRequest.setContactType(contact.getContactType());
+                    contactNewRequest.setContactValue(contact.getContactValue());
+                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_CONTACT_NEW, contactNewRequest);
+                } else {
+                    ContactUpdateRequest contactUpdateRequest = new ContactUpdateRequest();
+                    contactUpdateRequest.setId(contact.getMapId());
+                    contactUpdateRequest.setContactType(contact.getContactType());
+                    contactUpdateRequest.setContactValue(contact.getContactValue());
+                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_CONTACT_UPDATE, contactUpdateRequest);
+                }
+            }
+
+            for (MemberProfileDocument profileDocument : company.getProfileDocumentList()) {
+                if (profileDocument.isInvalidData()) continue;
+                if (!company.isAlreadyExist() || !profileDocument.isAlreadyExist()) {
+                    ProfileDocumentNewRequest profileDocumentNewRequest = new ProfileDocumentNewRequest();
+                    profileDocumentNewRequest.setCompanyId(companyId);
+                    profileDocumentNewRequest.setDocumentType(profileDocument.getDocumentType());
+                    profileDocumentNewRequest.setIssueDate(profileDocument.getIssueDate());
+                    profileDocumentNewRequest.setIssuer(profileDocument.getIssuer());
+                    profileDocumentNewRequest.setNumber(profileDocument.getNumber());
+                    profileDocumentNewRequest.setValidToDate(profileDocument.getValidToDate());
+                    profileDocumentNewRequest.setLink(profileDocument.getLink());
+                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_PROFILE_DOCUMENT_NEW, profileDocumentNewRequest);
+                } else {
+                    ProfileDocumentUpdateRequest profileDocumentUpdateRequest = new ProfileDocumentUpdateRequest();
+                    profileDocumentUpdateRequest.setId(profileDocument.getMapId());
+                    profileDocumentUpdateRequest.setCompanyId(companyId);
+                    profileDocumentUpdateRequest.setDocumentType(profileDocument.getDocumentType());
+                    profileDocumentUpdateRequest.setIssueDate(profileDocument.getIssueDate());
+                    profileDocumentUpdateRequest.setIssuer(profileDocument.getIssuer());
+                    profileDocumentUpdateRequest.setNumber(profileDocument.getNumber());
+                    profileDocumentUpdateRequest.setValidToDate(profileDocument.getValidToDate());
+                    profileDocumentUpdateRequest.setLink(profileDocument.getLink());
+                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_PROFILE_DOCUMENT_NEW, profileDocumentUpdateRequest);
+                }
+            }
+
+            for (MemberClient client : company.getClientList()) {
+                if (client.isInvalidData()) continue;
+
+                if (!company.isAlreadyExist() || !client.isAlreadyExist()) {
+                    ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest();
+                    clientCodeNewRequest.setCompanyId(companyId);
+                    clientCodeNewRequest.setCode(client.getClientCode());
+                    clientCodeNewRequest.setMoneyAccountId(client.getMoneyAccountId());
+                    clientCodeNewRequest.setDepoAccountId(client.getDepoAccountId());
+                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_CLIENT_CODE_NEW, clientCodeNewRequest);
+                } else {
+                    ClientCodeUpdateRequest clientCodeUpdateRequest = new ClientCodeUpdateRequest();
+                    clientCodeUpdateRequest.setId(client.getMapId());
+                    clientCodeUpdateRequest.setCompanyId(companyId);
+                    clientCodeUpdateRequest.setCode(client.getClientCode());
+                    clientCodeUpdateRequest.setMoneyAccountId(client.getMoneyAccountId());
+                    clientCodeUpdateRequest.setDepoAccountId(client.getDepoAccountId());
+                    kafkaSender.sendRequestToQueue(Consts.DESTINATION_CLIENT_CODE_NEW, clientCodeUpdateRequest);
+                }
+            }
+        }
+
+        return null;
+    }
+}

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/companies/ValidateMemberCompanies.java

@@ -54,7 +54,14 @@ public class ValidateMemberCompanies extends Stage<CompaniesRequestParam> {
             DocumentTypes.xcnt
     );
 
-    private final List<ServiceStatus> validWorkflowStatus = List.of(ServiceStatus.values());
+    private final List<ServiceStatus> validWorkflowStatus = Arrays.asList(
+            ServiceStatus.Active,
+            ServiceStatus.Appl,
+            ServiceStatus.Suspended,
+            ServiceStatus.Reopened,
+            ServiceStatus.Blocked,
+            ServiceStatus.Closed
+    );
     private final List<ClearingCategory> validClearingCategory = List.of(ClearingCategory.values());
 
     @Override

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/listings_fond/SendMessageToCompanyServiceWithIssuerCompanies.java

@@ -20,14 +20,14 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import java.util.List;
 import java.util.Map;
 
-public class SendMessageToCompanyService extends Stage<FondListingsRequestParam> {
+public class SendMessageToCompanyServiceWithIssuerCompanies extends Stage<FondListingsRequestParam> {
     private final Logger log = LoggerFactory.getLogger(getClass());
 
     private final KafkaSender kafkaSender;
     private final Imdg<Company> companyImdg;
 
 
-    public SendMessageToCompanyService(KafkaSender kafkaSender, ImdgProvider imdgProvider) {
+    public SendMessageToCompanyServiceWithIssuerCompanies(KafkaSender kafkaSender, ImdgProvider imdgProvider) {
         this.kafkaSender = kafkaSender;
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
     }

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/listings_fond/SendMessageToSecurityServiceWithFondSecurities.java

@@ -21,7 +21,7 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import java.util.List;
 import java.util.Map;
 
-public class SendMessageToSecurityService extends Stage<FondListingsRequestParam> {
+public class SendMessageToSecurityServiceWithFondSecurities extends Stage<FondListingsRequestParam> {
     private final Logger log = LoggerFactory.getLogger(getClass());
 
     private final KafkaSender kafkaSender;
@@ -29,7 +29,7 @@ public class SendMessageToSecurityService extends Stage<FondListingsRequestParam
     private final Imdg<EquitySecurity> equitySecurityImdg;
 
 
-    public SendMessageToSecurityService(KafkaSender kafkaSender, ImdgProvider imdgProvider) {
+    public SendMessageToSecurityServiceWithFondSecurities(KafkaSender kafkaSender, ImdgProvider imdgProvider) {
         this.kafkaSender = kafkaSender;
         this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
         this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/request/objects/FondSecurity.java

@@ -173,15 +173,19 @@ public class FondSecurity extends WithMapId {
 
 
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<IncomeListing> listingList = new ArrayList<>();
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<CouponSchedule> couponScheduleList = new ArrayList<>();
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<Nominal> nominalList = new ArrayList<>();
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private IssuerCompany issuerCompany = null;
 

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/request/objects/IssuerCompany.java

@@ -42,15 +42,20 @@ public class IssuerCompany extends WithMapId {
     )
     private String workflowStatus;
 
+
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private IssuerCompanyInfo issuerCompanyInfo;
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<IssuerCompanySymbols> issuerCompanySymbolsList = new ArrayList<>();
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<IssuerContact> issuerContactList = new ArrayList<>();
 
+
     public UUID getId() {
         return id;
     }

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/request/objects/MemberClient.java

@@ -1,5 +1,6 @@
 package ru.spcex.clearing.gatewayapi.request.objects;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.annotations.ApiModelProperty;
 
@@ -34,6 +35,14 @@ public class MemberClient extends WithMapId {
     )
     private String depoAccount;
 
+    @ApiModelProperty(hidden = true)
+    @JsonIgnore
+    private Long moneyAccountId = null;
+
+    @ApiModelProperty(hidden = true)
+    @JsonIgnore
+    private Long depoAccountId = null;
+
     public UUID getCompanyId() {
         return companyId;
     }
@@ -65,4 +74,20 @@ public class MemberClient extends WithMapId {
     public void setDepoAccount(String depoAccount) {
         this.depoAccount = depoAccount;
     }
+
+    public Long getMoneyAccountId() {
+        return moneyAccountId;
+    }
+
+    public void setMoneyAccountId(Long moneyAccountId) {
+        this.moneyAccountId = moneyAccountId;
+    }
+
+    public Long getDepoAccountId() {
+        return depoAccountId;
+    }
+
+    public void setDepoAccountId(Long depoAccountId) {
+        this.depoAccountId = depoAccountId;
+    }
 }

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/request/objects/MemberCompany.java

@@ -62,21 +62,27 @@ public class MemberCompany extends WithMapId {
     private String initiatorCode;
 
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private MemberCompanyInfo companyInfo;
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<MemberCompanyClearingCategory> companyClearingCategoryList = new ArrayList<>();
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<MemberCompanySymbols> memberCompanySymbolsList = new ArrayList<>();
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<MemberContact> contactList = new ArrayList<>();
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<MemberProfileDocument> memberProfileDocumentList = new ArrayList<>();
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     private List<MemberClient> memberClientList = new ArrayList<>();
 

clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/request/objects/WithMapId.java

@@ -1,14 +1,18 @@
 package ru.spcex.clearing.gatewayapi.request.objects;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import io.swagger.annotations.ApiModelProperty;
 
 public abstract class WithMapId {
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     protected Long mapId = null;
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     protected boolean alreadyExist = false;
 
+    @ApiModelProperty(hidden = true)
     @JsonIgnore
     protected boolean invalidData = false;
 

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/ServiceStatus.java

@@ -8,6 +8,7 @@ public enum ServiceStatus implements IEnumKey {
     Suspended("SSPD"),
     Closed("CLOS"),
     Reopened("ROPN"),
+    Appl("APPL")
 ;
 
     private final String key;