diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/SdfExecutorsConfig.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/SdfExecutorsConfig.java index 0c6937090..6bc274352 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/SdfExecutorsConfig.java +++ b/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> executorsMap(Sdf01Executor sdf01Executor, + public Map> executorsMap(Sdf01Executor sdf01Executor, //Sdf09Executor sdf09Executor, - Sdf16Executor sdf16Executor) { - Map> executors = new HashMap<>(); + Sdf16Executor sdf16Executor, + Sdf57Executor sdf57Executor) { + Map> 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; } } diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java index 87b39ee7f..aa0745b0a 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java +++ b/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 sdf57Validator() { + return sDf57 -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(sDf57); + Consumer 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 sdf16Validator() { return sDf16 -> { diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java index e933afed2..b6d405297 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java +++ b/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; diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AbstractExecutor.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AbstractExecutor.java index cc7429904..7b3c6586d 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/AbstractExecutor.java +++ b/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 { +public abstract class AbstractExecutor { abstract Result execute(Collection sdf, StatementRequest statementRequest); abstract String exportTableName(); } diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/Sdf57Executor.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/Sdf57Executor.java new file mode 100644 index 000000000..aefba2ef7 --- /dev/null +++ b/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 { + private final Logger log = LoggerFactory.getLogger(getClass()); + + private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy"); + private final Imdg statementImdg; + private final Imdg registryImdg; + private final Function sDf57Validator; + private final LoggingService errorLogger; + private final Imdg sdf02Imdg; + private final ImdgProvider imdgProvider; + private final AccountBalanceService accountBalanceService; + private final IMessageResolver errorResolver; + private final Imdg accountBalanceImdg; + private final IMessageResolver messageResolver; + + public Sdf57Executor(@Qualifier("sdf57Validator") Function 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 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 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 createRegistryIfNeeded = stmtCmpAcc -> { + Statement stmt = stmtCmpAcc.statement(); + Optional err = validateActiveness(stmtCmpAcc.company(), stmtCmpAcc.account(), stmt); + if (err.isEmpty()) { + Consumer 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 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 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); + } +} diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java index 5cddeb723..c1041b9e7 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java +++ b/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> sdfImdgs; - private final Map> executorsMap; + private final Map> executorsMap; private final AccountBalanceService accountBalanceService; @Autowired public StatementService(Consumer kafkaQueue, ImdgProvider imdgProvider, KafkaSender kafkaReqProducer, - @Qualifier("sdfExecutors") Map> executorsMap, AccountBalanceService accountBalanceService) { + @Qualifier("sdfExecutors") Map> 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 systemRequest) { diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf57ValidationRule.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf57ValidationRule.java new file mode 100644 index 000000000..10cb0cd85 --- /dev/null +++ b/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> { + CompanyDebPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + SDf57 sdf57 = context.getValidatedObject(); + if (TextUtil.isEmpty(sdf57.getDeal_deb())) { + return of(BalanceError.CompanyNotFound, sdf57.getDeal_deb()); + } + Imdg 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 validate(ImdgValidationContext context) { + SDf57 sdf57 = context.getValidatedObject(); + if (TextUtil.isEmpty(sdf57.getDeal_cred())) { + return of(BalanceError.CompanyNotFound, sdf57.getDeal_deb()); + } + Imdg 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 validate(ImdgValidationContext context) { + SDf57 sdf57 = context.getValidatedObject(); + if (TextUtil.isEmpty(sdf57.getC_acc_deb())) { + return of(BalanceError.AccountNotPresent, sdf57.getDeal_deb()); + } + Imdg 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 validate(ImdgValidationContext context) { + SDf57 sdf57 = context.getValidatedObject(); + if (TextUtil.isEmpty(sdf57.getC_acc_cred())) { + return of(BalanceError.AccountNotPresent, sdf57.getDeal_deb()); + } + Imdg 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 validate(ImdgValidationContext 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(); + } +} diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/ValidationStored.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/ValidationStored.java index 25eaddc69..b6074f057 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/ValidationStored.java +++ b/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 + ; + } diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CurrencyCode.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CurrencyCode.java index 7c6fb4daa..e0fd13c1a 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CurrencyCode.java +++ b/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; diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationStatus.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationStatus.java index 037b60c22..eecedd704 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationStatus.java +++ b/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; diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryDesignation.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryDesignation.java index 896e326af..fbef0e535 100644 --- a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryDesignation.java +++ b/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") ; 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 988f55a0c..0d885df19 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 @@ -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;