From 050c7423133c372b2f2e4bc504d28d11a7ff31c7 Mon Sep 17 00:00:00 2001 From: ialbert Date: Thu, 3 Aug 2023 19:14:41 +0300 Subject: [PATCH] SDF08/SDF21 --- .../clearing/config/SdfExecutorsConfig.java | 4 +- .../clearing/config/ValidationConfig.java | 20 ++- .../clearing/service/StatementService.java | 78 ++++++--- .../builder/RegistrySecurityBuilder.java | 150 ++++++++++++++++++ .../service/executors/Sdf08Executor.java | 15 +- .../validation/Sdf21ValidationRule.java | 64 ++++++++ .../service/validation/ValidationStored.java | 2 + .../platform/enumeration/InOutSDfType.java | 1 + .../platform/enumeration/OperationCode.java | 18 +++ .../spcex/platform/enumeration/SdfTable.java | 1 + 10 files changed, 322 insertions(+), 31 deletions(-) create mode 100644 clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java create mode 100644 clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf21ValidationRule.java create mode 100644 platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationCode.java diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java index 13c3dd6af..1628b3a46 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java @@ -16,13 +16,15 @@ public class SdfExecutorsConfig { Sdf57Executor sdf57Executor, Sdf04Executor sdf04Executor, Sdf13Executor sdf13Executor, - Sdf08Executor sdf08Executor) { + Sdf08Executor sdf08Executor, + Sdf21Executor sdf21Executor) { Map> executors = new HashMap<>(); executors.put(SdfTable.SDF_01, sdf01Executor); executors.put(SdfTable.SDF_57, sdf57Executor); executors.put(SdfTable.SDF_04, sdf04Executor); executors.put(SdfTable.SDF_13, sdf13Executor); executors.put(SdfTable.SDF_08, sdf08Executor); + executors.put(SdfTable.SDF_21, sdf21Executor); return executors; } } 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 c46b1de32..eb9f3ef15 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 @@ -14,10 +14,7 @@ import ru.clearing.classes.statics.data.misc.STrades; import ru.clearing.classes.statics.data.misc.Session; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; -import ru.clearing.classes.statics.data.sdf.SDf01; -import ru.clearing.classes.statics.data.sdf.SDf06; -import ru.clearing.classes.statics.data.sdf.SDf08; -import ru.clearing.classes.statics.data.sdf.SDf57; +import ru.clearing.classes.statics.data.sdf.*; import ru.clearing.classes.statics.data.security.MoneyMarketSecurity; import ru.clearing.classes.statics.data.security.Security; import ru.clearing.platform.dictionary.SectionDictionary; @@ -190,6 +187,21 @@ public class ValidationConfig { }; } + @Bean("sdf21Validator") + public Function sdf21Validator() { + return sDf21 -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(sDf21); + context.addImdg(IMDGDistributedNames.Map_Account, imdgAccount); + context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany); + context.setLogPrefix(LogPrefixId.INSTANCE); + return new ValidatorImpl<>(context, + Sdf21ValidationRule.CompanyPresent, + Sdf21ValidationRule.AccountPresent + ); + }; + } + @Bean("sdf01ValidatorNew") public Function sdf01ValidatorNew() { return sDf01 -> { diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java index d64ec6d0d..28d072a2e 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java @@ -60,6 +60,7 @@ public class StatementService extends QueueConsumer implements InitializingBean this.sdfImdgs.put(SdfTable.SDF_04, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf04, SDf04.class)); this.sdfImdgs.put(SdfTable.SDF_13, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf13, SDf13.class)); this.sdfImdgs.put(SdfTable.SDF_08, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf08, SDf08.class)); + this.sdfImdgs.put(SdfTable.SDF_21, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf21, SDf21.class)); } @Override @@ -100,26 +101,51 @@ public class StatementService extends QueueConsumer implements InitializingBean } + /** + * fromAccService передается когда пришел ответ от account-service + * в этом случае: по key находим пару в которой сохранен sdf57 запрос и частично выполненный sdf01 + * вместо старого sdf01 запроса выполняем новый пришедший от account-service + */ + private void processSdf08And21(Long key, StatementRequest fromAccService) { + Pair pair = pairOfSdfRequest.get(key); + Result sdf08Res = processSdf08(fromAccService == null ? pair.getFirst() : fromAccService); + if (sdf08Res.getAccountRequests().size() > 0) { + log.info("sdf08 execution wasn't complete, waiting for an answer from account-service"); + return; + } + //затем sdf21 + processSdf21(pair.getSecond()); +//fixme ревизия для бумаг reviser.doRevise(pair.getFirst().getGroupId()); + //теперь можем продолжить сессию с шага 1 +// ContinueSessionBnRequest continueSessionBn = new ContinueSessionBnRequest(); +// kafkaSender.sendRequestToQueue(Consts.CONTINUE_SESSION_BN_FIRST_PART, continueSessionBn); + pairOfSdfRequest.remove(key); + log.info("pair sdf08/sdf21 processed successfully"); + + } + private void processAccountAnswer(BaseRequest systemRequest) { StatementRequest payload = systemRequest.getRequestPayload(); + Optional key = findCompleteKey(payload.getTable()); + if (key.isEmpty()) { + log.error("FATAL: response from account-service received id={} table {} sdf ids={}", systemRequest.getId(), + payload.getTable(), + payload + .getAccountCreationResults() + .stream() + .map(res -> String.valueOf(res.getSdfId())) + .collect(Collectors.joining(",", "[", "]")) + ); + return; + } switch (payload.getTable()) { case SDF_01 -> { //там нужно переиспользовать SDF57 запрос приходивший ранее и сохраненный в pairOfSdfRequest - Optional key = findCompleteKey(payload.getTable()); - if (key.isEmpty()) { - log.error("FATAL: response from account-service received id={} table {} sdf ids={}", systemRequest.getId(), - payload.getTable(), - payload - .getAccountCreationResults() - .stream() - .map(res -> String.valueOf(res.getSdfId())) - .collect(Collectors.joining(",", "[", "]")) - ); - return; - } processSdf01And57(key.get(), payload); } - case SDF_08 -> processSdf08(payload); + case SDF_08 -> { + processSdf08(payload); + } } log.info("{} processed successfully after account-service command.", payload.getTable()); @@ -184,6 +210,15 @@ public class StatementService extends QueueConsumer implements InitializingBean // finishSendCommand(res, service, statementRequest); } + private void processSdf21(StatementRequest statementRequest) { + Imdg sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf21, SDf21.class); + Collection sdfGroup = sdfImdg.getCollectionObjectsByFieldValues(Map.of( + "generationId", statementRequest.getGroupId())); + AbstractExecutor service = executorsMap.get(SdfTable.SDF_21); + Result res = service.execute(sdfGroup, statementRequest); +// finishSendCommand(res, service, statementRequest); + } + private void processSdf04(StatementRequest statementRequest) { Imdg sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf04, SDf04.class); Collection sdfGroup = sdfImdg.getCollectionObjectsByFieldValues(Map.of( @@ -197,7 +232,7 @@ public class StatementService extends QueueConsumer implements InitializingBean } } - private void processSdf08(StatementRequest statementRequest) { + private Result processSdf08(StatementRequest statementRequest) { Imdg sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf08, SDf08.class); Collection sdfGroup; if (statementRequest.getAccountCreationResults().size() == 0) { @@ -211,16 +246,13 @@ public class StatementService extends QueueConsumer implements InitializingBean .collect(Collectors.toList()); } AbstractExecutor service = executorsMap.get(SdfTable.SDF_08); - if (service != null) { - Result res = service.execute(sdfGroup, statementRequest); - if (res.getAccountRequests().size() != 0) { - kafkaSender.sendRequestToQueue(Consts.ACCOUNT_NEW_SDF08, createAccountsRequest(statementRequest.getGroupId(), res.getAccountRequests())); - } else if (service.isNeedToSendCommand()) { - service.sendCommand(kafkaSender, res); - } - } else { - log.warn("Executor for SDF_08 not set"); + Result res = service.execute(sdfGroup, statementRequest); + if (res.getAccountRequests().size() != 0) { + kafkaSender.sendRequestToQueue(Consts.ACCOUNT_NEW_SDF08, createAccountsRequest(statementRequest.getGroupId(), res.getAccountRequests())); + } else if (service.isNeedToSendCommand()) { + service.sendCommand(kafkaSender, res); } + return res; } private void processSdf13(StatementRequest statementRequest) { 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 new file mode 100644 index 000000000..fb42baf34 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java @@ -0,0 +1,150 @@ +package ru.spcex.clearing.service.builder; + +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.account.ClearingAccount; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity; +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.MoneyMarketSecurity; +import ru.clearing.classes.statics.data.security.Security; +import ru.clearing.classes.statics.data.statement.Statement; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.session.stage.util.RegistryUtil; +import ru.spcex.platform.enumeration.*; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.utils.enumeration.IEnumKey; + +import java.math.BigDecimal; +import java.time.Instant; +import java.time.LocalDate; +import java.util.Collection; +import java.util.Map; + +public class RegistrySecurityBuilder { + private Statement statement; + private Company company; + private Account account; + private RegistryDesignation designation; + private final ImdgProvider imdgProvider; + + private final Imdg clearingAccountImdg; + private final Imdg tradingClearingRegistryImdg; + private final Imdg securityImdg; + private final Imdg fixedIncomeSecurityImdg; + private final Imdg moneyMarketSecurityImdg; + private final Imdg equitySecurityImdg; + private final Imdg currencyImdg; + + + public static RegistrySecurityBuilder builder(ImdgProvider imdgProvider) { + return new RegistrySecurityBuilder(imdgProvider); + } + + private RegistrySecurityBuilder(ImdgProvider imdgProvider) { + this.imdgProvider = imdgProvider; + this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); + this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class); + this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class); + 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.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class); + } + + public RegistrySecurityBuilder statement(Statement statement) { + this.statement = statement; + return this; + } + + public RegistrySecurityBuilder company(Company company) { + this.company = company; + return this; + } + + public RegistrySecurityBuilder account(Account account) { + this.account = account; + return this; + } + + public RegistrySecurityBuilder designation(RegistryDesignation designation) { + this.designation = designation; + return this; + } + + public Registry build() { + Registry rgs = new Registry(); + rgs.setCompanyId(company.getId()); + rgs.setTradingCode(company.getTradingCode()); + rgs.setClearingCode(company.getClearingCode()); + rgs.setShortName(company.getShortName()); + rgs.setFullName(company.getFullName()); + rgs.setAccountId(account.getId()); + rgs.setAccountType(account.getAccountType()); + rgs.setAccount(account.getAccount()); + rgs.setRegistryDesignation(designation.getKey()); + rgs.setRegistryInstrumentType(RegistryInstrumentType.S.getKey()); + + AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()); + if (AccountType.Clrn.equals(accType)) { + ClearingAccount accountForStatement = clearingAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", statement.getAccountId())); + if (accountForStatement != null) { + rgs.setRegistryCapacity(accountForStatement.getClearingAccountType()); + } + } else if (AccountType.Info.equals(accType) || AccountType.Anlt.equals(accType)) { + rgs.setRegistryCapacity(RegistryCapacity.A.getKey()); + } + rgs.setRegistryUnit(RegistryUnit.T.getKey()); + rgs.setRegistryCode(RegistryUtil.clearingCode(rgs)); + + Collection tcrsByAccount = tradingClearingRegistryImdg.getCollectionObjectsByFieldValues(Map.of( + "moneyAccountId", account.getId(), + "companyId", company.getId(), + "status", ServiceStatus.Active.getKey() + )); + if (!tcrsByAccount.isEmpty()) { + TradingClearingRegistry tcr = tcrsByAccount.iterator().next(); + rgs.setTradingClearingRegistryId(tcr.getId()); + rgs.setTradingClearingRegistry(tcr.getCode()); + } + + rgs.setRegistryStatus(RegistryStatus.PROC.getKey()); + rgs.setSecurityId(statement.getSecurityId()); + if (statement.getSecurityId() != null) { + String securitySymbol = obtainSecuritySymbol(statement.getSecurityId()); + rgs.setSecuritySymbol(securitySymbol); + } + //fixme !rgs.setSettlementCode(); + rgs.setTradingDate(statement.getSettlementDate()); //fixme ! today ? + rgs.setClearingDate(LocalDate.now()); + //fixme rgs.setRefundDate(); + //fixme rgs.setValueDate(); + rgs.setContract(statement.getContract()); + //создается на базе stmt, companyCred, accountDeb + rgs.setCounterPartyId(statement.getAddresseeId()); + rgs.setCreated(Instant.now()); + + //по дефолту создаем с балансом 0, а потом пересчитываем по необходимости + rgs.setBalance(BigDecimal.ZERO); + rgs.setDebit(BigDecimal.ZERO); + rgs.setCredit(BigDecimal.ZERO); + rgs.setDiffBalance(BigDecimal.ZERO); + rgs.setCheckBalance(BigDecimal.ZERO); + return rgs; + } + + private String obtainSecuritySymbol(Long securityId) { + 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(); + 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/executors/Sdf08Executor.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf08Executor.java index 18ff2538e..d758b4108 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf08Executor.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf08Executor.java @@ -34,6 +34,7 @@ import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.enumeration.IEnumKey; import ru.spcex.platform.utils.enumeration.IMessageResolver; import ru.spcex.platform.utils.log.ExceptionUtils; +import ru.spcex.platform.utils.number.BigDecimalUtil; import ru.spcex.platform.utils.text.TextUtil; import ru.spcex.platform.utils.validation.IValidator; @@ -179,6 +180,7 @@ public class Sdf08Executor extends AbstractExecutor { registryImdg.update(rgs); } else { rgs = createRegistryByStatement(stmt, company, account); + calcBalance(rgs, stmt); Registry registryB = copyRegB(rgs); Registry registryF = copyRegF(rgs, registryB.getBalance()); registryImdg.insert(rgs); @@ -334,9 +336,11 @@ public class Sdf08Executor extends AbstractExecutor { rgs.setSecuritySymbol(security.getSecuritySymbol()); } } - rgs.setCheckBalance(safeBD(statement.getAmount())); - rgs.setBalance(safeBD(statement.getAmount())); - rgs.setDiffBalance(rgs.getBalance().subtract(rgs.getCheckBalance())); + rgs.setBalance(BigDecimal.ZERO); + rgs.setDebit(BigDecimal.ZERO); + rgs.setCredit(BigDecimal.ZERO); + rgs.setDiffBalance(BigDecimal.ZERO); + rgs.setCheckBalance(BigDecimal.ZERO); rgs.setBalanceDimension(BalanceDimension.MONY.getKey()); rgs.setTradingDate(statement.getSettlementDate()); rgs.setClearingDate(LocalDate.now()); @@ -411,4 +415,9 @@ public class Sdf08Executor extends AbstractExecutor { ); return Optional.ofNullable(registryImdg.getSingleObjectByPredicate(rgstrPredicate)); } + + private void calcBalance(Registry rgs, Statement statement) { + rgs.setCheckBalance(BigDecimalUtil.safeBD(statement.getAmount())); + rgs.setDiffBalance(BigDecimalUtil.safeBD(rgs.getCheckBalance()).negate()); + } } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf21ValidationRule.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf21ValidationRule.java new file mode 100644 index 000000000..291745786 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf21ValidationRule.java @@ -0,0 +1,64 @@ +package ru.spcex.clearing.service.validation; + +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.sdf.SDf21; +import ru.spcex.clearing.error.ClearingError; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.text.TextUtil; +import ru.spcex.platform.utils.validation.IValidationRule; + +import java.util.Collection; +import java.util.Optional; + +public enum Sdf21ValidationRule implements IValidationRule> { + + CompanyPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + SDf21 sdf21 = context.getValidatedObject(); + Imdg companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class); + String depoCodeCl = sdf21.getDepoCodeCl(); + //ClearingError.CompanyNotFoundB + if (TextUtil.isEmpty(depoCodeCl) || depoCodeCl.length() < 4) { + return of(ClearingError.CompanyNotFoundB, depoCodeCl); + } + String tradingCode = depoCodeCl.substring(1, 4); + Collection companies = companyImdg.getCollectionObjectsBySQL("tradingCode = '%s'".formatted(tradingCode)); + if (companies.size() != 1) { + return of(ClearingError.CompanyNotFoundB, depoCodeCl); + } + context.storeObject(ValidationStored.Sdf21Company, companies.iterator().next()); + return empty(); + } + }, + AccountPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + SDf21 sdf21 = context.getValidatedObject(); + if (TextUtil.isEmpty(sdf21.getDepoCodeCl())) { + return of(ClearingError.AccountNotPresent, sdf21.getDepoCodeCl()); + } + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Collection account = accountImdg.getCollectionObjectsBySQL( + "account = '%s' and accountType = '%s'".formatted(sdf21.getDepoCodeCl(), AccountType.Depo.getKey()) + ); + if (account.size() != 1) { + return of(ClearingError.AccountNotPresent, sdf21.getDepoCodeCl()); + } + context.storeObject(ValidationStored.Sdf21Account, account.iterator().next()); + return empty(); + } + } + + ; + + @Override + public String ruleName() { + return "Sdf21ValidationRule." + name(); + } +} diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/ValidationStored.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/ValidationStored.java index 08bd3b36e..e2ce8b9ed 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/ValidationStored.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/ValidationStored.java @@ -10,6 +10,8 @@ public enum ValidationStored { Sdf08Company, Sdf08Account, + Sdf21Company, Sdf21Account, + Sdf06Company, Sdf06Account, ReturnDepositDmx diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/InOutSDfType.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/InOutSDfType.java index bb92d6dd0..825614851 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/InOutSDfType.java +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/InOutSDfType.java @@ -10,6 +10,7 @@ public enum InOutSDfType implements IEnumKey { type57("57"), type08("0809"), type10("1011"), + type21("21"), ; private final String key; diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationCode.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationCode.java new file mode 100644 index 000000000..8840fe501 --- /dev/null +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationCode.java @@ -0,0 +1,18 @@ +package ru.spcex.platform.enumeration; + +import ru.spcex.platform.utils.enumeration.IEnumKey; + +public enum OperationCode implements IEnumKey { + RECFREE("RECFREE"), DELFREE("DELFREE"); + + private final String key; + + OperationCode(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/SdfTable.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/SdfTable.java index 1d2a11dc2..7edf8fbab 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/SdfTable.java +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/SdfTable.java @@ -11,6 +11,7 @@ public enum SdfTable implements IEnumKey { SDF_10("SDF_10"), SDF_13("SDF_13"), SDF_16("SDF_16"), + SDF_21("SDF_21"), SDF_57("SDF_57"); SdfTable(String key) {