diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java index f3b7a523a..bafe94db1 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java @@ -48,6 +48,9 @@ public class SecurityController { all.addAll(stateLoader.getAllMetaTransformSpecificClass( IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class )); + all.addAll(stateLoader.getAllMetaTransformSpecificClass( + IMDGDistributedNames.Map_CurrencyPairSecurity, EquitySecurity.class + )); CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/ValidationConfig.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/ValidationConfig.java index 9a44dd2f5..dc586840c 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/ValidationConfig.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/ValidationConfig.java @@ -29,6 +29,7 @@ import ru.clearing.classes.statics.data.sdf.SDf21; import ru.clearing.classes.statics.data.sdf.SDf54; import ru.clearing.classes.statics.data.sdf.SDf55; import ru.clearing.classes.statics.data.sdf.SDf57; +import ru.clearing.classes.statics.data.security.CurrencyPairSecurity; import ru.clearing.classes.statics.data.security.MoneyMarketSecurity; import ru.clearing.classes.statics.data.security.Security; import ru.clearing.classes.statics.data.statement.Statement; @@ -88,6 +89,7 @@ public class ValidationConfig { Imdg imdgCompany; Imdg fixedIncomeSecurityImdg; Imdg equitySecurityImdg; + Imdg currencyPairSecurityImdg; Imdg imdgCompanySymbols; Imdg 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, diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistryBuilder.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistryBuilder.java index 22f69b014..3d1528604 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistryBuilder.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistryBuilder.java @@ -8,6 +8,7 @@ import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity; import ru.clearing.classes.statics.data.misc.Currency; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.clearing.classes.statics.data.security.CurrencyPairSecurity; import ru.clearing.classes.statics.data.security.MoneyMarketSecurity; import ru.clearing.classes.statics.data.security.Security; import ru.clearing.classes.statics.data.statement.Statement; @@ -37,6 +38,7 @@ public class RegistryBuilder { private final Imdg fixedIncomeSecurityImdg; private final Imdg moneyMarketSecurityImdg; private final Imdg equitySecurityImdg; + private final Imdg currencyPairSecurityImdg; private final Imdg 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; diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java index b7c122dc6..8be4f2591 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java @@ -8,6 +8,7 @@ import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity; import ru.clearing.classes.statics.data.misc.Currency; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.clearing.classes.statics.data.security.CurrencyPairSecurity; import ru.clearing.classes.statics.data.security.MoneyMarketSecurity; import ru.clearing.classes.statics.data.security.Security; import ru.clearing.classes.statics.data.statement.Statement; @@ -37,6 +38,7 @@ public class RegistrySecurityBuilder { private final Imdg fixedIncomeSecurityImdg; private final Imdg moneyMarketSecurityImdg; private final Imdg equitySecurityImdg; + private final Imdg currencyPairSecurityImdg; private final Imdg 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; diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/STradesValidationRule.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/STradesValidationRule.java index 6b132d5f8..52afe9784 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/STradesValidationRule.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/STradesValidationRule.java @@ -33,7 +33,8 @@ public enum STradesValidationRule implements IValidationRule 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) { diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf20ValidationRule.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf20ValidationRule.java index 2552d0afe..ce411bc43 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf20ValidationRule.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf20ValidationRule.java @@ -7,6 +7,7 @@ import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.classes.statics.data.sdf.SDf20; +import ru.clearing.classes.statics.data.security.CurrencyPairSecurity; import ru.clearing.classes.statics.data.security.Security; import ru.spcex.clearing.error.ClearingError; import ru.spcex.clearing.imdg.IMDGDistributedNames; @@ -107,7 +108,8 @@ public enum Sdf20ValidationRule implements IValidationRule 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) { diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/SecurityBySecurityCodeValidationRule.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/SecurityBySecurityCodeValidationRule.java index 49fe1ef3c..f1d52f297 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/SecurityBySecurityCodeValidationRule.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/SecurityBySecurityCodeValidationRule.java @@ -36,7 +36,8 @@ public class SecurityBySecurityCodeValidationRule implements IValidationRule< SecuritySelector 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) { diff --git a/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/SecurityService.java b/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/SecurityService.java index 8aa3e60d1..8ec12b60e 100644 --- a/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/SecurityService.java +++ b/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/SecurityService.java @@ -7,10 +7,12 @@ import ru.spcex.clearing.gatewayapi.controller.inbound.request.WithSecurityId; import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.*; import ru.spcex.clearing.gatewayapi.service.adapter.SecurityRequestAdapter; import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.company.CurrencyPairSecurityGatewayRequest; import ru.spcex.clearing.platform.messaging.domain.cud.company.EquitySecurityGatewayRequest; import ru.spcex.clearing.platform.messaging.domain.cud.company.FixedIncomeGatewayRequest; import ru.spcex.clearing.platform.messaging.domain.cud.company.SecurityFondGatewayRequest; import ru.spcex.clearing.platform.messaging.domain.cud.securitites.*; +import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest; import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; import ru.spcex.platform.enumeration.InstrumentType; import ru.spcex.platform.utils.log.ExceptionUtils; @@ -68,13 +70,22 @@ public class SecurityService { fillRequest(securityGatewayRequest, security, listingRequests, couponPeriodRequests, cashFlowRequests); log.debug("Send request to DESTINATION_SECURITY_BOND_GATEWAY"); kafkaSender.sendRequestToQueue(Consts.DESTINATION_SECURITY_BOND_GATEWAY, securityGatewayRequest); - } else { + } else if (InstrumentType.EQTY.equalsByKey(security.getInstrumentType())) { EquitySecurityNewRequest equitySecurityNewRequest = securityRequestAdapter.toEquitySecurityNewRequest(security); securityGatewayRequest = new EquitySecurityGatewayRequest(equitySecurityNewRequest); fillRequest(securityGatewayRequest, security, listingRequests, couponPeriodRequests, cashFlowRequests); log.debug("Send request to DESTINATION_SECURITY_BOND_GATEWAY"); kafkaSender.sendRequestToQueue(Consts.DESTINATION_SECURITY_EQTY_GATEWAY, securityGatewayRequest); +// } else if (InstrumentType.CRNC.equalsByKey(security.getInstrumentType())) { // todo будет отдельная задача +// CurrencyPairSecurityNewRequest currencyPairSecurityNewRequest = securityRequestAdapter.toCurrencyPairSecurityNewRequest(security); +// securityGatewayRequest = new CurrencyPairSecurityGatewayRequest(currencyPairSecurityNewRequest); +// fillRequest(securityGatewayRequest, security, listingRequests, couponPeriodRequests, cashFlowRequests); +// log.debug("Send request to DESTINATION_SECURITY_BOND_GATEWAY"); +// kafkaSender.sendRequestToQueue(Consts.DESTINATION_SECURITY_CURRENCY_GATEWAY, securityGatewayRequest); + } else { + log.error("Unknown instrumentType={}", security.getInstrumentType()); } + } catch (Throwable e) { log.error("{}", ExceptionUtils.getStackTrace(e)); } diff --git a/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/SecurityRequestAdapter.java b/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/SecurityRequestAdapter.java index f408dd343..f95128a26 100644 --- a/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/SecurityRequestAdapter.java +++ b/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/SecurityRequestAdapter.java @@ -6,6 +6,7 @@ import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.Fond import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.IncomeListing; import ru.spcex.clearing.gatewayapi.controller.inbound.request.listing.fond.Nominal; import ru.spcex.clearing.platform.messaging.domain.cud.securitites.*; +import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest; import ru.spcex.platform.utils.text.TextUtil; @Service @@ -46,6 +47,25 @@ public class SecurityRequestAdapter { return equitySecurityNewRequest; } + public CurrencyPairSecurityNewRequest toCurrencyPairSecurityNewRequest(FondSecurity fondSecurity) { +// CurrencyPairSecurityNewRequest currencyPairSecurityNewRequest = new CurrencyPairSecurityNewRequest(); +// currencyPairSecurityNewRequest.setInstrumentType(fondSecurity.getInstrumentType()); +// currencyPairSecurityNewRequest.setSecuritySymbol(fondSecurity.getSecuritySymbol()); +// currencyPairSecurityNewRequest.setShortName(fondSecurity.getShortName()); +// currencyPairSecurityNewRequest.setFullName(fondSecurity.getFullName()); +// currencyPairSecurityNewRequest.setMarket(fondSecurity.getMarket()); +// currencyPairSecurityNewRequest.setCurrencyPairId(fondSecurity.getCurrencyPairId()); +// currencyPairSecurityNewRequest.setLotSize(fondSecurity.getLotSize()); +// currencyPairSecurityNewRequest.setMinStep(fondSecurity.getMinStep()); +// currencyPairSecurityNewRequest.setBaseUnitSize(fondSecurity.getBaseUnitSize()); +// currencyPairSecurityNewRequest.setSettlementType(fondSecurity.getSettlementType()); +// currencyPairSecurityNewRequest.setWorkflowStatus(fondSecurity.getWorkflowStatus()); +// currencyPairSecurityNewRequest.setSettlementOrganization(fondSecurity.getSettlementOrganization()); +// currencyPairSecurityNewRequest.setClearingOrganization(fondSecurity.getClearingOrganization()); +// return currencyPairSecurityNewRequest; + throw new IllegalStateException("TODO currency pair"); + } + public ListingNewRequest toIncomeListing(IncomeListing incomeListing) { ListingNewRequest listingNewRequest = new ListingNewRequest(); String code = incomeListing.getCode(); @@ -56,6 +76,7 @@ public class SecurityRequestAdapter { listingNewRequest.setSymbolCode(incomeListing.getSymbolCode()); listingNewRequest.setSymbolName(incomeListing.getSymbolName()); listingNewRequest.setLotSize(incomeListing.getLotSize()); +// listingNewRequest.setMinStep(incomeListing.getMinStep()); listingNewRequest.setTradingCurrency(incomeListing.getTradingCurrency()); listingNewRequest.setWorkflowStatus(incomeListing.getWorkflowStatus()); return listingNewRequest; diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyPairSecurityService.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyPairSecurityService.java new file mode 100644 index 000000000..41f805815 --- /dev/null +++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyPairSecurityService.java @@ -0,0 +1,201 @@ +package ru.spcex.clearing.securities.service.cud; + +import org.apache.kafka.clients.consumer.Consumer; +import org.apache.kafka.clients.producer.Producer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.InitializingBean; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.util.StringUtils; +import ru.clearing.classes.statics.data.security.CurrencyPairSecurity; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.BaseRequest; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityUpdateRequest; +import ru.spcex.clearing.platform.messaging.service.QueueConsumer; +import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; +import ru.spcex.clearing.securities.validation.ValidationProvider; +import ru.spcex.clearing.util.security.UserRoleVerification; +import ru.spcex.clearing.util.services.RequestHelper; +import ru.spcex.clearing.validation.common.ValidationHelper; +import ru.spcex.platform.enumeration.UserRole; +import ru.spcex.platform.enumeration.WorkflowStatus; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgId; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.error.ValidationException; +import ru.spcex.platform.utils.validation.IValidator; + +import java.time.Instant; +import java.util.Optional; + +@Service +public class CurrencyPairSecurityService extends QueueConsumer implements InitializingBean { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final Imdg 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 kafkaQueue, + Producer 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 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 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 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 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; + } + +} diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/GatewaySecurityService.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/GatewaySecurityService.java index 91199a8ad..c9ffb4691 100644 --- a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/GatewaySecurityService.java +++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/GatewaySecurityService.java @@ -1,6 +1,7 @@ package ru.spcex.clearing.securities.service.cud; import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.exception.ExceptionUtils; import org.apache.kafka.clients.consumer.Consumer; import org.apache.kafka.clients.producer.Producer; import org.slf4j.Logger; @@ -20,10 +21,12 @@ import ru.clearing.classes.statics.data.security.Security; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.BaseRequest; import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.company.CurrencyPairSecurityGatewayRequest; import ru.spcex.clearing.platform.messaging.domain.cud.company.EquitySecurityGatewayRequest; import ru.spcex.clearing.platform.messaging.domain.cud.company.FixedIncomeGatewayRequest; import ru.spcex.clearing.platform.messaging.domain.cud.company.SecurityFondGatewayRequest; import ru.spcex.clearing.platform.messaging.domain.cud.securitites.*; +import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest; import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.securities.validation.ValidationProvider; @@ -61,6 +64,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin private final FixedIncomeSecurityService fixedIncomeSecurityService; private final EquitySecurityService equitySecurityService; private final MoneyMarketSecurityService moneyMarketSecurityService; + private final CurrencyPairSecurityService currencyPairSecurityService; private final ListingService listingService; private final CouponPeriodService couponPeriodService; private final FixedIncomeCashFlowService fixedIncomeCashFlowService; @@ -84,6 +88,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin FixedIncomeSecurityService fixedIncomeSecurityService, EquitySecurityService equitySecurityService, MoneyMarketSecurityService moneyMarketSecurityService, + CurrencyPairSecurityService currencyPairSecurityService, ListingService listingService, CouponPeriodService couponPeriodService, FixedIncomeCashFlowService fixedIncomeCashFlowService) { @@ -92,6 +97,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class); this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class); this.moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class); + this.currencyPairSecurityService = currencyPairSecurityService; this.listingImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Listing, Listing.class); this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class); this.fixedIncomeCashFlowImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class); @@ -123,6 +129,10 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin callback(MoneyMarketSecurityNewGatewayRequest.class) .setFunction(this::newMoneyMarketSecurity) .forDestination(Consts.DESTINATION_GATEWAY_MONEY_MARKET_SECURITY, callbacks::put); + callback(CurrencyPairSecurityGatewayRequest.class) + .setFunction(this::newSecurities) + .forDestination(Consts.DESTINATION_SECURITY_CURRENCY_GATEWAY, callbacks::put); + imdgProvider.waitAvailable(); init(); } @@ -226,6 +236,28 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin security = equitySecurityService.updateEquity0(updateRequest); } } + if (InstrumentType.CRNC.equalsByKey(req.getSecurityType())) { +// CurrencyPairSecurityGatewayRequest currencyPairSecurityGatewayRequest = (CurrencyPairSecurityGatewayRequest) req; +// CurrencyPairSecurityNewRequest currencyPairRequest = currencyPairSecurityGatewayRequest.getSecurity(); +// if (StringUtils.isEmpty(currencyPairRequest.getSecuritySymbol())) { +// log.warn("Skip creating CurrencyPairSecurity without securityId: uuid: {}", req.getUuid()); +// return null; +// } +// log.debug("Processed request with securitySymbol: {}", currencyPairRequest.getSecuritySymbol()); +// currencyPairRequest.setIssuerId(companyId); +// log.trace("EquitySecurityNewRequest - FOND"); +// String securitySymbol = currencyPairRequest.getSecuritySymbol(); +// security = findSecurityBySecuritySymbol(currencyPairSecurityImdg, securitySymbol); +// +// if (security == null) { +// security = currencyPairSecurityService.newEquity0(currencyPairRequest); +// } else { +// EquitySecurityUpdateRequest updateRequest = toUpdateRequest(security, currencyPairRequest); +// security = currencyPairSecurityService.updateEquity0(updateRequest); +// } +// //fixme currencypair будет отдельная задача + throw new IllegalStateException("todo CRNC"); + } } catch (ValidationException expected) { if (security == null) { log.error("Error create or update issue: {}", messageResolver.resolve(expected.getEnumMsg())); diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java index 0e529f5b8..1f359064e 100644 --- a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java +++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java @@ -1,17 +1,26 @@ package ru.spcex.clearing.securities.validation; import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity; +import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeCashFlow; import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity; +import ru.clearing.classes.statics.data.misc.Market; +import ru.clearing.classes.statics.data.security.CurrencyPairSecurity; import ru.clearing.classes.statics.data.security.MoneyMarketSecurity; +import ru.clearing.platform.dictionary.InstrumentTypeDictionary; import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.account.AccountSymbolsNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; import ru.spcex.clearing.platform.messaging.domain.cud.securitites.*; +import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityUpdateRequest; import ru.spcex.clearing.securities.errors.SecuritiesError; import ru.spcex.clearing.securities.validation.rule.*; -import ru.spcex.clearing.validation.common.rules.EndDtAfterStartDtRule; -import ru.spcex.clearing.validation.common.rules.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 companyImdg; private final Imdg currencyImdg; private final Imdg couponPeriodImdg; + private final Imdg 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 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 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 currencyPairSecurityNewValidator() { + return equityRequest -> { + ImdgValidationContext 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 currencyPairImdg = context.obtainMap( +// IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class +// ); +// Long securityId = Long.valueOf(securitySymbol); +// Collection 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 currencyPairSecurityUpdateValidator() { + return equityRequest -> { + ImdgValidationContext 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 currencyPairImdg = context.obtainMap( +// IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class +// ); +// Long securityId = Long.valueOf(securitySymbol); +// Collection 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 currencyPairSecurityDeleteValidator() { + return equityRequest -> { + ImdgValidationContext 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() + ); + }; + } } diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/SecuritySelector.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/SecuritySelector.java index c7c1a375e..31d4f5295 100644 --- a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/SecuritySelector.java +++ b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/SecuritySelector.java @@ -13,19 +13,23 @@ public class SecuritySelector { private final Imdg fixedIncomeSecurityImdg; private final Imdg moneyMarketSecurityImdg; private final Imdg equitySecurity; + private final Imdg currencyPairSecurity; public SecuritySelector(ImdgProvider imdgProvider, Class 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 fixedIncomeSecurityImdg, Imdg moneyMarketSecurityImdg, - Imdg equitySecurity) { + Imdg equitySecurity, + Imdg 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 { 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 } } diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java index 94189450a..e9f3cbdea 100644 --- a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java @@ -16,6 +16,7 @@ public interface Consts { String DESTINATION_SECURITY_BOND_GATEWAY = "security-bond-gateway-request-new"; String DESTINATION_SECURITY_EQTY_GATEWAY = "security-eqty-gateway-request-new"; + String DESTINATION_SECURITY_CURRENCY_GATEWAY = "security-currency-pair-gateway-request-new"; String DESTINATION_FIXED_INCOME_CASH_FLOW_NEW = "fixed-income-cash-flow-new"; String DESTINATION_FIXED_INCOME_CASH_FLOW_UPDATE = "fixed-income-cash-flow-update"; diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/company/CurrencyPairSecurityGatewayRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/company/CurrencyPairSecurityGatewayRequest.java new file mode 100644 index 000000000..57e16088f --- /dev/null +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/company/CurrencyPairSecurityGatewayRequest.java @@ -0,0 +1,24 @@ +package ru.spcex.clearing.platform.messaging.domain.cud.company; + +import com.fasterxml.jackson.annotation.JsonProperty; +import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest; + +public class CurrencyPairSecurityGatewayRequest extends SecurityFondGatewayRequest { + @JsonProperty + private CurrencyPairSecurityNewRequest security; + + public CurrencyPairSecurityGatewayRequest() { + } + + public CurrencyPairSecurityGatewayRequest(CurrencyPairSecurityNewRequest security) { + this.security = security; + } + + public CurrencyPairSecurityNewRequest getSecurity() { + return security; + } + + public void setSecurity(CurrencyPairSecurityNewRequest security) { + this.security = security; + } +}