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

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

Browse source
This commit is contained in:
AKurakin 2024-03-21 19:51:04 +03:00
parent d1cf6da58e
commit b6ff7b091d
15 changed files with 504 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

201
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyPairSecurityService.java Normal file
View file

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

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

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

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

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

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

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

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

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

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

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