http://jira.mfd.msk:8088/browse/CLS-303

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/SdfExecutorsConfig.java

@@ -5,7 +5,7 @@ import org.springframework.context.annotation.Configuration;
 import ru.spcex.clearing.balance.service.AbstractExecutor;
 import ru.spcex.clearing.balance.service.Sdf01Executor;
 import ru.spcex.clearing.balance.service.Sdf16Executor;
-import ru.spcex.platform.classes.base.interfaces.WithAccount;
+import ru.spcex.clearing.balance.service.Sdf57Executor;
 import ru.spcex.platform.enumeration.SdfTable;
 
 import java.util.HashMap;
@@ -15,13 +15,15 @@ import java.util.Map;
 public class SdfExecutorsConfig {
 
     @Bean("sdfExecutors")
-    public Map<SdfTable, AbstractExecutor<? extends WithAccount>> executorsMap(Sdf01Executor sdf01Executor,
+    public Map<SdfTable, AbstractExecutor<?>> executorsMap(Sdf01Executor sdf01Executor,
                                                                                //Sdf09Executor sdf09Executor,
-                                                                               Sdf16Executor sdf16Executor) {
+                                                                               Sdf16Executor sdf16Executor,
-        Map<SdfTable, AbstractExecutor<? extends WithAccount>> executors = new HashMap<>();
+                                                                               Sdf57Executor sdf57Executor) {
+        Map<SdfTable, AbstractExecutor<?>> executors = new HashMap<>();
         executors.put(SdfTable.SDF_01, sdf01Executor);
 // todo возможно удалят или переделают:       executors.put(SdfTable.SDF_09, sdf09Executor);
         executors.put(SdfTable.SDF_16, sdf16Executor);
+        executors.put(SdfTable.SDF_57, sdf57Executor);
         return executors;
     }
 }

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java

@@ -10,6 +10,7 @@ import ru.clearing.classes.statics.data.company.CompanySymbols;
 import ru.clearing.classes.statics.data.sdf.SDf01;
 import ru.clearing.classes.statics.data.sdf.SDf09;
 import ru.clearing.classes.statics.data.sdf.SDf16;
+import ru.clearing.classes.statics.data.sdf.SDf57;
 import ru.spcex.clearing.balance.validation.*;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
@@ -63,6 +64,23 @@ public class ValidationConfig {
         };
     }
 
+    @Bean("sdf57Validator")
+    public Function<SDf57, IValidator> sdf57Validator() {
+        return sDf57 -> {
+            ImdgValidationContext<SDf57> context = new ImdgValidationContext<>();
+            context.setValidatedObject(sDf57);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, getImdg(s));
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            return new ValidatorImpl<>(context,
+                    Sdf57ValidationRule.CompanyDebPresent,
+                    Sdf57ValidationRule.CompanyCredPresent,
+                    Sdf57ValidationRule.AccountDebPresent,
+                    Sdf57ValidationRule.CurrencyCode
+            );
+        };
+    }
+
     @Bean("sdf16Validator")
     public Function<SDf16, IValidator> sdf16Validator() {
         return sDf16 -> {

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java

@@ -11,6 +11,7 @@ public enum BalanceError implements IErrorEnumId {
     AccountNotPresent(5217L),
     AccountNotActive(5218L),
     BalanceNotEnough(5222L),
+    CompanyNotActive(5411L),
     ;
     private final Long id;
 

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AbstractExecutor.java

@@ -1,11 +1,10 @@
 package ru.spcex.clearing.balance.service;
 
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
-import ru.spcex.platform.classes.base.interfaces.WithAccount;
 
 import java.util.Collection;
 
-public abstract class AbstractExecutor<T extends WithAccount> {
+public abstract class AbstractExecutor<T> {
     abstract Result execute(Collection<T> sdf, StatementRequest statementRequest);
     abstract String exportTableName();
 }

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/Sdf57Executor.java

@@ -0,0 +1,215 @@
+package ru.spcex.clearing.balance.service;
+
+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.AccountBalance;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.clearing.classes.statics.data.sdf.SDf02;
+import ru.clearing.classes.statics.data.sdf.SDf57;
+import ru.clearing.classes.statics.data.statement.Statement;
+import ru.spcex.clearing.balance.errors.BalanceError;
+import ru.spcex.clearing.balance.validation.ValidationStored;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
+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.text.TextUtil;
+import ru.spcex.platform.utils.validation.IValidator;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Service
+public class Sdf57Executor extends AbstractExecutor<SDf57> {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
+    private final Imdg<Statement> statementImdg;
+    private final Imdg<Registry> registryImdg;
+    private final Function<SDf57, IValidator> sDf57Validator;
+    private final LoggingService errorLogger;
+    private final Imdg<SDf02> sdf02Imdg;
+    private final ImdgProvider imdgProvider;
+    private final AccountBalanceService accountBalanceService;
+    private final IMessageResolver errorResolver;
+    private final Imdg<AccountBalance> accountBalanceImdg;
+    private final IMessageResolver messageResolver;
+
+    public Sdf57Executor(@Qualifier("sdf57Validator") Function<SDf57, IValidator> sDf57Validator,
+                         LoggingService errorLogger,
+                         ImdgProvider imdgProvider,
+                         AccountBalanceService accountBalanceService,
+                         IMessageResolver errorResolver, IMessageResolver messageResolver) {
+        this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
+        this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);
+        this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
+        this.sDf57Validator = sDf57Validator;
+        this.errorLogger = errorLogger;
+        this.imdgProvider = imdgProvider;
+        this.accountBalanceService = accountBalanceService;
+        this.errorResolver = errorResolver;
+        this.messageResolver = messageResolver;
+    }
+
+    @Override
+    String exportTableName() {
+        return "DF-57";
+    } //no need...
+
+    //V - Изменение statement по sDf57
+    //
+    //1. Перед изменением statement необходимо выполнить ряд проверок:
+    //   1.1. Найти в company запись, у которой company.tradingCode=sDf57.deal_deb. Если такой записи нет, записать в лог ошибку (5211) "Компания %s не найдена".
+    //   1.2. Найти в company запись, у которой company.tradingCode=sDf57.deal_cred. Если такой записи нет, записать в лог ошибку (5211) "Компания %s не найдена".
+    //   1.3. Проверить, есть ли в таблице account счет, у которого account.account=sDf57.c_acc_deb. Если такой записи нет, записать в лог ошибку (5217) "Счет %s не найден".
+    //   1.4. Проверить, есть ли в таблице account счет, у которого account.account=sDf57.c_acc_cred. Если такой записи нет, записать в лог ошибку (5217) "Счет %s не найден".
+    //   1.5. Проверить, что sDf57.pay_val=RUR. Иначе записать в лог ошибку (5213) "Валюта %s не найдена".
+    //2. В зависимости от результата прохождения проверок в п.1 раздела Изменение statement по sDf57:
+    //   2.1. Если все проверки пройдены, необходимо сформировать 2 новые записи согласно описанию с соответствующим тэгом,
+    //   где первая запись будет содержать информацию о плательщике (по sDf57.deal_deb),
+    //   а вторая о получателе (по sDf57.deal_cred) и связаны по одному inSDfId (= sDf57.id).
+    //   2.2. Иначе запись в statement не добавляется.
+    //3. По итогу добавления statement:
+    //   Если в п.1 раздела Изменение statement по sDf57 ошибок не обнаружено, то инициировать изменение таблицы registry согласно описанию с соответствующим тэгом.
+    //   По итогу изменения registry должны быть обновлены значения полей в statement:
+    //      - operationStatus;
+    //      - errorCode в случае выявления ошибки;
+    //      - errorText в случае выявления ошибки.
+    public Result execute(Collection<SDf57> sdf, StatementRequest statementRequest) {
+        Result result = new Result();
+        Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId();
+        result.setGenerationId(generationIdForGroup);
+        for (SDf57 sdf57 : sdf) {
+            IValidator validator = sDf57Validator.apply(sdf57);
+            Optional<EnumMessage> error = validator.tillFirstError();
+            if (error.isPresent()) {
+                log.error("error while validating sdf57.id={} - {}", sdf57.getId(), messageResolver.resolve(error.get()));
+                continue;
+            }
+            //create by companyDeb
+            Company companyDeb = validator.getStored(ValidationStored.Sdf57CompanyDeb);
+            Account accountDeb = validator.getStored(ValidationStored.Sdf57AccountDeb);
+            Statement statementDeb = create(sdf57, companyDeb, accountDeb);
+            statementImdg.insert(statementDeb);
+            //create by companyCred
+            Company companyCred = validator.getStored(ValidationStored.Sdf57CompanyCred);
+            Account accountCred = validator.getStored(ValidationStored.Sdf57AccountCred);
+            Statement statementCred = create(sdf57, companyCred, accountCred);
+            statementImdg.insert(statementCred);
+
+            Consumer<StmtCmpAcc> createRegistryIfNeeded = stmtCmpAcc -> {
+                Statement stmt = stmtCmpAcc.statement();
+                Optional<EnumMessage> err = validateActiveness(stmtCmpAcc.company(), stmtCmpAcc.account(), stmt);
+                if (err.isEmpty()) {
+                    Consumer<Registry> update = rgs -> {
+                        updateReg(stmt, rgs);
+                        registryImdg.update(rgs);
+                    };
+                    Runnable create = () -> {
+                        Registry registry = createRegistryByStatement(stmt);
+                        registryImdg.insert(registry);
+                    };
+                    findReg(stmt, RegistryDesignation.A).ifPresentOrElse(update, create);
+                    findReg(stmt, RegistryDesignation.D).ifPresentOrElse(update, create);
+                    stmt.setOperationStatus(OperationStatus.Executed.getKey());
+                } else {
+                    stmt.setErrorCodeId(err.get().getSubject().getId()); // fixme ErrorText insert
+                    stmt.setOperationStatus(OperationStatus.Rejected.getKey());
+                    statementImdg.update(stmt);
+                }
+            };
+            createRegistryIfNeeded.accept(new StmtCmpAcc(statementDeb, companyDeb, accountDeb));
+            createRegistryIfNeeded.accept(new StmtCmpAcc(statementCred, companyCred, accountCred));
+        }
+        return result;
+    }
+
+    private static record StmtCmpAcc(Statement statement, Company company, Account account) {
+    }
+
+    private Optional<EnumMessage> validateActiveness(Company company, Account account, Statement statement) {
+        if (!WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus())) {
+            return Optional.of(new EnumMessage(BalanceError.CompanyNotActive, company.getId()));
+        }
+        if (!WorkflowStatus.Active.equalsByKey(account.getStatus())) {
+            return Optional.of(new EnumMessage(BalanceError.AccountNotActive, account.getId()));
+        }
+        return Optional.empty();
+    }
+
+    private Statement create(SDf57 sdf57, Company companyDeb, Account accountDeb) {
+        Statement statement = new Statement();
+        statement.setAddresseeId(companyDeb.getId());
+        statement.setSenderId(Sender.Prc.getId());
+        statement.setStatementType(StatementType.full.getKey());
+        statement.setContract(getContractFromSpecif(sdf57.getSpecif()));
+        statement.setAccountId(accountDeb.getId());
+        statement.setAccount(accountDeb.getAccount());
+        statement.setInOutDirection(InOutDirection.out.getKey());
+        statement.setSettlementDate(payDate(sdf57.getPay_date())); //fixme pay_date format
+        statement.setAmount(TextUtil.isEmpty(sdf57.getSum_deb()) ? null : new BigDecimal(sdf57.getSum_deb()));
+        statement.setOperationStatus(OperationStatus.Pending.getKey());
+        statement.setInSDfId(sdf57.getId());
+        statement.setInOutSDfType(InOutSDfType.type57.getKey());
+        return statement;
+    }
+
+    private Registry createRegistryByStatement(Statement statement) {
+        //todo
+        return new Registry();
+    }
+
+    private void updateReg(Statement s, Registry r) {
+        //todo
+    }
+
+    private Optional<Registry> findReg(Statement s, RegistryDesignation des) {
+        //todo add dependency on Registry search
+//        RegistryTradingParams p = new RegistryTradingParams(
+//                des, RegistryInstrumentType.M, RegistryCapacity.A, RegistryUnit.T
+//        );
+//        String sql = RegistryCodeSqlBuilder.getInstance(p).build();
+//        ImdgPredicateBuilder pb = registryImdg.predicateBuilder();
+//        ImdgPredicate rgstrPredicate = pb.and(pb.sql(sql),
+//                pb.sql(sql),
+//                pb.equals("companyId", s.getAddresseeId()) //fixme companyId?
+//        );
+//        if (des.equals(RegistryDesignation.D) && !TextUtil.isEmpty(s.getContract())) {
+//            rgstrPredicate = pb.and(rgstrPredicate, pb.equals("contract", s.getContract()));
+//        }
+//        return Optional.ofNullable(registryImdg.getSingleObjectByPredicate(rgstrPredicate));
+        return null;
+    }
+
+    DateTimeFormatter payDateFormatter = DateTimeFormatter.ofPattern("yyyyMMdd");
+    private LocalDate payDate(String payDate) {
+        if (TextUtil.isEmpty(payDate)) {
+            return null;
+        }
+        return LocalDate.parse(payDate, payDateFormatter);
+    }
+
+    private String getContractFromSpecif(String specif) {
+        if (specif == null) {
+            return null;
+        }
+        int index = specif.indexOf("№");
+        if (index == -1) {
+            return null;
+        }
+        return specif.substring(index + 1);
+    }
+}

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java

@@ -8,7 +8,6 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.sdf.SDf01;
-import ru.clearing.classes.statics.data.sdf.SDf09;
 import ru.clearing.classes.statics.data.sdf.SDf16;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
@@ -39,14 +38,14 @@ public class StatementService extends QueueConsumer implements InitializingBean
     private final ImdgProvider imdgProvider;
     private final KafkaSender kafkaReqProducer;
     private final Map<SdfTable, Imdg<? extends WithAccount>> sdfImdgs;
-    private final Map<SdfTable, AbstractExecutor<? extends WithAccount>> executorsMap;
+    private final Map<SdfTable, AbstractExecutor<?>> executorsMap;
     private final AccountBalanceService accountBalanceService;
 
     @Autowired
     public StatementService(Consumer<String, Object> kafkaQueue,
                             ImdgProvider imdgProvider,
                             KafkaSender kafkaReqProducer,
-                            @Qualifier("sdfExecutors") Map<SdfTable, AbstractExecutor<? extends WithAccount>> executorsMap, AccountBalanceService accountBalanceService) {
+                            @Qualifier("sdfExecutors") Map<SdfTable, AbstractExecutor<?>> executorsMap, AccountBalanceService accountBalanceService) {
         super(kafkaQueue);
         this.imdgProvider = imdgProvider;
         this.accountBalanceService = accountBalanceService;
@@ -76,7 +75,7 @@ public class StatementService extends QueueConsumer implements InitializingBean
         accountBalanceService.updateAccountBalanceByClearing(payload);
         CommonIdRequest commonIdRequest = new CommonIdRequest();
         commonIdRequest.setId(updateAccBalanceReq.getId());
-        kafkaReqProducer.sendRequestToQueue(Consts.CONTINUE_CLEARING, commonIdRequest);
+        kafkaReqProducer.sendRequestToQueue(Consts.CONTINUE_CLEARING, commonIdRequest, updateAccBalanceReq.getCorrelationId());
     }
 
     private void process(BaseRequest<StatementRequest> systemRequest) {

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf57ValidationRule.java

@@ -0,0 +1,94 @@
+package ru.spcex.clearing.balance.validation;
+
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.sdf.SDf57;
+import ru.spcex.clearing.balance.errors.BalanceError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+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.Optional;
+
+public enum Sdf57ValidationRule implements IValidationRule<ImdgValidationContext<SDf57>> {
+    CompanyDebPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
+            SDf57 sdf57 = context.getValidatedObject();
+            if (TextUtil.isEmpty(sdf57.getDeal_deb())) {
+                return of(BalanceError.CompanyNotFound, sdf57.getDeal_deb());
+            }
+            Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
+            Company found = companyImdg.getSingleObjectBySQL("tradingCode = '" + sdf57.getDeal_deb() + "'");
+            if (found == null) {
+                return of(BalanceError.CompanyNotFound, sdf57.getDeal_deb());
+            }
+            context.storeObject(ValidationStored.Sdf57CompanyDeb, found);
+            return empty();
+        }
+    }, CompanyCredPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
+            SDf57 sdf57 = context.getValidatedObject();
+            if (TextUtil.isEmpty(sdf57.getDeal_cred())) {
+                return of(BalanceError.CompanyNotFound, sdf57.getDeal_deb());
+            }
+            Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
+            Company found = companyImdg.getSingleObjectBySQL("tradingCode = '" + sdf57.getDeal_cred() + "'");
+            if (found == null) {
+                return of(BalanceError.CompanyNotFound, sdf57.getDeal_deb());
+            }
+            context.storeObject(ValidationStored.Sdf57CompanyCred, found);
+            return empty();
+        }
+    }, AccountDebPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
+            SDf57 sdf57 = context.getValidatedObject();
+            if (TextUtil.isEmpty(sdf57.getC_acc_deb())) {
+                return of(BalanceError.AccountNotPresent, sdf57.getDeal_deb());
+            }
+            Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            Account found = accountImdg.getSingleObjectBySQL("account = '" + sdf57.getC_acc_deb() + "'");
+            if (found == null) {
+                return of(BalanceError.AccountNotPresent, sdf57.getDeal_deb());
+            }
+            context.storeObject(ValidationStored.Sdf57AccountDeb, found);
+            return empty();
+        }
+
+    }, AccountCredPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
+            SDf57 sdf57 = context.getValidatedObject();
+            if (TextUtil.isEmpty(sdf57.getC_acc_cred())) {
+                return of(BalanceError.AccountNotPresent, sdf57.getDeal_deb());
+            }
+            Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            Account found = accountImdg.getSingleObjectBySQL("account = '" + sdf57.getC_acc_cred() + "'");
+            if (found == null) {
+                return of(BalanceError.AccountNotPresent, sdf57.getDeal_deb());
+            }
+            context.storeObject(ValidationStored.Sdf57AccountCred, found);
+            return empty();
+        }
+
+    }, CurrencyCode() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
+            SDf57 sdf57 = context.getValidatedObject();
+            if (!ru.spcex.platform.enumeration.CurrencyCode.RUR.equalsByKey(sdf57.getPay_val())) {
+                return of(BalanceError.CurrencyNotFound, sdf57.getPay_val());
+            }
+            return empty();
+        }
+    };
+
+    @Override
+    public String ruleName() {
+        return "Sdf57ValidationRule." + name();
+    }
+}

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/ValidationStored.java

@@ -1,5 +1,9 @@
 package ru.spcex.clearing.balance.validation;
 
 public enum ValidationStored {
-    Account, Company;
+    Account, Company,
+
+    Sdf57CompanyDeb, Sdf57CompanyCred, Sdf57AccountDeb, Sdf57AccountCred
+    ;
+
 }

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CurrencyCode.java

@@ -3,7 +3,9 @@ package ru.spcex.platform.enumeration;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 
 public enum CurrencyCode implements IEnumKey {
-    RUB("RUB");
+    RUB("RUB"),
+    RUR("RUR") //fixme may be remove to separate enum
+    ;
 
     private final String key;
 

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationStatus.java

@@ -3,7 +3,7 @@ package ru.spcex.platform.enumeration;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 
 public enum OperationStatus implements IEnumKey {
-    Pending("PEND"), Executed("EXEC");
+    Pending("PEND"), Executed("EXEC"), Rejected("RJCT");
 
     private final String key;
 

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryDesignation.java

@@ -6,6 +6,7 @@ public enum RegistryDesignation implements IEnumKey {
     A("A"),
     O("O"),
     T("T"),
+    D("D"),
     L("L"),
     C("C")
     ;

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/SdfTable.java

@@ -3,7 +3,7 @@ package ru.spcex.platform.enumeration;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 
 public enum SdfTable implements IEnumKey {
-    SDF_01("SDF_01"), SDF_09("SDF_09"), SDF_16("SDF_16");
+    SDF_01("SDF_01"), SDF_57("SDF_57"), SDF_09("SDF_09"), SDF_16("SDF_16");
 
     SdfTable(String key) {
         this.key = key;