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..45889772a 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, + Sdf06Executor sdf06Executor) { 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_06, sdf06Executor); 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 0adc89eb6..2e4b75411 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 @@ -5,6 +5,7 @@ import org.springframework.context.annotation.Configuration; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.account.AccountBalance; import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.company.CompanySymbols; import ru.clearing.classes.statics.data.company.relation.Relation; import ru.clearing.classes.statics.data.execution.ExecutionDeposit; import ru.clearing.classes.statics.data.misc.STrades; @@ -12,14 +13,18 @@ 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.security.MoneyMarketSecurity; import ru.clearing.classes.statics.data.security.Security; import ru.clearing.platform.dictionary.SectionDictionary; +import ru.spcex.clearing.error.ClearingError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.service.validation.*; +import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.platform.enumeration.ClearingCategory; +import ru.spcex.platform.enumeration.UserRole; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.validation.ImdgValidationContext; @@ -34,6 +39,8 @@ public class ValidationConfig { Imdg imdgRelation; Imdg imdgCompany; + Imdg imdgCompanySymbols; + Imdg imdgRegistry; Imdg imdgAccount; Imdg imdgAccountBalance; Imdg imdgSecurity; @@ -41,10 +48,13 @@ public class ValidationConfig { Imdg imdgTradingClearingRegistry; Imdg imdgSession; Imdg imdgSectionDictionary; + ImdgProvider imdgProvider; public ValidationConfig(ImdgProvider imdgProvider) { this.imdgRelation = imdgProvider.getImdg(IMDGDistributedNames.Map_Relation, Relation.class); this.imdgCompany = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + this.imdgCompanySymbols = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class); + this.imdgRegistry = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); this.imdgAccount = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); this.imdgAccountBalance = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); this.imdgSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class); @@ -52,6 +62,14 @@ public class ValidationConfig { this.imdgSession = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); this.imdgSectionDictionary = imdgProvider.getImdg(IMDGDistributedNames.Map_SectionDictionary, SectionDictionary.class); this.imdgMoneyMarketSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class); + this.imdgProvider = imdgProvider; + } + + @Bean("adminRoleVerification") + public UserRoleVerification adminRoleVerification() { + return new UserRoleVerification( + imdgProvider, null, UserRole.Admin, ClearingError.GeneralError //fixme no UserVerifyDenial error + ); } @Bean("executionDepositValidator") @@ -185,4 +203,22 @@ public class ValidationConfig { ); }; } + + @Bean("sdf06ValidatorNew") + public Function sdf06ValidatorNew() { + return sDf06 -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(sDf06); + context.addImdg(IMDGDistributedNames.Map_Account, imdgAccount); + context.addImdg(IMDGDistributedNames.Map_CompanySymbols, imdgCompany); + context.addImdg(IMDGDistributedNames.Map_Registry, imdgCompany); + return new ValidatorImpl<>(context, + Sdf06NewValidationRule.CompanySymbolPresent, + Sdf06NewValidationRule.AccountPresent, + Sdf06NewValidationRule.MarketIsMkr +// Sdf06NewValidationRule.Balance + + ); + }; + } } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/error/ClearingError.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/error/ClearingError.java index 085fa9555..9d23610b2 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/error/ClearingError.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/error/ClearingError.java @@ -24,6 +24,9 @@ public enum ClearingError implements IErrorEnumId { CurrencyNotFound(5213L), OperationCanBeRunForTodayOnly(5214L), AccountWrongType(5216L), + AccountNotFoundB(5217L), + MarketIsNotMkr(5217L), + BalanceInsufficient(5222L), ; private final Long id; 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 c8bd2fe62..c58db99ca 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 @@ -62,12 +62,32 @@ public class StatementService extends QueueConsumer implements InitializingBean @Override public void afterPropertiesSet() throws Exception { callback(StatementRequest.class) - .setConsumer(this::process) + .setConsumer(systemRequest -> { + SdfTable table = systemRequest.getRequestPayload().getTable(); + if (SdfTable.SDF_06.equals(table)) { + processSdf06(systemRequest); + } else { + processPaired(systemRequest); + } + }) .forDestination(Consts.STATEMENT_PROCESS, callbacks::put); init(); } - private void process(BaseRequest systemRequest) { + @SuppressWarnings("unchecked") + private void processSdf06(BaseRequest systemRequest) { + Imdg sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf06, SDf06.class); + Collection sdf06Group = sdfImdg.getCollectionObjectsByFieldValues(Map.of( + "generationId", systemRequest.getRequestPayload().getGroupId() + )); + AbstractExecutor service = (AbstractExecutor) executorsMap.get(SdfTable.SDF_06); + Result res = service.execute(sdf06Group, systemRequest.getRequestPayload()); + if (service.isNeedToSendCommand()) { + service.sendCommand(kafkaSender, res); + } + } + + private void processPaired(BaseRequest systemRequest) { StatementRequest statementRequest = systemRequest.getRequestPayload(); SdfTable table = statementRequest.getTable(); log.debug("Receiving StatementRequest id={}; table {}", systemRequest.getId(), table); diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf06Executor.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf06Executor.java new file mode 100644 index 000000000..e93f870c4 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf06Executor.java @@ -0,0 +1,152 @@ +package ru.spcex.clearing.service.executors; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.account.DepoAccount; +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.registry.Registry; +import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.clearing.classes.statics.data.sdf.SDf06; +import ru.clearing.classes.statics.data.sdf.SDf09; +import ru.clearing.classes.statics.data.statement.Statement; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.clearing.AssetOperationRequest; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.clearing.service.model.Result; +import ru.spcex.clearing.service.validation.ValidationStored; +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.EnumMessage; +import ru.spcex.platform.utils.enumeration.IMessageResolver; +import ru.spcex.platform.utils.validation.IValidator; + +import java.time.Instant; +import java.time.LocalDate; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; + +@Service +public class Sdf06Executor extends AbstractExecutor { + private final Logger log = LoggerFactory.getLogger(getClass()); + + private final Imdg statementImdg; + private final ImdgProvider imdgProvider; + private final Imdg registryImdg; + private final Imdg fixedIncomeSecurityImdg; + private final Imdg equitySecurityImdg; + private final Imdg depoAccountImdg; + private final Imdg tradingClearingRegistryImdg; + private final Imdg companyImdg; + private final Imdg sdf09Imdg; + private final IMessageResolver messageResolver; + private final Function sDf06Validator; + private final KafkaSender kafkaSender; + + + //@Qualifier("sdf08ValidatorNew") Function sDf08Validator + public Sdf06Executor(ImdgProvider imdgProvider, + IMessageResolver messageResolver, + @Qualifier("sdf06ValidatorNew") Function sDf06Validator, KafkaSender kafkaSender) { + this.imdgProvider = imdgProvider; + this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class); + this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class); + this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class); + this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class); + this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class); + this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + this.sdf09Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf09, SDf09.class); + this.messageResolver = messageResolver; + this.sDf06Validator = sDf06Validator; + this.kafkaSender = kafkaSender; + } + + @Override + public String exportTableName() { + return "DF-06"; + } + + @Override + public boolean isNeedToSendCommand() { + return false; + } + + @Override + public void sendCommand(KafkaSender kafkaSender, Result result) { + } + + public Result execute(Collection sdfs, StatementRequest statementRequest) { + Result result = new Result(); + Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId(); + result.setGenerationId(generationIdForGroup); + Collection requests = new ArrayList<>(); + for (SDf06 sDf06 : sdfs) { + IValidator validator = sDf06Validator.apply(sDf06); + Optional err = validator.tillFirstError(); + if (err.isPresent()) { + //todo если ошибка про нехватку баланса - делаем statement с ошибочным статусом + //todo 2 делаем ошибочный SDF07 + log.debug("Validation error: {}", messageResolver.resolve(err.get())); + continue; + } + Long companyId = validator.getStored(ValidationStored.Sdf06CompanyId); + Account account = validator.getStored(ValidationStored.Sdf06Account); + Company company = companyImdg.getSingleObjectByID(companyId); + TradingClearingRegistry tcr = tradingClearingRegistryImdg.getSingleObjectByFieldValues( + Map.of("moneyAccountId", account.getId()) + ); + if (company == null || tcr == null) { + log.error("Company.id {} {}, TCR by account.id {} {} ", companyId, + company != null ? "present" : "not found", + account.getId(), + tcr != null ? "present" : "not found"); + continue; + } + //проверка существует ли statement пока убрал + Statement stmt = createStatementBySdf06(sDf06, companyId, account); + statementImdg.insert(stmt); + log.debug("Statement created: {}", stmt.getId()); + requests.add(requestFromStatement(stmt, company.getTradingCode(), tcr.getCode())); + } + requests.forEach(r -> kafkaSender.sendRequestToQueue(Consts.ASSET_OPERATION, r)); + return result; + } + + private Statement createStatementBySdf06(SDf06 sdf06, Long companyId, Account account) { + Statement stmt = new Statement(); + stmt.setAddresseeId(companyId); + stmt.setSenderId(Sender.Prc.getId()); + stmt.setStatementType(StatementType.incr.getKey()); + stmt.setComment(sdf06.getSpec()); + stmt.setAccountId(account.getId()); + stmt.setAccount(account.getAccount()); + stmt.setInOutDirection(InOutDirection.in.getKey()); + stmt.setAmount(sdf06.getSum()); + stmt.setOperationStatus(OperationStatus.Pending.getKey()); + stmt.setInSDfId(sdf06.getId()); + stmt.setInOutSDfType(InOutSDfType.type6.getKey()); + stmt.setClearingDate(LocalDate.now()); + stmt.setCreated(Instant.now()); + return stmt; + } + + private AssetOperationRequest requestFromStatement(Statement stmt, String tradingCode, String tcrCode) { + AssetOperationRequest req = new AssetOperationRequest(); + req.setAmount(stmt.getAmount()); + req.setSecuritySymbol(CurrencyCode.RUB.getKey()); //fixme retrieve security symbol from validator + req.setTradingCode(tradingCode); + req.setCode(tcrCode); + return req; + } +} diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf06NewValidationRule.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf06NewValidationRule.java new file mode 100644 index 000000000..b63e662dc --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf06NewValidationRule.java @@ -0,0 +1,102 @@ +package ru.spcex.clearing.service.validation; + +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.CompanySymbols; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.clearing.classes.statics.data.sdf.SDf06; +import ru.spcex.clearing.error.ClearingError; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.CompanySymbol; +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.number.BigDecimalUtil; +import ru.spcex.platform.utils.text.TextUtil; +import ru.spcex.platform.utils.validation.IValidationRule; + +import java.math.BigDecimal; +import java.util.Map; +import java.util.Optional; + +public enum Sdf06NewValidationRule implements IValidationRule> { + CompanySymbolPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + SDf06 sdf06 = context.getValidatedObject(); + Imdg companySymbolsImdg = context.obtainMap(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class); + CompanySymbols companySymbols = null; + if (sdf06.getInn() != null) { //TextUtil.isEmpty + companySymbols = companySymbolsImdg.getSingleObjectByFieldValues(Map.of( + "companySymbol", CompanySymbol.INN.getKey(), + "companySymbolValue", sdf06.getInn())); + } else if (sdf06.getBic() != null) { + companySymbols = companySymbolsImdg.getSingleObjectByFieldValues(Map.of( + "companySymbol", CompanySymbol.BIC.getKey(), + "companySymbolValue", sdf06.getBic())); + } + if (companySymbols == null) { + return of(ClearingError.CompanyNotFoundB, "inn=" + sdf06.getInn() + "/bic=" + sdf06.getBic()); + } + context.storeObject(ValidationStored.Sdf06CompanyId, companySymbols.getCompanyId()); + return empty(); + } + }, + //// 1.2. Проверить, есть ли в таблице account счет, у которого account.account=sDf06.account + // и account.accountType=CLRN (см. справочник accountType). Иначе записать в лог ошибку (5217) "Счет %s не найден". + AccountPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + SDf06 sdf06 = context.getValidatedObject(); + if (TextUtil.isEmpty(sdf06.getAccount())) { + return of(ClearingError.AccountNotFoundB, sdf06.getAccount()); + } + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Account account = accountImdg.getSingleObjectByFieldValues(Map.of( + "account", sdf06.getAccount(), + "accountType", AccountType.Clrn.getKey())); + if (account == null) { + return of(ClearingError.AccountNotFoundB, sdf06.getAccount()); + } + context.storeObject(ValidationStored.Sdf06Account, account); + return empty(); + } + }, + MarketIsMkr() { + @Override + public Optional validate(ImdgValidationContext context) { + SDf06 sdf06 = context.getValidatedObject(); + if (sdf06.getMarket() == null || !sdf06.getMarket().equals("U")) { + return of(ClearingError.MarketIsNotMkr); + } + return empty(); + } + }, + Balance() { + @Override + public Optional validate(ImdgValidationContext context) { + SDf06 sdf06 = context.getValidatedObject(); + if (BigDecimalUtil.safeBD(sdf06.getSum()).compareTo(BigDecimal.ZERO) >= 0) { + return empty(); + } + Imdg registryImdg = context.obtainMap(IMDGDistributedNames.Map_Registry, Registry.class); + Registry rgs = registryImdg.getSingleObjectByFieldValues(Map.of( + "account", sdf06.getAccount(), + "accountType", AccountType.Clrn.getKey())); + if (rgs == null) { + return of(ClearingError.BalanceInsufficient, sdf06.getAccount()); + } + //fixme getFreeBalance??? + if (BigDecimalUtil.safeBD(rgs.getCheckBalance()).compareTo(BigDecimalUtil.safeBD(sdf06.getSum()).abs()) < 0) { + return of(ClearingError.BalanceInsufficient, sdf06.getAccount()); + } + return empty(); + } + } + ; + + @Override + public String ruleName() { + return "Sdf08NewValidationRule." + 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 472a65bfd..56057b25a 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 @@ -8,5 +8,7 @@ public enum ValidationStored { Sdf01Company, Sdf01Account, - Sdf08Company, Sdf08Account + Sdf08Company, Sdf08Account, + + Sdf06CompanyId, Sdf06Account } diff --git a/clearing-parent/dbf-importer/src/main/java/ru/spcex/clearing/dbf/importer/logic/stages/DbfImportKafkaMessenger.java b/clearing-parent/dbf-importer/src/main/java/ru/spcex/clearing/dbf/importer/logic/stages/DbfImportKafkaMessenger.java index eed6b0b63..93d3177c2 100644 --- a/clearing-parent/dbf-importer/src/main/java/ru/spcex/clearing/dbf/importer/logic/stages/DbfImportKafkaMessenger.java +++ b/clearing-parent/dbf-importer/src/main/java/ru/spcex/clearing/dbf/importer/logic/stages/DbfImportKafkaMessenger.java @@ -30,6 +30,7 @@ public class DbfImportKafkaMessenger implements InitializingBean { @Override public void afterPropertiesSet() { messengers.put(ETable.DF_01, groupId -> messageBalance(groupId, SdfTable.SDF_01)); + messengers.put(ETable.DF_06, groupId -> messageBalance(groupId, SdfTable.SDF_06)); messengers.put(ETable.DF_09, groupId -> messageBalance(groupId, SdfTable.SDF_09)); messengers.put(ETable.DF_16, groupId -> messageBalance(groupId, SdfTable.SDF_16)); messengers.put(ETable.DF_57, groupId -> messageBalance(groupId, SdfTable.SDF_57)); 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 bd9f728ee..5854e19dc 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 @@ -3,7 +3,7 @@ package ru.spcex.platform.enumeration; import ru.spcex.platform.utils.enumeration.IEnumKey; public enum InOutSDfType implements IEnumKey { - type1("0102"), type16("1617"), type9("0910"), type57("57"), type08("0809"); + type1("0102"), type6("0607"), type16("1617"), type9("0910"), type57("57"), type08("0809"); private final String 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 3221f97dd..1d2a11dc2 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 @@ -5,6 +5,7 @@ import ru.spcex.platform.utils.enumeration.IEnumKey; public enum SdfTable implements IEnumKey { SDF_01("SDF_01"), SDF_04("SDF_04"), + SDF_06("SDF_06"), SDF_08("SDF_08"), SDF_09("SDF_09"), SDF_10("SDF_10"),