treshenkov/clearing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
etreschenkov 2023-06-16 14:54:38 +03:00
parent e704b8d70c
commit 1c155e4804
18 changed files with 83 additions and 1550 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/config/ProcessorConfiguration.java
View file

@ -5,9 +5,6 @@ import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import ru.spcex.clearing.gatewayapi.logic.Processor;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.companies.CompaniesKafkaMessenger;
import ru.spcex.clearing.gatewayapi.logic.companies.CompaniesRequestParam;
import ru.spcex.clearing.gatewayapi.logic.companies.PrepareMemberCompaniesLegacy;
import ru.spcex.clearing.gatewayapi.logic.listings_fond.*;
import ru.spcex.clearing.gatewayapi.logic.listings_mm.MMListingsRequestParam;
import ru.spcex.clearing.gatewayapi.logic.listings_mm.PrepareExchangeInstruments;
@ -45,15 +42,4 @@ public class ProcessorConfiguration {
return processor;
}
@Qualifier("companiesRequestProcessor")
@Bean
public Processor<CompaniesRequestParam> companiesRequestProcessor(ImdgProvider imdgProvider, KafkaSender kafkaSender) {
Processor<CompaniesRequestParam> processor = new Processor<>();
List<Stage<CompaniesRequestParam>> pipeline = new ArrayList<>();
pipeline.add(new PrepareMemberCompaniesLegacy());
pipeline.add(new CompaniesKafkaMessenger(kafkaSender, imdgProvider));
processor.setPipeline(pipeline);
return processor;
}
}

6
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/controller/GatewayController.java
View file

@ -11,10 +11,9 @@ import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import ru.spcex.clearing.gatewayapi.exception.GatewayException;
import ru.spcex.clearing.gatewayapi.logic.CompanyProcessor;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Processor;
import ru.spcex.clearing.gatewayapi.logic.companies.CompaniesRequestParam;
import ru.spcex.clearing.gatewayapi.logic.companies.CompanyProcessor;
import ru.spcex.clearing.gatewayapi.logic.listings_fond.FondListingsRequestParam;
import ru.spcex.clearing.gatewayapi.logic.listings_mm.MMListingsRequestParam;
import ru.spcex.clearing.gatewayapi.request.CommonRequest;
@ -40,7 +39,6 @@ public class GatewayController {
private final IMessageResolver messageResolver;
private final Processor<FondListingsRequestParam> fondListingsRequestProcessor;
private final Processor<MMListingsRequestParam> mmListingsRequestProcessor;
private final Processor<CompaniesRequestParam> companiesRequestProcessor;
private final CompanyProcessor companiesProcessor;
private final ExecutorService executor;
@ -50,12 +48,10 @@ public class GatewayController {
IMessageResolver messageResolver,
@Qualifier("fondListingsRequestProcessor") Processor<FondListingsRequestParam> fondListingsRequestProcessor,
@Qualifier("mmListingsRequestProcessor") Processor<MMListingsRequestParam> mmListingsRequestProcessor,
@Qualifier("companiesRequestProcessor") Processor<CompaniesRequestParam> companiesRequestProcessor,
CompanyProcessor companiesProcessor, @Qualifier("gatewayExecutor") ExecutorService executor) {
this.messageResolver = messageResolver;
this.fondListingsRequestProcessor = fondListingsRequestProcessor;
this.mmListingsRequestProcessor = mmListingsRequestProcessor;
this.companiesRequestProcessor = companiesRequestProcessor;
this.companiesProcessor = companiesProcessor;
this.executor = executor;
}

3
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/companies/CompanyProcessor.java → clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/CompanyProcessor.java
View file

@ -1,8 +1,9 @@
package ru.spcex.clearing.gatewayapi.logic.companies;
package ru.spcex.clearing.gatewayapi.logic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import ru.spcex.clearing.gatewayapi.logic.adapter.CompanyRequestAdapter;
import ru.spcex.clearing.gatewayapi.request.WithCompanyId;
import ru.spcex.clearing.gatewayapi.request.company.*;
import ru.spcex.clearing.platform.messaging.domain.Consts;

2
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/companies/CompanyRequestAdapter.java → clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/adapter/CompanyRequestAdapter.java
View file

@ -1,4 +1,4 @@
package ru.spcex.clearing.gatewayapi.logic.companies;
package ru.spcex.clearing.gatewayapi.logic.adapter;
import org.springframework.stereotype.Service;
import ru.spcex.clearing.gatewayapi.request.company.*;

107
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/companies/CompaniesKafkaMessenger.java
View file

@ -1,107 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.companies;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.request.company.*;
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.company.*;
import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
import ru.spcex.platform.enumeration.CompanySymbol;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.List;
/**
* Отправка сообщения к company-service на создание/обновление company
* todo Пока убрал совсем не рабочую логику с sendToQueueWaitForAnswer
*/
public class CompaniesKafkaMessenger extends Stage<CompaniesRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final KafkaSender kafkaSender;
private final Imdg<ru.clearing.classes.statics.data.company.Company> companyImdg;
public CompaniesKafkaMessenger(KafkaSender kafkaSender, ImdgProvider imdgProvider) {
this.kafkaSender = kafkaSender;
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, ru.clearing.classes.statics.data.company.Company.class);
}
@Override
public ProcessResult process(CompaniesRequestParam param) {
List<Company> companyList = param.getMemberCompanyList();
for (Company company : companyList) {
if (company.isInvalidData()) continue;
CompanyGatewayRequest multiCompanyRequest = new CompanyGatewayRequest();
CompanyNewRequest companyNewRequest = new CompanyNewRequest();
companyNewRequest.setShortName(company.getShortName());
companyNewRequest.setFullName(company.getFullName());
companyNewRequest.setCompanySymbol(CompanySymbol.UUID.getKey());
companyNewRequest.setCompanySymbolValue(company.getId().toString());
companyNewRequest.setTradingCode(company.getTradingCode());
companyNewRequest.setClearingCode(company.getClearingCode());
companyNewRequest.setRegistrationCode(company.getRegistrationCode());
companyNewRequest.setInitiatorCode(company.getInitiatorCode());
multiCompanyRequest.setCompany(companyNewRequest);
CompanyInfo companyInfo = company.getCompanyInfo();
CompanyInfoUpdateRequest companyInfoUpdateRequest = new CompanyInfoUpdateRequest();
companyInfoUpdateRequest.setCountryCode("RUS"); // todo в текущей версии ТЗ присылается в цифровом обозначении
companyInfoUpdateRequest.setProfessionalSign(companyInfo.getProfessionalSign());
companyInfoUpdateRequest.setLegalKind(companyInfo.getLegalKind());
companyInfoUpdateRequest.setOrganizationType(companyInfo.getOrganizationType());
companyInfoUpdateRequest.setResidence(companyInfo.getResidence());
multiCompanyRequest.setCompanyInfo(companyInfoUpdateRequest);
for (CompanySymbols companySymbols : company.getMemberCompanySymbolsList()) {
if (companySymbols.isInvalidData()) continue;
CompanySymbolNewRequest companySymbolNewRequest = new CompanySymbolNewRequest();
companySymbolNewRequest.setCompanySymbol(companySymbols.getCompanySymbol());
companySymbolNewRequest.setCompanySymbolValue(companySymbols.getCompanySymbolValue());
multiCompanyRequest.getCompanySymbols().add(companySymbolNewRequest);
}
for (Contact contact : company.getContactList()) {
if (contact.isInvalidData()) continue;
ContactNewRequest contactNewRequest = new ContactNewRequest();
contactNewRequest.setContactType(contact.getContactType());
contactNewRequest.setContactValue(contact.getContactValue());
multiCompanyRequest.getContacts().add(contactNewRequest);
}
for (ProfileDocument profileDocument : company.getProfileDocumentList()) {
if (profileDocument.isInvalidData()) continue;
ProfileDocumentNewRequest profileDocumentNewRequest = new ProfileDocumentNewRequest();
profileDocumentNewRequest.setDocumentType(profileDocument.getDocumentType());
profileDocumentNewRequest.setIssueDate(profileDocument.getIssueDate());
profileDocumentNewRequest.setIssuer(profileDocument.getIssuer());
profileDocumentNewRequest.setNumber(profileDocument.getNumber());
profileDocumentNewRequest.setValidToDate(profileDocument.getValidToDate());
profileDocumentNewRequest.setLink(profileDocument.getLink());
multiCompanyRequest.getProfileDocuments().add(profileDocumentNewRequest);
}
for (Client client : company.getClientList()) {
if (client.isInvalidData()) continue;
if (!company.isAlreadyExist() || !client.isAlreadyExist()) {
ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest();
clientCodeNewRequest.setCode(client.getClientCode());
clientCodeNewRequest.setMoneyAccountId(client.getMoneyAccountId());
clientCodeNewRequest.setDepoAccountId(client.getDepoAccountId());
multiCompanyRequest.getClientCodes().add(clientCodeNewRequest);
}
}
kafkaSender.sendRequestToQueue(Consts.DESTINATION_COMPANY_MULTIREQUEST, multiCompanyRequest);
}
return null;
}
}

28
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/companies/CompaniesRequestParam.java
View file

@ -1,28 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.companies;
import ru.spcex.clearing.gatewayapi.request.company.CompaniesRequest;
import ru.spcex.clearing.gatewayapi.request.company.Company;
import java.util.ArrayList;
import java.util.List;
public class CompaniesRequestParam {
private final CompaniesRequest companiesRequest;
private List<Company> memberCompanyList = new ArrayList<>();
public CompaniesRequestParam(CompaniesRequest companiesRequest) {
this.companiesRequest = companiesRequest;
}
public CompaniesRequest getCompaniesRequest() {
return companiesRequest;
}
public List<Company> getMemberCompanyList() {
return memberCompanyList;
}
public void setMemberCompanyList(List<Company> memberCompanyList) {
this.memberCompanyList = memberCompanyList;
}
}

123
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/companies/PrepareMemberCompaniesLegacy.java
View file

@ -1,123 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.companies;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.request.WithCompanyId;
import ru.spcex.clearing.gatewayapi.request.company.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;
public class PrepareMemberCompaniesLegacy extends Stage<CompaniesRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
@Override
public ProcessResult process(CompaniesRequestParam param) {
CompaniesRequest request = param.getCompaniesRequest();
List<Company> companyList = request.getCompanyList();
Map<UUID, Company> companyForUUID = new HashMap<>();
for (Company memberCompany : companyList) {
if (companyForUUID.containsKey(memberCompany.getId())) {
log.warn("For company.id {} found > 1 element from request, use first", memberCompany.getId());
memberCompany.setInvalidData(true);
continue;
}
companyForUUID.put(memberCompany.getId(), memberCompany);
}
List<CompanyInfo> companyInfoList = request.getCompanyInfoList();
for (CompanyInfo companyInfo : companyInfoList) {
UUID companyInfoUUID = companyInfo.getCompanyId();
Company company = companyForUUID.get(companyInfoUUID);
if (company == null) {
log.warn("For company_info.company_id {} not found company, company_info skipped", companyInfoUUID);
continue;
}
company.setCompanyInfo(companyInfo);
}
List<CompanySymbols> memberCompanySymbolsList = param.getCompaniesRequest().getMemberCompanySymbolsList();
for (CompanySymbols memberCompanySymbols : memberCompanySymbolsList) {
UUID memberCompanySymbolsUUID = memberCompanySymbols.getCompanyId();
Company memberCompany = companyForUUID.get(memberCompanySymbolsUUID);
if (memberCompany == null) {
log.warn("For company_symbols ({} = {}) not found company, company_symbols skipped",
memberCompanySymbols.getCompanySymbol(),
memberCompanySymbols.getCompanySymbolValue());
memberCompanySymbols.setInvalidData(true);
continue;
}
memberCompany.getMemberCompanySymbolsList().add(memberCompanySymbols);
}
List<Contact> memberContactList = param.getCompaniesRequest().getContactList();
for (Contact memberContact : memberContactList) {
UUID memberContactUUID = memberContact.getCompanyId();
Company memberCompany = companyForUUID.get(memberContactUUID);
if (memberCompany == null) {
log.warn("For contact ({} = {}) not found company, skipped",
memberContact.getContactType(),
memberContact.getContactValue());
memberContact.setInvalidData(true);
continue;
}
memberCompany.getContactList().add(memberContact);
}
List<CompanyClearingCategory> companyClearingCategoryList = param.getCompaniesRequest().getCompanyClearingCategoryList();
for (CompanyClearingCategory companyClearingCategory : companyClearingCategoryList) {
UUID companyClearingCategoryUUID = companyClearingCategory.getCompanyId();
Company memberCompany = companyForUUID.get(companyClearingCategoryUUID);
if (memberCompany == null) {
log.warn("For company_clearing_category ({}) not found company, skipped", companyClearingCategory.getCategory());
companyClearingCategory.setInvalidData(true);
continue;
}
memberCompany.getCompanyClearingCategoryList().add(companyClearingCategory);
}
List<ProfileDocument> memberProfileDocumentList = param.getCompaniesRequest().getProfileDocumentList();
for (ProfileDocument memberProfileDocument : memberProfileDocumentList) {
UUID profileDocumentUUID = memberProfileDocument.getCompanyId();
Company memberCompany = companyForUUID.get(profileDocumentUUID);
if (memberCompany == null) {
log.warn("For profile_document (document_type {}) not found company, skipped", memberProfileDocument.getDocumentType());
memberProfileDocument.setInvalidData(true);
continue;
}
memberCompany.getProfileDocumentList().add(memberProfileDocument);
}
List<Client> memberClientList = param.getCompaniesRequest().getClientList();
for (Client memberClient : memberClientList) {
UUID clientUUID = memberClient.getCompanyId();
Company memberCompany = companyForUUID.get(clientUUID);
if (memberCompany == null) {
log.warn("For client (client_code {}) not found company, skipped", memberClient.getClientCode());
memberClient.setInvalidData(true);
continue;
}
memberCompany.getClientList().add(memberClient);
}
List<Company> filteredIssuerCompany = companyList.stream()
.filter(memberCompany -> !memberCompany.isInvalidData())
.collect(Collectors.toList());
// todo check list is empty
param.setMemberCompanyList(filteredIssuerCompany);
return null;
}
private <T extends WithCompanyId> List<T> groupByCompanyId(List<T> listToProcess, UUID companyId) {
return listToProcess.stream().filter(t -> t.getCompanyId().equals(companyId)).collect(Collectors.toList());
}
}

187
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/legacy/CheckFondSecurityExist.java
View file

@ -1,187 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.legacy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod;
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.Listing;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.listings_fond.FondListingsRequestParam;
import ru.spcex.clearing.gatewayapi.request.listing.fond.CouponSchedule;
import ru.spcex.clearing.gatewayapi.request.listing.fond.FondSecurity;
import ru.spcex.clearing.gatewayapi.request.listing.fond.IncomeListing;
import ru.spcex.clearing.gatewayapi.request.listing.fond.Nominal;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.InstrumentType;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.List;
import java.util.Map;
public class CheckFondSecurityExist extends Stage<FondListingsRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<EquitySecurity> equitySecurityImdg;
private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
private final Imdg<Listing> listingImdg;
private final Imdg<CouponPeriod> couponPeriodImdg;
private final Imdg<FixedIncomeCashFlow> fixedIncomeCashFlowImdg;
public CheckFondSecurityExist(ImdgProvider imdgProvider) {
equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
listingImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
fixedIncomeCashFlowImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class);
}
@Override
public ProcessResult process(FondListingsRequestParam param) {
List<FondSecurity> securities = param.getSecurities();
for (FondSecurity fondSecurity : securities) {
String instrumentType = fondSecurity.getInstrumentType();
String securitySymbol = fondSecurity.getSecuritySymbol();
if (InstrumentType.BOND.equalsByKey(instrumentType)) {
Collection<FixedIncomeSecurity> fixedIncomeSecurities = fixedIncomeSecurityImdg.getCollectionObjectsByFieldValues(
Map.of("securitySymbol", securitySymbol)
);
if (!fixedIncomeSecurities.isEmpty()) {
FixedIncomeSecurity fixedIncomeSecurity = fixedIncomeSecurities.iterator().next();
if (fixedIncomeSecurities.size() > 1) {
log.warn("For security_symbol = {} found > 1 fixed_income_security, update first (id = {})",
securitySymbol,
fixedIncomeSecurity.getId());
}
fondSecurity.setAlreadyExist(true);
fondSecurity.setMapId(fixedIncomeSecurity.getId());
} else {
fondSecurity.setAlreadyExist(false);
}
} else if (InstrumentType.EQTY.equalsByKey(instrumentType)) {
Collection<EquitySecurity> equitySecurities = equitySecurityImdg.getCollectionObjectsByFieldValues(
Map.of("securitySymbol", securitySymbol)
);
if (!equitySecurities.isEmpty()) {
EquitySecurity equitySecurity = equitySecurities.iterator().next();
if (equitySecurities.size() > 1) {
log.warn("For security_symbol = {} found > 1 equity_security, update first (id = {})",
securitySymbol,
equitySecurity.getId());
}
fondSecurity.setAlreadyExist(true);
fondSecurity.setMapId(equitySecurity.getId());
} else {
fondSecurity.setAlreadyExist(false);
}
}
for (IncomeListing listing : fondSecurity.getListingList()) {
if (listing.isInvalidData()) continue;
if (!fondSecurity.isAlreadyExist()) {
listing.setAlreadyExist(false);
continue;
}
Collection<Listing> listingsFromImdg = listingImdg.getCollectionObjectsByFieldValues(
Map.of(
"securityId", fondSecurity.getMapId(),
"market", listing.getCode()
)
);
if (listingsFromImdg.isEmpty()) {
listing.setAlreadyExist(false);
} else {
Listing listingFromImdg = listingsFromImdg.iterator().next();
if (listingsFromImdg.size() > 1) {
log.warn("For security_id {} and market {} found > 1 listing, update first (id = {})",
fondSecurity.getMapId(),
listing.getCode(),
listingFromImdg.getId());
}
listing.setAlreadyExist(true);
listing.setMapId(listingFromImdg.getId());
}
}
for (CouponSchedule couponSchedules : fondSecurity.getCouponScheduleList()) {
if (couponSchedules.isInvalidData()) continue;
if (!fondSecurity.isAlreadyExist()) {
couponSchedules.setAlreadyExist(false);
continue;
}
Collection<CouponPeriod> couponPeriodListFromImdg = couponPeriodImdg.getCollectionObjectsByFieldValues(
Map.of(
"securityId", fondSecurity.getMapId(),
"periodStartDate", couponSchedules.getPeriodStartDate(),
"periodEndDate", couponSchedules.getPeriodEndDate()
)
);
if (couponPeriodListFromImdg.isEmpty()) {
couponSchedules.setAlreadyExist(false);
} else {
CouponPeriod couponPeriod = couponPeriodListFromImdg.iterator().next();
if (couponPeriodListFromImdg.size() > 1) {
log.warn("For securityId {}, period_start_date {}, period_end_date {} found > 1 coupon_period, " +
"update first (id = {})",
fondSecurity.getMapId(),
couponSchedules.getPeriodStartDate(),
couponSchedules.getPeriodEndDate(),
couponPeriod.getId());
}
couponSchedules.setAlreadyExist(true);
couponSchedules.setMapId(couponPeriod.getId());
}
}
for (Nominal nominal : fondSecurity.getNominalList()) {
if (nominal.isInvalidData()) continue;
if (fondSecurity.isAlreadyExist()) {
Collection<FixedIncomeCashFlow> fixedIncomeCashFlowListFromImdg = fixedIncomeCashFlowImdg.getCollectionObjectsByFieldValues(
Map.of(
"securityId", fondSecurity.getMapId(),
"valueDate", nominal.getDate()
)
);
if (fixedIncomeCashFlowListFromImdg.isEmpty()) {
nominal.setAlreadyExist(false);
} else {
FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowListFromImdg.iterator().next();
if (fixedIncomeCashFlowListFromImdg.size() > 1) {
log.warn("For security_id {}, value_date {} found > 1 fixed_income_cash_flow, update first (id = {})",
fondSecurity.getMapId(),
nominal.getDate(),
fixedIncomeCashFlow.getId());
}
nominal.setAlreadyExist(true);
nominal.setMapId(fixedIncomeCashFlow.getId());
}
} else {
nominal.setAlreadyExist(false);
}
for (CouponSchedule couponSchedule : fondSecurity.getCouponScheduleList()) {
if (couponSchedule.isInvalidData()) continue;
if (nominal.getDate().isBefore(couponSchedule.getPeriodStartDate()) || nominal.getDate().isAfter(couponSchedule.getPeriodEndDate()))
continue;
nominal.setAccruedCoupon(couponSchedule.getAccruedCoupon());
nominal.setCouponNumber(couponSchedule.getCouponNumber());
}
if (nominal.getAccruedCoupon() == null || nominal.getCouponNumber() == null) {
log.warn("Can't find accrued_coupon OR coupon_number for nominal, security.id {}", fondSecurity.getId());
nominal.setInvalidData(true);
}
}
}
return null;
}
}

173
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/legacy/CheckIssuerCompanyExist.java
View file

@ -1,173 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.legacy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanySymbols;
import ru.clearing.classes.statics.data.profile.Contact;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.listings_fond.FondListingsRequestParam;
import ru.spcex.clearing.gatewayapi.request.listing.fond.IssuerCompany;
import ru.spcex.clearing.gatewayapi.request.listing.fond.IssuerCompanySymbols;
import ru.spcex.clearing.gatewayapi.request.listing.fond.IssuerContact;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.CompanySymbol;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class CheckIssuerCompanyExist extends Stage<FondListingsRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<Company> companyImdg;
private final Imdg<CompanySymbols> companySymbolsImdg;
private final Imdg<Contact> contactImdg;
public CheckIssuerCompanyExist(ImdgProvider imdgProvider) {
companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
contactImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Contact, Contact.class);
}
@Override
public ProcessResult process(FondListingsRequestParam param) {
List<IssuerCompany> companyList = param.getIssuerCompanyList();
for (IssuerCompany company : companyList) {
List<IssuerCompanySymbols> companySymbolsList = company.getIssuerCompanySymbolsList();
Map<CompanySymbol, String> companySymbolMap = new HashMap<>();
for (IssuerCompanySymbols issuerCompanySymbol : companySymbolsList) {
if (
!issuerCompanySymbol.isInvalidData() &&
!CompanySymbol.CIO.equalsByKey(issuerCompanySymbol.getCompanySymbol()) &&
!CompanySymbol.INN.equalsByKey(issuerCompanySymbol.getCompanySymbol())
) continue;
companySymbolMap.put(IEnumKey.getEnumByKey(CompanySymbol.class, issuerCompanySymbol.getCompanySymbol()), issuerCompanySymbol.getCompanySymbolValue());
}
Long companyId = getCompanyIdForCompanySymbols(company.getId().toString(), companySymbolMap);
if (companyId != null) {
company.setAlreadyExist(true);
company.setMapId(companyId);
} else {
company.setAlreadyExist(false);
continue;
}
// Проверяем реквизиты на необходимость обновления
for (IssuerCompanySymbols companySymbols : companySymbolsList) {
if (companySymbols.isInvalidData()) continue;
Collection<CompanySymbols> companySymbolsFromImdg = companySymbolsImdg.getCollectionObjectsByFieldValues(
Map.of(
"companyId", companyId,
"companySymbol", companySymbols.getCompanySymbol()
)
);
if (companySymbolsFromImdg.isEmpty()) {
companySymbols.setAlreadyExist(false);
} else {
CompanySymbols companySymbolFromImdg = companySymbolsFromImdg.iterator().next();
if (companySymbolsFromImdg.size() > 1) {
log.warn("For company_symbols ({}={}) found > 1 own company_symbols, " +
"update first (company_symbols.id = {})",
companySymbols.getCompanySymbol(),
companySymbols.getCompanySymbolValue(),
companySymbolFromImdg.getId());
}
companySymbols.setAlreadyExist(true);
companySymbols.setMapId(companySymbolFromImdg.getId());
}
}
// Проверяем контакты на необходимость обновления
if (company.isAlreadyExist() && company.getMapId() != null) {
List<IssuerContact> contactList = company.getIssuerContactList();
for (IssuerContact contact : contactList) {
if (contact.isInvalidData()) continue;
Collection<Contact> contactsFromImdg = contactImdg.getCollectionObjectsByFieldValues(
Map.of(
"companyId", company.getMapId(),
"contactType", contact.getContactType()
)
);
if (contactsFromImdg.isEmpty()) {
contact.setAlreadyExist(false);
} else {
Contact contactFromImdg = contactsFromImdg.iterator().next();
if (contactsFromImdg.size() > 1) {
log.warn("Found contact > 1 for contact_type {}, update first (id = {})",
contactFromImdg.getContactType(),
contactFromImdg.getId());
}
contact.setAlreadyExist(true);
contact.setMapId(contactFromImdg.getId());
}
}
}
}
List<IssuerCompany> filteredIssuerCompany = companyList.stream()
.filter(issuerCompany -> !issuerCompany.isInvalidData())
.collect(Collectors.toList());
param.setIssuerCompanyList(filteredIssuerCompany);
return null;
}
private Long getCompanyIdForCompanySymbols(String uuid, Map<CompanySymbol, String> INNorCIO) {
Collection<CompanySymbols> companySymbolsFromImdg = companySymbolsImdg.getCollectionObjectsByFieldValues(
Map.of(
"companySymbol", CompanySymbol.UUID.getKey(),
"companySymbolValue", uuid
)
);
if (!companySymbolsFromImdg.isEmpty()) {
CompanySymbols companySymbolFromImdg = companySymbolsFromImdg.iterator().next();
if (companySymbolsFromImdg.size() > 1) {
log.warn("For UUID found > 1 company_symbols, use first (id = {})", companySymbolFromImdg.getId());
}
return companySymbolFromImdg.getCompanyId();
}
for (Map.Entry<CompanySymbol, String> entry : INNorCIO.entrySet()) {
CompanySymbol companySymbol = entry.getKey();
String companySymbolValue = entry.getValue();
companySymbolsFromImdg = companySymbolsImdg.getCollectionObjectsByFieldValues(
Map.of(
"companySymbol", companySymbol.getKey(),
"companySymbolValue", companySymbolValue
)
);
if (!companySymbolsFromImdg.isEmpty()) {
if (companySymbolsFromImdg.size() > 1)
log.warn("For {} = {} found > 1 company_symbols, use first", companySymbol.getKey(), companySymbolValue);
CompanySymbols companySymbolFromImdg = companySymbolsFromImdg.iterator().next();
Company companyFromImdg = companyImdg.getSingleObjectByID(companySymbolFromImdg.getCompanyId());
if (companyFromImdg == null) {
// Случай, когда реквизиты есть, а компании нет (по сути данных ошибка в мапе)
log.error("For own company_symbols (id = {}) company not found (map error)", companySymbolFromImdg.getId());
} else {
return companyFromImdg.getId();
}
}
}
return null;
}
}

290
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/legacy/CheckMemberCompanyExist.java
View file

@ -1,290 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.legacy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.clearing.classes.statics.data.account.*;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.companies.CompaniesRequestParam;
import ru.spcex.clearing.gatewayapi.request.company.*;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.CompanySymbol;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class CheckMemberCompanyExist extends Stage<CompaniesRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<ru.clearing.classes.statics.data.company.Company> companyImdg;
private final Imdg<ru.clearing.classes.statics.data.company.CompanySymbols> companySymbolsImdg;
private final Imdg<ru.clearing.classes.statics.data.profile.Contact> contactImdg;
private final Imdg<ru.clearing.classes.statics.data.profile.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, ru.clearing.classes.statics.data.company.Company.class);
companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, ru.clearing.classes.statics.data.company.CompanySymbols.class);
contactImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Contact, ru.clearing.classes.statics.data.profile.Contact.class);
profileDocumentImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ProfileDocument, ru.clearing.classes.statics.data.profile.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);
}
@Override
public ProcessResult process(CompaniesRequestParam param) {
List<Company> companyList = param.getMemberCompanyList();
for (Company company : companyList) {
List<CompanySymbols> companySymbolsList = company.getMemberCompanySymbolsList();
Map<CompanySymbol, String> companySymbolMap = new HashMap<>();
for (CompanySymbols memberCompanySymbol : companySymbolsList) {
if (
!memberCompanySymbol.isInvalidData() &&
!CompanySymbol.CIO.equalsByKey(memberCompanySymbol.getCompanySymbol()) &&
!CompanySymbol.INN.equalsByKey(memberCompanySymbol.getCompanySymbol())
) continue;
companySymbolMap.put(IEnumKey.getEnumByKey(CompanySymbol.class, memberCompanySymbol.getCompanySymbol()), memberCompanySymbol.getCompanySymbolValue());
}
Long companyId = getCompanyIdForCompanySymbols(company.getId().toString(), companySymbolMap);
if (companyId != null) {
company.setAlreadyExist(true);
company.setMapId(companyId);
} else {
company.setAlreadyExist(false);
continue;
}
// Проверяем реквизиты на необходимость обновления
for (CompanySymbols companySymbols : companySymbolsList) {
if (companySymbols.isInvalidData()) continue;
Collection<ru.clearing.classes.statics.data.company.CompanySymbols> companySymbolsFromImdg = companySymbolsImdg.getCollectionObjectsByFieldValues(
Map.of(
"companyId", companyId,
"companySymbol", companySymbols.getCompanySymbol()
)
);
if (companySymbolsFromImdg.isEmpty()) {
companySymbols.setAlreadyExist(false);
} else {
ru.clearing.classes.statics.data.company.CompanySymbols companySymbolFromImdg = companySymbolsFromImdg.iterator().next();
if (companySymbolsFromImdg.size() > 1) {
log.warn("For company_symbols ({}={}) found > 1 own company_symbols, " +
"update first (company_symbols.id = {})",
companySymbols.getCompanySymbol(),
companySymbols.getCompanySymbolValue(),
companySymbolFromImdg.getId());
}
companySymbols.setAlreadyExist(true);
companySymbols.setMapId(companySymbolFromImdg.getId());
}
}
// Проверяем контакты, документы и клиентов на необходимость обновления
if (company.isAlreadyExist()) {
List<Contact> contactList = company.getContactList();
for (Contact contact : contactList) {
if (contact.isInvalidData()) continue;
Collection<ru.clearing.classes.statics.data.profile.Contact> contactsFromImdg = contactImdg.getCollectionObjectsByFieldValues(
Map.of(
"companyId", companyId,
"contactType", contact.getContactType()
)
);
if (contactsFromImdg.isEmpty()) {
contact.setAlreadyExist(false);
} else {
ru.clearing.classes.statics.data.profile.Contact contactFromImdg = contactsFromImdg.iterator().next();
if (contactsFromImdg.size() > 1) {
log.warn("Found contact > 1 for contact_type {}, update first (id = {})",
contactFromImdg.getContactType(),
contactFromImdg.getId());
}
contact.setAlreadyExist(true);
contact.setMapId(contactFromImdg.getId());
}
}
List<ProfileDocument> memberProfileDocumentList = company.getProfileDocumentList();
for (ProfileDocument memberProfileDocument : memberProfileDocumentList) {
if (memberProfileDocument.isInvalidData()) continue;
Collection<ru.clearing.classes.statics.data.profile.ProfileDocument> profileDocumentsFromImdg = profileDocumentImdg.getCollectionObjectsByFieldValues(
Map.of(
"companyId", companyId,
"documentType", memberProfileDocument.getDocumentType()
)
);
if (profileDocumentsFromImdg.isEmpty()) {
memberProfileDocument.setAlreadyExist(false);
} else {
ru.clearing.classes.statics.data.profile.ProfileDocument profileDocument = profileDocumentsFromImdg.iterator().next();
if (profileDocumentsFromImdg.size() > 1) {
log.warn("Found profile_document > 1 for document_type {} (company.id {}), update first (id = {})",
memberProfileDocument.getDocumentType(),
companyId,
profileDocument.getId());
}
memberProfileDocument.setAlreadyExist(true);
memberProfileDocument.setMapId(profileDocument.getId());
}
}
List<Client> memberClientList = company.getClientList();
for (Client memberClient : memberClientList) {
if (memberClient.isInvalidData()) continue;
Collection<ClientCode> clientCodesFromImdg = clientCodeImdg.getCollectionObjectsByFieldValues(
Map.of(
"companyId", companyId,
"code", memberClient.getClientCode()
)
);
if (clientCodesFromImdg.isEmpty()) {
memberClient.setAlreadyExist(false);
} else {
ClientCode clientCode = clientCodesFromImdg.iterator().next();
if (clientCodesFromImdg.size() > 1) {
log.warn("Found client_code > 1 for code {} (company.id {}), update first (id = {})",
clientCode.getCode(),
companyId,
clientCode.getId());
}
memberClient.setAlreadyExist(true);
memberClient.setMapId(clientCode.getId());
}
// Определяем соответствующие moneyAccount id из clearingAccount/informationAccount
fillMemberClientMoneyOrDepoAccountId(company, memberClient);
}
}
}
List<Company> filteredMemberCompany = companyList.stream()
.filter(memberCompany -> !memberCompany.isInvalidData())
.collect(Collectors.toList());
param.setMemberCompanyList(filteredMemberCompany);
return null;
}
private void fillMemberClientMoneyOrDepoAccountId(Company company, Client 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.id {}) 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.id {}) 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());
}
}
}
}
private Long getCompanyIdForCompanySymbols(String uuid, Map<CompanySymbol, String> INNorCIO) {
Collection<ru.clearing.classes.statics.data.company.CompanySymbols> companySymbolsFromImdg = companySymbolsImdg.getCollectionObjectsByFieldValues(
Map.of(
"companySymbol", CompanySymbol.UUID.getKey(),
"companySymbolValue", uuid
)
);
if (!companySymbolsFromImdg.isEmpty()) {
ru.clearing.classes.statics.data.company.CompanySymbols companySymbolFromImdg = companySymbolsFromImdg.iterator().next();
if (companySymbolsFromImdg.size() > 1) {
log.warn("For UUID found > 1 company_symbols, use first (id = {})", companySymbolFromImdg.getId());
}
return companySymbolFromImdg.getCompanyId();
}
for (Map.Entry<CompanySymbol, String> entry : INNorCIO.entrySet()) {
CompanySymbol companySymbol = entry.getKey();
String companySymbolValue = entry.getValue();
companySymbolsFromImdg = companySymbolsImdg.getCollectionObjectsByFieldValues(
Map.of(
"companySymbol", companySymbol.getKey(),
"companySymbolValue", companySymbolValue
)
);
if (!companySymbolsFromImdg.isEmpty()) {
if (companySymbolsFromImdg.size() > 1)
log.warn("For {} = {} found > 1 company_symbols, use first", companySymbol.getKey(), companySymbolValue);
ru.clearing.classes.statics.data.company.CompanySymbols companySymbolFromImdg = companySymbolsFromImdg.iterator().next();
ru.clearing.classes.statics.data.company.Company companyFromImdg = companyImdg.getSingleObjectByID(companySymbolFromImdg.getCompanyId());
if (companyFromImdg == null) {
// Случай, когда реквизиты есть, а компании нет (по сути данных ошибка в мапе)
log.error("For own company_symbols (id = {}) company not found (map error)", companySymbolFromImdg.getId());
} else {
return companyFromImdg.getId();
}
}
}
return null;
}
}

67
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/legacy/CheckMoneyMarketSecurityExist.java
View file

@ -1,67 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.legacy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.listings_mm.MMListingsRequestParam;
import ru.spcex.clearing.gatewayapi.request.listing.mkr.ExchangeInstrument;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.InstrumentType;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.List;
import java.util.Map;
public class CheckMoneyMarketSecurityExist extends Stage<MMListingsRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<MoneyMarketSecurity> moneyMarketSecurityImdg;
public CheckMoneyMarketSecurityExist(ImdgProvider imdgProvider) {
moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
}
@Override
public ProcessResult process(MMListingsRequestParam param) {
List<ExchangeInstrument> exchangeInstrumentList = param.getExchangeInstrumentsList();
for (ExchangeInstrument exchangeInstrument : exchangeInstrumentList) {
if (exchangeInstrument.isInvalidData()) continue;
String securitySymbol = extractSecuritySymbol(exchangeInstrument.getCode());
exchangeInstrument.setSecuritySymbol(securitySymbol);
Collection<MoneyMarketSecurity> securitiesFromImdg = moneyMarketSecurityImdg.getCollectionObjectsByFieldValues(
Map.of(
"securitySymbol", securitySymbol,
"instrumentType", InstrumentType.RATE.getKey()
)
);
if (securitiesFromImdg.isEmpty()) {
exchangeInstrument.setAlreadyExist(false);
} else {
MoneyMarketSecurity security = securitiesFromImdg.iterator().next();
if (securitiesFromImdg.size() > 1) {
log.warn("For securitySymbol = {} and instrumentType = {} found > 1 moneyMarketSecurity, update first (id = {})",
securitySymbol,
InstrumentType.RATE.getKey(),
security.getId());
}
exchangeInstrument.setAlreadyExist(true);
exchangeInstrument.setMapId(security.getId());
}
}
return null;
}
private String extractSecuritySymbol(String code) {
int firstX = code.indexOf('X');
if (firstX == -1) return code;
return code.substring(0, firstX);
}
}

112
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/legacy/ValidateExchangeInstruments.java
View file

@ -1,112 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.legacy;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanySymbols;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.listings_mm.MMListingsRequestParam;
import ru.spcex.clearing.gatewayapi.request.listing.mkr.ExchangeInstrument;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.CompanySymbol;
import ru.spcex.platform.enumeration.TermType;
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.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class ValidateExchangeInstruments extends Stage<MMListingsRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<Company> companyImdg;
private final Imdg<CompanySymbols> companySymbolsImdg;
public ValidateExchangeInstruments(ImdgProvider imdgProvider) {
companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
}
@Override
public ProcessResult process(MMListingsRequestParam param) {
List<ExchangeInstrument> exchangeInstrumentList = param.getExchangeInstrumentsList();
for (ExchangeInstrument exchangeInstrument : exchangeInstrumentList) {
Collection<CompanySymbols> companySymbols = companySymbolsImdg.getCollectionObjectsByFieldValues(
Map.of(
"companySymbol", CompanySymbol.UUID.getKey(),
"companySymbolValue", exchangeInstrument.getInitiatorId()
)
);
if (companySymbols.isEmpty()) {
log.warn("Invalid exchange_instrument.initiator_id: companySymbol.UUID = {} not found, skipped",
exchangeInstrument.getInitiatorId());
exchangeInstrument.setInvalidData(true);
} else {
CompanySymbols companySymbol = companySymbols.iterator().next();
if (companySymbols.size() > 1) {
log.warn("companySymbol.UUID = {} > 1, use first (id = {}, companyId = {})",
companySymbol.getCompanySymbolValue(),
companySymbol.getId(),
companySymbol.getCompanyId());
}
exchangeInstrument.setIssuerId(companySymbol.getCompanyId());
}
if (StringUtils.isEmpty(exchangeInstrument.getCode())) {
log.warn("Invalid exchange_instrument (id = {}), code is empty or null, skipped", exchangeInstrument.getId());
exchangeInstrument.setInvalidData(true);
}
if (StringUtils.isEmpty(exchangeInstrument.getName())) {
log.warn("Empty or null name for exchange_instrument (id = {})", exchangeInstrument.getId());
exchangeInstrument.setInvalidData(true);
}
if (exchangeInstrument.getInitiatorId() == null) {
log.warn("initiator_id empty for exchange_instrument (id = {})", exchangeInstrument.getId());
exchangeInstrument.setInvalidData(true);
}
if (StringUtils.isEmpty(exchangeInstrument.getSettlementCurrencyLetterCode())) {
log.warn("settlement_currency_letter_code empty or null for exchange_instrument (id = {})", exchangeInstrument.getId());
exchangeInstrument.setInvalidData(true);
}
if (exchangeInstrument.getLot() == null) {
log.warn("lot null for exchange_instrument (id = {})", exchangeInstrument.getId());
exchangeInstrument.setInvalidData(true);
}
String workflowStatusStr = exchangeInstrument.getWorkflowStatus();
WorkflowStatus workflowStatus = IEnumKey.getEnumByKey(WorkflowStatus.class, workflowStatusStr);
if (workflowStatus == null) {
log.warn("Invalid workflow_status {} for exchange_instrument (id = {})", workflowStatusStr, exchangeInstrument.getId());
exchangeInstrument.setInvalidData(true);
}
String bankDepositAgreementTypeStr = exchangeInstrument.getBankDepositAgreementType();
TermType termType = IEnumKey.getEnumByKey(TermType.class, bankDepositAgreementTypeStr);
if (termType == null) {
log.warn("Invalid bank_deposit_agreement_type {} for exchange_instrument (id = {})", bankDepositAgreementTypeStr, exchangeInstrument.getId());
exchangeInstrument.setInvalidData(true);
}
}
List<ExchangeInstrument> filteredExchangeInstrument = exchangeInstrumentList.stream()
.filter(exchangeInstrument -> !exchangeInstrument.isInvalidData())
.collect(Collectors.toList());
// todo check list is empty
param.setExchangeInstrumentsList(filteredExchangeInstrument);
return null;
}
}

167
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/legacy/ValidateIncomeSecurities.java
View file

@ -1,167 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.legacy;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.spcex.clearing.gatewayapi.errors.GatewayError;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.listings_fond.FondListingsRequestParam;
import ru.spcex.clearing.gatewayapi.request.listing.fond.CouponSchedule;
import ru.spcex.clearing.gatewayapi.request.listing.fond.FondSecurity;
import ru.spcex.clearing.gatewayapi.request.listing.fond.IncomeListing;
import ru.spcex.clearing.gatewayapi.request.listing.fond.Nominal;
import ru.spcex.platform.enumeration.BondType;
import ru.spcex.platform.enumeration.InstrumentType;
import ru.spcex.platform.enumeration.ShareType;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import java.util.List;
import java.util.stream.Collectors;
public class ValidateIncomeSecurities extends Stage<FondListingsRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
@Override
public ProcessResult process(FondListingsRequestParam param) {
List<FondSecurity> securities = param.getSecurities();
for (FondSecurity fondSecurity : securities) {
if (fondSecurity.isInvalidData()) continue;
String instrumentTypeStr = fondSecurity.getInstrumentType();
InstrumentType instrumentType = IEnumKey.getEnumByKey(InstrumentType.class, instrumentTypeStr);
if (instrumentType != InstrumentType.BOND && instrumentType != InstrumentType.EQTY) {
log.warn("Invalid instrument_type {} for security.id {}, skipped", instrumentTypeStr, fondSecurity.getId());
fondSecurity.setInvalidData(true);
continue;
}
String workflowStatusStr = fondSecurity.getWorkflowStatus();
WorkflowStatus workflowStatus = IEnumKey.getEnumByKey(WorkflowStatus.class, workflowStatusStr);
if (workflowStatus == null) {
log.warn("Invalid workflow_status {} for security.id {}, skipped", workflowStatusStr, fondSecurity.getId());
fondSecurity.setInvalidData(true);
continue;
}
String shareTypeStr = fondSecurity.getShareType();
ShareType shareType = IEnumKey.getEnumByKey(ShareType.class, shareTypeStr);
if (instrumentType == InstrumentType.EQTY && shareType == null) {
log.warn("Invalid share_type {} for security.id {}, skipped", shareTypeStr, fondSecurity.getId());
fondSecurity.setInvalidData(true);
continue;
}
String bondTypeStr = fondSecurity.getBondType();
BondType bondType = IEnumKey.getEnumByKey(BondType.class, bondTypeStr);
if (bondType == null) {
log.warn("Invalid bondType {} for security.id {}, skipped", bondTypeStr, fondSecurity.getId());
fondSecurity.setInvalidData(true);
continue;
}
if (StringUtils.isEmpty(fondSecurity.getSecuritySymbol())) {
log.warn("Empty or null security_symbol for security.id {}, skipped", fondSecurity.getId());
fondSecurity.setInvalidData(true);
continue;
}
if (StringUtils.isEmpty(fondSecurity.getShortName())) {
log.warn("Empty or null short_name for security.id {}, skipped", fondSecurity.getShortName());
fondSecurity.setInvalidData(true);
continue;
}
List<IncomeListing> listingList = fondSecurity.getListingList();
for (IncomeListing listing : listingList) {
if (StringUtils.isEmpty(listing.getCode())) {
log.warn("Empty or null code for listing from security.id {}", fondSecurity.getId());
listing.setInvalidData(true);
}
if (listing.getLotSize() == null) {
log.warn("lot_size is null for listing from security.id {}", fondSecurity.getId());
listing.setInvalidData(true);
}
if (StringUtils.isEmpty(listing.getTradingCurrency())) {
log.warn("Empty or null trading_currency for listing from security.id {}", fondSecurity.getId());
listing.setInvalidData(true);
}
workflowStatusStr = listing.getWorkflowStatus();
workflowStatus = IEnumKey.getEnumByKey(WorkflowStatus.class, workflowStatusStr);
if (workflowStatus == null) {
log.warn("Invalid workflow_status {} for listing from security.id {}", workflowStatusStr, fondSecurity.getId());
listing.setInvalidData(true);
}
}
fondSecurity.setListingList(
listingList.stream()
.filter(incomeListing -> !incomeListing.isInvalidData())
.collect(Collectors.toList())
);
for (CouponSchedule couponSchedule : fondSecurity.getCouponScheduleList()) {
if (
couponSchedule.getPeriodStartDate() == null ||
couponSchedule.getPeriodEndDate() == null ||
couponSchedule.getPeriodEndDate().isBefore(couponSchedule.getPeriodStartDate())
) {
log.warn("Invalid period_start_date {} or period_end_date {} for coupon_schedule, security.id {}, skipped",
couponSchedule.getPeriodStartDate(),
couponSchedule.getPeriodEndDate(),
fondSecurity.getId());
couponSchedule.setInvalidData(true);
}
if (couponSchedule.getCouponNumber() == null) {
log.warn("coupon_number is null for coupon_schedule, security.id {}, skipped", fondSecurity.getId());
couponSchedule.setInvalidData(true);
}
if (couponSchedule.getCouponRate() == null) {
log.warn("coupon_rate is null for coupon_schedule, security.id {}, skipped", fondSecurity.getId());
couponSchedule.setInvalidData(true);
}
if (couponSchedule.getAccruedCoupon() == null) {
log.warn("accrued_coupon is null for coupon_schedule, security.id {}, skipped", fondSecurity.getId());
couponSchedule.setInvalidData(true);
}
}
for (Nominal nominal : fondSecurity.getNominalList()) {
if (nominal.getNominal() == null) {
log.warn("nominal (value) is null for nominal, security.id {}, skipped", fondSecurity.getId());
nominal.setInvalidData(true);
}
if (nominal.getDate() == null) {
log.warn("date is null for nominal, security.id {}, skipped", fondSecurity.getId());
nominal.setInvalidData(true);
}
}
}
List<FondSecurity> filteredIncomeSecurities = securities.stream()
.filter(incomeSecurity -> !incomeSecurity.isInvalidData())
.collect(Collectors.toList());
if (filteredIncomeSecurities.isEmpty()) {
return new ProcessResult(GatewayError.SecurityNotFound, securities.stream().map(fondSecurity -> fondSecurity.getId().toString()).collect(Collectors.joining(", ")));
}
param.setSecurities(filteredIncomeSecurities);
return null;
}
}

103
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/legacy/ValidateIssuerCompanies.java
View file

@ -1,103 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.legacy;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.listings_fond.FondListingsRequestParam;
import ru.spcex.clearing.gatewayapi.request.listing.fond.IssuerCompany;
import ru.spcex.clearing.gatewayapi.request.listing.fond.IssuerCompanySymbols;
import ru.spcex.clearing.gatewayapi.request.listing.fond.IssuerContact;
import ru.spcex.platform.enumeration.CompanySymbol;
import ru.spcex.platform.enumeration.ContactTypes;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import java.util.Arrays;
import java.util.List;
public class ValidateIssuerCompanies extends Stage<FondListingsRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final List<CompanySymbol> validCompanySymbols = Arrays.asList(
CompanySymbol.OCVD,
CompanySymbol.INN,
CompanySymbol.CIO,
CompanySymbol.CPP,
CompanySymbol.OCPO,
CompanySymbol.BIC,
CompanySymbol.OGRN
);
private final List<ContactTypes> validContactTypes = Arrays.asList(
ContactTypes.adrs,
ContactTypes.cont,
ContactTypes.mail,
ContactTypes.gdir,
ContactTypes.trst,
ContactTypes.fax,
ContactTypes.info,
ContactTypes.web
);
@Override
public ProcessResult process(FondListingsRequestParam param) {
List<IssuerCompany> companyList = param.getIssuerCompanyList();
for (IssuerCompany issuerCompany : companyList) {
if (issuerCompany.isInvalidData()) continue;
if (StringUtils.isEmpty(issuerCompany.getShortName())) {
log.warn("Empty or null short_name for company (id = {}), skipped", issuerCompany.getId());
issuerCompany.setInvalidData(true);
continue;
}
String workflowStatusStr = issuerCompany.getWorkflowStatus();
WorkflowStatus workflowStatus = IEnumKey.getEnumByKey(WorkflowStatus.class, workflowStatusStr);
if (workflowStatus == null) {
log.warn("Invalid workflow_status {} for company (id = {}), skipped", workflowStatusStr, issuerCompany.getId());
issuerCompany.setInvalidData(true);
continue;
}
for (IssuerCompanySymbols companySymbols : issuerCompany.getIssuerCompanySymbolsList()) {
String companySymbolStr = companySymbols.getCompanySymbol();
CompanySymbol companySymbol = IEnumKey.getEnumByKey(CompanySymbol.class, companySymbolStr);
if (!validCompanySymbols.contains(companySymbol)) {
log.warn("Invalid company_symbol {} for company.id {}, skipped", companySymbolStr, issuerCompany.getId());
companySymbols.setInvalidData(true);
}
if (StringUtils.isEmpty(companySymbols.getCompanySymbolValue())) {
log.warn("Empty or null company_symbol_value for company.id {}, skipped", companySymbols.getCompanySymbolValue());
companySymbols.setInvalidData(true);
}
}
for (IssuerContact contact : issuerCompany.getIssuerContactList()) {
String contactTypeStr = contact.getContactType();
ContactTypes contactType = IEnumKey.getEnumByKey(ContactTypes.class, contactTypeStr);
if (!validContactTypes.contains(contactType)) {
log.warn("Invalid contact_type {} for company.id {}, skipped", contactTypeStr, issuerCompany.getId());
contact.setInvalidData(true);
}
if (StringUtils.isEmpty(contact.getContactValue())) {
log.warn("Empty or null contact_value for contact {}, company.id {}", contactTypeStr, issuerCompany.getId());
contact.setInvalidData(true);
}
}
}
return null;
}
}

172
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/logic/legacy/ValidateMemberCompanies.java
View file

@ -1,172 +0,0 @@
package ru.spcex.clearing.gatewayapi.logic.legacy;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.spcex.clearing.gatewayapi.logic.ProcessResult;
import ru.spcex.clearing.gatewayapi.logic.Stage;
import ru.spcex.clearing.gatewayapi.logic.companies.CompaniesRequestParam;
import ru.spcex.clearing.gatewayapi.request.company.*;
import ru.spcex.platform.enumeration.*;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import java.util.Arrays;
import java.util.List;
public class ValidateMemberCompanies extends Stage<CompaniesRequestParam> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final List<CompanySymbol> validCompanySymbols = Arrays.asList(
CompanySymbol.INN,
CompanySymbol.CIO,
CompanySymbol.OGRN,
CompanySymbol.CPP,
CompanySymbol.OCPO,
CompanySymbol.BIC,
CompanySymbol.LICB,
CompanySymbol.LICR,
CompanySymbol.LICD,
CompanySymbol.LICT,
CompanySymbol.LICC,
CompanySymbol.LICF
);
private final List<ContactTypes> validContactTypes = Arrays.asList(
ContactTypes.adrs,
ContactTypes.cont,
ContactTypes.mail,
ContactTypes.gdir,
ContactTypes.trst,
ContactTypes.fax,
ContactTypes.info,
ContactTypes.web
);
private final List<DocumentTypes> validDocumentTypes = Arrays.asList(
DocumentTypes.cntr,
DocumentTypes.form,
DocumentTypes.licb,
DocumentTypes.licr,
DocumentTypes.licd,
DocumentTypes.lict,
DocumentTypes.licc,
DocumentTypes.licf,
DocumentTypes.edoc,
DocumentTypes.xcnt
);
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
public ProcessResult process(CompaniesRequestParam param) {
List<Company> memberCompanyList = param.getMemberCompanyList();
for (Company company : memberCompanyList) {
if (company.isInvalidData()) continue;
if (StringUtils.isEmpty(company.getShortName())) {
log.warn("Empty or null short_name for company (id = {}), skipped", company.getId());
company.setInvalidData(true);
continue;
}
for (CompanyClearingCategory companyClearingCategory : company.getCompanyClearingCategoryList()) {
String workflowStatusStr = companyClearingCategory.getWorkflowStatus();
ServiceStatus workflowStatus = IEnumKey.getEnumByKey(ServiceStatus.class, workflowStatusStr);
if (!validWorkflowStatus.contains(workflowStatus)) {
log.warn("Invalid workflow_status {} for company_clearing_category for company.id {}, skipped", workflowStatus, company.getId());
companyClearingCategory.setInvalidData(true);
}
String clearingCategoryStr = companyClearingCategory.getCategory();
ClearingCategory clearingCategory = IEnumKey.getEnumByKey(ClearingCategory.class, clearingCategoryStr);
if (!validClearingCategory.contains(clearingCategory)) {
log.warn("Invalid category {} for company_clearing_category for company.id {}, skipped", workflowStatus, company.getId());
companyClearingCategory.setInvalidData(true);
}
}
for (CompanySymbols companySymbols : company.getMemberCompanySymbolsList()) {
String companySymbolStr = companySymbols.getCompanySymbol();
CompanySymbol companySymbol = IEnumKey.getEnumByKey(CompanySymbol.class, companySymbolStr);
if (!validCompanySymbols.contains(companySymbol)) {
log.warn("Invalid company_symbol {} for company.id {}, skipped", companySymbolStr, company.getId());
companySymbols.setInvalidData(true);
}
if (StringUtils.isEmpty(companySymbols.getCompanySymbolValue())) {
log.warn("Empty or null company_symbol_value for company.id {}, skipped", companySymbols.getCompanySymbolValue());
companySymbols.setInvalidData(true);
}
}
for (Contact contact : company.getContactList()) {
String contactTypeStr = contact.getContactType();
ContactTypes contactType = IEnumKey.getEnumByKey(ContactTypes.class, contactTypeStr);
if (!validContactTypes.contains(contactType)) {
log.warn("Invalid contact_type {} for company.id {}, skipped", contactTypeStr, company.getId());
contact.setInvalidData(true);
}
if (StringUtils.isEmpty(contact.getContactValue())) {
log.warn("Empty or null contact_value for contact {}, company.id {}", contactTypeStr, company.getId());
contact.setInvalidData(true);
}
}
for (ProfileDocument memberProfileDocument : company.getProfileDocumentList()) {
String documentTypeStr = memberProfileDocument.getDocumentType();
DocumentTypes documentType = IEnumKey.getEnumByKey(DocumentTypes.class, documentTypeStr);
if (!validDocumentTypes.contains(documentType)) {
log.warn("Invalid document_type {} for profile_document for company.id {}, skipped", documentTypeStr, company.getId());
memberProfileDocument.setInvalidData(true);
}
if (memberProfileDocument.getIssueDate() == null) {
log.warn("issue_date is null for profile_document, company.id {}", company.getId());
memberProfileDocument.setInvalidData(true);
}
if (StringUtils.isEmpty(memberProfileDocument.getIssuer())) {
log.warn("issuer is null or empty for profile_document, company.id {}", company.getId());
memberProfileDocument.setInvalidData(true);
}
if (StringUtils.isEmpty(memberProfileDocument.getNumber())) {
log.warn("number is null or empty for profile_document, company.id {}", company.getId());
memberProfileDocument.setInvalidData(true);
}
if (memberProfileDocument.getValidToDate() == null) {
log.warn("valid_to_date is null for profile_document, company.id {}", company.getId());
memberProfileDocument.setInvalidData(true);
}
}
for (Client memberClient : company.getClientList()) {
if (StringUtils.isEmpty(memberClient.getClientCode())) {
log.warn("client_code is null or empty for client, company.id {}", company.getId());
memberClient.setInvalidData(true);
}
if (StringUtils.isEmpty(memberClient.getMoneyAccount()) && StringUtils.isEmpty(memberClient.getDepoAccount())) {
log.warn("money_account and depo_account is null or empty for client, company.id {}", company.getId());
memberClient.setInvalidData(true);
}
}
}
return null;
}
}

27
clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/GatewayService.java
View file

@ -14,6 +14,7 @@ import ru.spcex.clearing.gatewayapi.config.InboundServerSettings;
import ru.spcex.clearing.gatewayapi.request.InboundRequest;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.clearing.AssetOperationRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.gateway.GatewayTaskRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.utilities.LimExportedRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
@ -58,6 +59,9 @@ public class GatewayService extends QueueConsumer implements InitializingBean {
callback(LimExportedRequest.class)
.setConsumer(this::requestOnLimit)
.forDestination(Consts.LIM_EXPORTED, callbacks::put);
callback(AssetOperationRequest.class)
.setConsumer(this::requestOnAsset)
.forDestination(Consts.ASSET_OPERATION, callbacks::put);
init();
}
@ -142,6 +146,29 @@ public class GatewayService extends QueueConsumer implements InitializingBean {
log.debug("LOSC task 2/2 complete (MKR section), response: {}", bodyResponse);
}
public void requestOnAsset(BaseRequest<AssetOperationRequest> request) {
log.debug("LOCM task received");
// RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
// if (requestInfoUpdate != null) return;
//
// logUnknownProperties(userRequest);
//
// String url = formingInboundUrl(inboundServerSettings.getPathLOCM());
// HttpHeaders httpHeaders = new HttpHeaders();
// httpHeaders.setContentType(MediaType.APPLICATION_JSON);
// httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
// InboundRequest inboundRequest = new InboundRequest();
// inboundRequest.setId(UUID.randomUUID());
// inboundRequest.setType("MEMBER_ON_DEMAND");
// inboundRequest.setDatetime(Instant.now());
// HttpEntity<InboundRequest> request = new HttpEntity<>(inboundRequest, httpHeaders);
//
// ResponseEntity<Map> response = restTemplate.exchange(url, HttpMethod.POST, request, Map.class);
// Map bodyResponse = response.getBody();
// log.debug("LOCM task complete, response: {}", bodyResponse);
}
private String formingInboundUrl(String path) {
return "%s://%s:%s/%s".formatted(
inboundServerSettings.getEnableSsl() ? "https" : "http",

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

@ -140,6 +140,7 @@ public interface Consts {
String EXPORT_COMPLETED = "export_completed";
String S_TRADES_IMPORTED = "s_trades-imported";
String LIM_EXPORTED = "lim_exported";
String ASSET_OPERATION = "asset_operation";
String JOURNAL_SERVICE = "journal-service-exported";
String ACCOUNT_TERMINATION = "account-termination";
String ACCOUNT_TERMINATION_STEP2 = "account-termination-step2";

51
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/clearing/AssetOperationRequest.java Normal file
View file

@ -0,0 +1,51 @@
package ru.spcex.clearing.platform.messaging.domain.cud.clearing;
import java.math.BigDecimal;
public class AssetOperationRequest {
private BigDecimal amount;
private BigDecimal quantity;
private String asset;
private String code;
private String firmId;
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
public BigDecimal getQuantity() {
return quantity;
}
public void setQuantity(BigDecimal quantity) {
this.quantity = quantity;
}
public String getAsset() {
return asset;
}
public void setAsset(String asset) {
this.asset = asset;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getFirmId() {
return firmId;
}
public void setFirmId(String firmId) {
this.firmId = firmId;
}
}