From 2b33c99f87386fc0d5391e73ca0be38de949b329 Mon Sep 17 00:00:00 2001 From: etreschenkov Date: Wed, 15 Apr 2026 16:23:59 +0300 Subject: [PATCH] http://jira.mfd.msk:8088/browse/CLS-959 --- .../settings/DefaultManagementSettings.java | 10 +- .../listener/OrderCurrencyListener.java | 64 +++++++++++- .../management/listener/TaskListener.java | 40 +++++++- .../management/service/ImdgQueryService.java | 24 ++++- .../service/OrderCalculationService.java | 4 +- .../OrderCurrencyTriExportService.java | 99 +++++++++++++++++++ .../src/main/resources/application.properties | 2 + .../platform/enumeration/OrderStatus.java | 18 ++++ .../ru/spcex/platform/enumeration/Task.java | 5 +- .../platform/messaging/domain/Consts.java | 4 +- .../OrderCurrencyStatusUpdateRequest.java | 20 ++++ 11 files changed, 276 insertions(+), 14 deletions(-) create mode 100644 clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCurrencyTriExportService.java create mode 100644 platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OrderStatus.java create mode 100644 platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/order/OrderCurrencyStatusUpdateRequest.java diff --git a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/config/settings/DefaultManagementSettings.java b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/config/settings/DefaultManagementSettings.java index e9d57d19d..c15ec86e2 100644 --- a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/config/settings/DefaultManagementSettings.java +++ b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/config/settings/DefaultManagementSettings.java @@ -14,7 +14,7 @@ public class DefaultManagementSettings { private HazelcastClientParams hazelcast; private KafkaConsumerSettings kafkaConsumer; private KafkaProducerSettings kafkaProducer; - private String clearingSystem; + private String fileStoragePath; public HazelcastClientParams getHazelcast() { return hazelcast; @@ -40,11 +40,11 @@ public class DefaultManagementSettings { this.kafkaProducer = kafkaProducer; } - public String getClearingSystem() { - return clearingSystem; + public String getFileStoragePath() { + return fileStoragePath; } - public void setClearingSystem(String clearingSystem) { - this.clearingSystem = clearingSystem; + public void setFileStoragePath(String fileStoragePath) { + this.fileStoragePath = fileStoragePath; } } diff --git a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/OrderCurrencyListener.java b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/OrderCurrencyListener.java index 9a5cf9a82..c397df83a 100644 --- a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/OrderCurrencyListener.java +++ b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/OrderCurrencyListener.java @@ -3,6 +3,7 @@ package ru.spcex.clearing.dflt.management.listener; import java.math.BigDecimal; import java.time.Instant; import java.time.LocalDate; +import java.util.Arrays; import java.util.Optional; import java.util.function.Function; import org.apache.kafka.clients.consumer.Consumer; @@ -18,6 +19,7 @@ import ru.clearing.classes.statics.data.misc.Listing; import ru.clearing.classes.statics.data.misc.Market; import ru.clearing.classes.statics.data.misc.OrderCurrency; import ru.clearing.classes.statics.data.misc.OvernightSettings; +import ru.clearing.classes.statics.data.misc.SOrders; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.classes.statics.data.security.Rates; @@ -31,12 +33,14 @@ 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.order.OrderCompanyNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.order.OrderCompanyUpdateRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.order.OrderCurrencyStatusUpdateRequest; import ru.spcex.clearing.platform.messaging.domain.cud.order.OrderCurrencyUpdateRequest; import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.platform.messaging.service.Status; import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.platform.enumeration.MarketType; +import ru.spcex.platform.enumeration.OrderStatus; import ru.spcex.platform.enumeration.OvernightType; import ru.spcex.platform.enumeration.SettleCode; import ru.spcex.platform.enumeration.Side; @@ -55,6 +59,7 @@ public class OrderCurrencyListener extends QueueConsumer implements Initializing private final Imdg registryImdg; private final Imdg overnightSettingsImdg; private final Imdg orderCurrencyImdg; + private final Imdg sOrdersImdg; private final Function orderCurrencyUpdateValidator; private final Function overnightTypeUpdateValidator; private final Function orderCompanyNewValidator; @@ -81,6 +86,7 @@ public class OrderCurrencyListener extends QueueConsumer implements Initializing super(kafkaQueue, kafkaProducer); this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); this.overnightSettingsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_OvernightSettings, OvernightSettings.class); + this.sOrdersImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SOrders, SOrders.class);; this.orderCurrencyUpdateValidator = orderCurrencyUpdateValidator; this.overnightTypeUpdateValidator = overnightTypeUpdateValidator; this.orderCompanyNewValidator = orderCompanyNewValidator; @@ -110,6 +116,12 @@ public class OrderCurrencyListener extends QueueConsumer implements Initializing callback(CommonDeleteRequest.class) .setFunction(this::deleteCompany) .forDestination(Consts.ORDER_CURRENCY_COMPANY_DELETE, callbacks::put); + callback(OrderCurrencyStatusUpdateRequest.class) + .setConsumer(this::updateByImporter) + .forDestination(Consts.ORDER_CURRENCY_STATUS_UPDATE_IMPORTER, callbacks::put); + callback(OrderCurrencyStatusUpdateRequest.class) + .setConsumer(this::updateByFix) + .forDestination(Consts.ORDER_CURRENCY_STATUS_UPDATE_FIX, callbacks::put); init(); } @@ -179,7 +191,7 @@ public class OrderCurrencyListener extends QueueConsumer implements Initializing Market market = imdgQueryService.getSpotMarket(); Listing listing = imdgQueryService.findListing(rgs, market.getCode()); //мб возвращать вместе с листингом? - CurrencyPairDictionary currPair = imdgQueryService.getCurrencyPairDictionaryByListing(listing); + CurrencyPairDictionary currPair = imdgQueryService.getCurrencyPairDictionaryBySecurityId(listing.getSecurityId()); Rates rate = imdgQueryService.getRate(currPair.getBaseCurrency(), LocalDate.now()); var pair = new Pair<>(orderT0, orderT1); @@ -335,4 +347,54 @@ public class OrderCurrencyListener extends QueueConsumer implements Initializing orderCurrencyImdg.delete(counterOrder); return null; } + + private void updateByImporter(BaseRequest req) { + OrderCurrencyStatusUpdateRequest payload = req.getRequestPayload(); + for (Long orderId : payload.getIds()) { + SOrders sOrder = sOrdersImdg.getSingleObjectByID(orderId); + OrderCurrency orderCurrency = orderCurrencyImdg.getSingleObjectByID(orderId); + OrderStatus status = resolveStatusByImportState(sOrder.getState()); + if (status == null) { + continue; + } + orderCurrency.setStatus(status.getKey()); + orderCurrencyImdg.update(orderCurrency); + } + } + private void updateByFix(BaseRequest req) { + OrderCurrencyStatusUpdateRequest payload = req.getRequestPayload(); + for (Long orderId : payload.getIds()) { + SOrders sOrder = sOrdersImdg.getSingleObjectByID(orderId); + OrderCurrency orderCurrency = orderCurrencyImdg.getSingleObjectByID(orderId); + OrderStatus status = resolveStatusByFixState(sOrder.getState()); + if (status == null) { + continue; + } + orderCurrency.setStatus(status.getKey()); + orderCurrencyImdg.update(orderCurrency); + } + } + + private OrderStatus resolveStatusByImportState(String state) { + if (Arrays.asList("0", "1", "15").contains(state)) { + return null; + } + if (state.equals("3")) { + return OrderStatus.NEW; + } else { + return OrderStatus.REJECTED; + } + } + + private OrderStatus resolveStatusByFixState(String state) { + return switch (state) { + case "0" -> OrderStatus.NEW; + case "1" -> OrderStatus.PTFL; + case "2" -> OrderStatus.FILL; + case "4" -> OrderStatus.CNCL; + case "5" -> OrderStatus.REPL; + case "8" -> OrderStatus.REJECTED; + default -> null; + }; + } } diff --git a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/TaskListener.java b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/TaskListener.java index d11692838..c289ed898 100644 --- a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/TaskListener.java +++ b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/listener/TaskListener.java @@ -1,5 +1,11 @@ package ru.spcex.clearing.dflt.management.listener; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.time.LocalTime; +import java.time.format.DateTimeFormatter; import java.util.Collection; import java.util.Optional; import org.apache.kafka.clients.consumer.Consumer; @@ -9,20 +15,26 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.misc.OrderCurrency; import ru.clearing.classes.statics.data.misc.OvernightSettings; import ru.clearing.classes.statics.data.registry.Registry; +import ru.spcex.clearing.dflt.management.config.settings.DefaultManagementSettings; import ru.spcex.clearing.dflt.management.service.ImdgQueryService; +import ru.spcex.clearing.dflt.management.service.OrderCurrencyTriExportService; import ru.spcex.clearing.dflt.management.service.SpotOvernightOrderService; import ru.spcex.clearing.dflt.management.service.SwapOvernightOrderService; 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.schedule.LauncherCommandRequest; import ru.spcex.clearing.platform.messaging.service.QueueConsumer; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; import ru.spcex.platform.enumeration.OvernightType; import ru.spcex.platform.enumeration.Task; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.utils.enumeration.IEnumKey; +import ru.spcex.platform.utils.log.ExceptionUtils; @Service public class TaskListener extends QueueConsumer implements InitializingBean { @@ -31,6 +43,10 @@ public class TaskListener extends QueueConsumer implements InitializingBean { private final Imdg registryImdg; private final SwapOvernightOrderService swapOvernightOrderService; private final SpotOvernightOrderService spotOvernightOrderService; + private final OrderCurrencyTriExportService orderCurrencyTriExportService; + private final KafkaSender kafkaSender; + private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyymmddHHmmssSSS"); + private final Path storagePath; @Autowired public TaskListener(Consumer kafkaQueue, @@ -38,12 +54,18 @@ public class TaskListener extends QueueConsumer implements InitializingBean { ImdgQueryService imdgQueryService, ImdgProvider imdgProvider, SwapOvernightOrderService swapOvernightOrderService, - SpotOvernightOrderService spotOvernightOrderService) { + SpotOvernightOrderService spotOvernightOrderService, + OrderCurrencyTriExportService orderCurrencyTriExportService, + KafkaSender kafkaSender, + DefaultManagementSettings defaultManagementSettings) { super(kafkaQueue, kafkaProducer); this.imdgQueryService = imdgQueryService; this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); this.swapOvernightOrderService = swapOvernightOrderService; this.spotOvernightOrderService = spotOvernightOrderService; + this.orderCurrencyTriExportService = orderCurrencyTriExportService; + this.kafkaSender = kafkaSender; + this.storagePath = Path.of(defaultManagementSettings.getFileStoragePath()); } @Override @@ -51,6 +73,9 @@ public class TaskListener extends QueueConsumer implements InitializingBean { callback(LauncherCommandRequest.class) .setConsumer(this::createOrder) .forDestination(Task.CROR.topic(), callbacks::put); + callback(LauncherCommandRequest.class) + .setConsumer(this::exportToTriAndSendToFix) + .forDestination(Task.SDOR.topic(), callbacks::put); init(); } @@ -88,6 +113,19 @@ public class TaskListener extends QueueConsumer implements InitializingBean { log.info("CROR createOrder finished"); } + private void exportToTriAndSendToFix(BaseRequest req) { + + try { + Collection orders = imdgQueryService.getClccOrderCurrencyIds(); + String content = orderCurrencyTriExportService.exportToTri(orders); + Path fileName = storagePath.resolve(String.format("KS_TS_ORDERS_%s.tri", + LocalTime.now().format(formatter))); + Files.writeString(fileName, content, StandardCharsets.UTF_8); + kafkaSender.sendRequestToQueue(Consts.SDOR_FIX_TASK, req.getRequestPayload()); + } catch (IOException e) { + log.error("Error while import order currency to tri file: {}", ExceptionUtils.getStackTrace(e)); + } + } private OvernightType resolveOvernightType(Registry registry) { Optional settingsOpt = diff --git a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/ImdgQueryService.java b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/ImdgQueryService.java index 76f2c501a..f73e4c5d3 100644 --- a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/ImdgQueryService.java +++ b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/ImdgQueryService.java @@ -10,6 +10,7 @@ import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.company.CompanyRoleSet; import ru.clearing.classes.statics.data.misc.Listing; import ru.clearing.classes.statics.data.misc.Market; +import ru.clearing.classes.statics.data.misc.OrderCurrency; import ru.clearing.classes.statics.data.misc.OvernightSettings; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; @@ -42,6 +43,7 @@ public class ImdgQueryService { private final Imdg ratesImdg; private final Imdg registryImdg; private final Imdg overnightSettingsImdg; + private final Imdg orderCurrencyImdg; public ImdgQueryService(ImdgProvider imdgProvider) { @@ -57,6 +59,7 @@ public class ImdgQueryService { this.ratesImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Rates, Rates.class); this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); this.overnightSettingsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_OvernightSettings, OvernightSettings.class); + this.orderCurrencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_OrderCurrency, OrderCurrency.class); } public Collection getCurrencyRegistry() { ImdgPredicateBuilder builder = registryImdg.predicateBuilder(); @@ -68,6 +71,23 @@ public class ImdgQueryService { return registryImdg.getCollectionIdsByPredicate(registryPredicate); } + public Collection getClccOrderCurrencyIds() { + ImdgPredicateBuilder builder = orderCurrencyImdg.predicateBuilder(); + CompanyRoleSet companyRoleSet = companyRoleSetImdg.getFirstObjectByPredicate( + builder.equals("companyRole", CompanyRole.CLCC.getKey()) + ); + + ImdgPredicate clccOrderPredicate = builder.and( + builder.equals("status", "CRET"), + builder.or( + builder.equals("companyId", companyRoleSet.getCompanyId()), + builder.equals("counterPartyId", companyRoleSet.getCompanyId()) + ) + ); + + return orderCurrencyImdg.getCollectionObjectsByPredicate(clccOrderPredicate); + } + public Optional findOvernightSettingsByCompany(Long companyId) { ImdgPredicateBuilder builder = overnightSettingsImdg.predicateBuilder(); ImdgPredicate predicate = builder.and( @@ -170,8 +190,8 @@ public class ImdgQueryService { return riskParameter.getQuoteValue(); } - public CurrencyPairDictionary getCurrencyPairDictionaryByListing(Listing listing) { - CurrencyPairSecurity security = currencyPairSecurityImdg.getSingleObjectByID(listing.getSecurityId()); + public CurrencyPairDictionary getCurrencyPairDictionaryBySecurityId(Long securityId) { + CurrencyPairSecurity security = currencyPairSecurityImdg.getSingleObjectByID(securityId); return currencyPairDictionaryImdg.getSingleObjectByID(security.getCurrencyPairId()); } diff --git a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCalculationService.java b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCalculationService.java index ecf6eade8..b4a237e1c 100644 --- a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCalculationService.java +++ b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCalculationService.java @@ -32,7 +32,7 @@ public class OrderCalculationService { Registry registry = context.getRegistry(); Listing listing = context.getListing(); - CurrencyPairDictionary pair = imdgQueryService.getCurrencyPairDictionaryByListing(listing); + CurrencyPairDictionary pair = imdgQueryService.getCurrencyPairDictionaryBySecurityId(listing.getSecurityId()); BigDecimal s = imdgQueryService.defineTransferRate(pair.getId(), registry.getSecuritySymbol()); BigDecimal n = transferDateService.numberOfDaysOfTransfer(); @@ -52,7 +52,7 @@ public class OrderCalculationService { Registry registry = context.getRegistry(); Listing listing = context.getListing(); - CurrencyPairDictionary pair = imdgQueryService.getCurrencyPairDictionaryByListing(listing); + CurrencyPairDictionary pair = imdgQueryService.getCurrencyPairDictionaryBySecurityId(listing.getSecurityId()); BigDecimal s = imdgQueryService.defineTransferRate(pair.getId(), registry.getSecuritySymbol()); BigDecimal n = transferDateService.numberOfDaysOfTransfer(); diff --git a/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCurrencyTriExportService.java b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCurrencyTriExportService.java new file mode 100644 index 000000000..6716cd297 --- /dev/null +++ b/clearing-parent/default-management/src/main/java/ru/spcex/clearing/dflt/management/service/OrderCurrencyTriExportService.java @@ -0,0 +1,99 @@ +package ru.spcex.clearing.dflt.management.service; + +import java.math.BigDecimal; +import java.nio.charset.StandardCharsets; +import java.time.LocalDate; +import java.util.Collection; +import java.util.List; +import java.util.StringJoiner; +import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.misc.OrderCurrency; +import ru.clearing.classes.statics.data.security.Rates; +import ru.clearing.platform.dictionary.CurrencyPairDictionary; +import ru.spcex.platform.enumeration.OvernightType; +import ru.spcex.platform.enumeration.Side; + +@Service +public class OrderCurrencyTriExportService { + private final ImdgQueryService imdgQueryService; + private static final String ACTION = "Ввод внебиржевой заявки"; + + public OrderCurrencyTriExportService( + ImdgQueryService imdgQueryService) { + this.imdgQueryService = imdgQueryService; + } + + /** + * Возвращает содержимое tri-файла в виде строки. + */ + public String exportToTri(Collection orders) { + return orders.stream() + .map(this::toTriLine) + .reduce((a, b) -> a + System.lineSeparator() + b) + .orElse(""); + } + + /** + * Возвращает содержимое tri-файла в байтах, чтобы можно было отдать как файл. + */ + public byte[] exportToTriBytes(List orders) { + return exportToTri(orders).getBytes(StandardCharsets.UTF_8); + } + + private String toTriLine(OrderCurrency orderCurrency) { + StringJoiner joiner = new StringJoiner(";", "", ";"); + joiner.add("TRANS_ID=" + nullSafe(orderCurrency.getId())); + joiner.add("CLASSCODE=" + nullSafe(orderCurrency.getMarket())); + joiner.add("ACTION=" + ACTION); + joiner.add("Торговый счет=" + nullSafe(orderCurrency.getAccount())); + joiner.add("К/П=" + mapSide(orderCurrency.getSide())); + joiner.add("Класс=" + nullSafe(orderCurrency.getMarket())); + joiner.add("Инструмент=" + nullSafe(orderCurrency.getSecuritySymbol())); + joiner.add("Контрагент=" + nullSafe(orderCurrency.getCounterTradingCode())); + joiner.add("Цена=" + formatDecimal(orderCurrency.getPrice())); + joiner.add("Количество=" + formatDecimal(orderCurrency.getQuantityLot())); + joiner.add("Примечание=" + nullSafe(orderCurrency.getAccount())); + joiner.add("Ссылка="); + joiner.add("Код расчетов=" + nullSafe(orderCurrency.getSettleCode())); + joiner.add("На заявку №="); + joiner.add("Базовый курс=" + resolveBaseRate(orderCurrency)); + + return joiner.toString(); + } + + private String mapSide(String side) { + if (Side.BUY.equalsByKey(side)) { + return "Покупка"; + } + if (Side.SELL.equalsByKey(side)) { + return "Продажа"; + } + throw new IllegalArgumentException("Неизвестное значение side: " + side); + } + + private String resolveBaseRate(OrderCurrency orderCurrency) { + if (OvernightType.SPOT.equalsByKey(orderCurrency.getOvernightType())) { + return ""; + } + + CurrencyPairDictionary currencyPairDictionary = imdgQueryService.getCurrencyPairDictionaryBySecurityId(orderCurrency.getSecurityId()); + String baseCurrency = currencyPairDictionary.getBaseCurrency(); + Rates rates = imdgQueryService.getRate(currencyPairDictionary.getBaseCurrency(), LocalDate.now()); + + if (rates == null || rates.getValue() == null) { + throw new IllegalStateException( + "Не найден активный курс для валюты " + baseCurrency + " на дату " + LocalDate.now() + ); + } + + return formatDecimal(rates.getValue()); + } + + private String formatDecimal(BigDecimal value) { + return value == null ? "" : value.toPlainString(); + } + + private String nullSafe(Object value) { + return value == null ? "" : String.valueOf(value); + } +} diff --git a/clearing-parent/default-management/src/main/resources/application.properties b/clearing-parent/default-management/src/main/resources/application.properties index e306c571e..0cc34e726 100644 --- a/clearing-parent/default-management/src/main/resources/application.properties +++ b/clearing-parent/default-management/src/main/resources/application.properties @@ -1,4 +1,6 @@ spring.main.web-application-type=none +default-management.file-storage-path=/opt/storage/csv-impoter/ + default-management.hazelcast.cluster-members=127.0.0.1:5701 default-management.hazelcast.login=dev default-management.hazelcast.password=dev-pass diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OrderStatus.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OrderStatus.java new file mode 100644 index 000000000..b9d10a614 --- /dev/null +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OrderStatus.java @@ -0,0 +1,18 @@ +package ru.spcex.platform.enumeration; + +import ru.spcex.platform.utils.enumeration.IEnumKey; + +public enum OrderStatus implements IEnumKey { + NEW("NEW"), PTFL("PTFL"), FILL("FILL"), CNCL("CNCL"), REPL("REPL"), REJECTED("RJCT"); + + private final String key; + + OrderStatus(String key) { + this.key = key; + } + + @Override + public String getKey() { + return key; + } +} diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/Task.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/Task.java index a9bde546f..1dc8d98a8 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/Task.java +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/Task.java @@ -62,8 +62,9 @@ public enum Task implements IEnumKey { makeFiles_MTCR("MTCR"), // Формирование файлов с МТКР CX84("CX84"), // Формирование отчета CCX84 GVTF("GVTF"), // Проведение сверки по регистрам AMAT и AMAF - LORT("LORT"), // Загрузка курсов валют - CROR("CROR"), // Загрузка курсов валют + LORT("LORT"), + CROR("CROR"), + SDOR("SDOR"), ; private final String key; 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 1bc4997a4..7253ea097 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 @@ -147,7 +147,9 @@ public interface Consts { String ORDER_CURRENCY_COMPANY_NEW = "order-currency-company-new"; String ORDER_CURRENCY_COMPANY_UPDATE = "order-currency-company-update"; String ORDER_CURRENCY_COMPANY_DELETE = "order-currency-company-delete"; - + String ORDER_CURRENCY_STATUS_UPDATE_IMPORTER = "order-currency-status-update-importer"; + String ORDER_CURRENCY_STATUS_UPDATE_FIX = "order-currency-status-update-fix"; + String SDOR_FIX_TASK = "sdor-fix-task"; String DESTINATION_SDF08_NEW = "s-df-08-new"; String DESTINATION_SDF02_NEW = "s-df-02-new"; diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/order/OrderCurrencyStatusUpdateRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/order/OrderCurrencyStatusUpdateRequest.java new file mode 100644 index 000000000..bc5da2613 --- /dev/null +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/order/OrderCurrencyStatusUpdateRequest.java @@ -0,0 +1,20 @@ +package ru.spcex.clearing.platform.messaging.domain.cud.order; + +import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.ArrayList; +import java.util.List; + +public class OrderCurrencyStatusUpdateRequest { + @JsonProperty + private List ids = new ArrayList<>(); + + public List getIds() { + return ids; + } + + public void addId(Long id) { + if (id != null) { + ids.add(id); + } + } +}