diff --git a/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/clearing/VerificationResult.java b/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/clearing/VerificationResult.java new file mode 100644 index 000000000..bfc7a74c2 --- /dev/null +++ b/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/clearing/VerificationResult.java @@ -0,0 +1,93 @@ +package ru.clearing.classes.statics.data.clearing; + +import ru.clearing.classes.ConstSerializable; +import ru.clearing.classes.objects.BusinessObject; +import ru.spcex.platform.classes.base.SpcexObjectBase; + +import java.math.BigDecimal; + + +public class VerificationResult extends BusinessObject { + private static final long serialVersionUID = ConstSerializable.serialVersionUID; + private String clearingCode; + private Long accountId; + private BigDecimal inSum; + private BigDecimal outIntSum; + private BigDecimal outExtSum; + private BigDecimal diffSum; + private Long generationId; + private String generationStatus; + private String resultStatus; + + public String getClearingCode() { + return clearingCode; + } + + public void setClearingCode(String clearingCode) { + this.clearingCode = clearingCode; + } + + public Long getAccountId() { + return accountId; + } + + public void setAccountId(Long accountId) { + this.accountId = accountId; + } + + public BigDecimal getInSum() { + return inSum; + } + + public void setInSum(BigDecimal inSum) { + this.inSum = inSum; + } + + public BigDecimal getOutIntSum() { + return outIntSum; + } + + public void setOutIntSum(BigDecimal outIntSum) { + this.outIntSum = outIntSum; + } + + public BigDecimal getOutExtSum() { + return outExtSum; + } + + public void setOutExtSum(BigDecimal outExtSum) { + this.outExtSum = outExtSum; + } + + public BigDecimal getDiffSum() { + return diffSum; + } + + public void setDiffSum(BigDecimal diffSum) { + this.diffSum = diffSum; + } + + public Long getGenerationId() { + return generationId; + } + + public void setGenerationId(Long generationId) { + this.generationId = generationId; + } + + public String getGenerationStatus() { + return generationStatus; + } + + public void setGenerationStatus(String generationStatus) { + this.generationStatus = generationStatus; + } + + public String getResultStatus() { + return resultStatus; + } + + public void setResultStatus(String resultStatus) { + this.resultStatus = resultStatus; + } +} diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/VerificationResultComponent.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/VerificationResultComponent.java index 4a23d7045..d408a675f 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/VerificationResultComponent.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/VerificationResultComponent.java @@ -11,6 +11,8 @@ import org.springframework.stereotype.Service; import org.springframework.util.StringUtils; import ru.clearing.classes.objects.BusinessObject; import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.clearing.VerificationResult; +import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.sdf.SDf01; import ru.clearing.classes.statics.data.account.AccountBalance; import ru.clearing.classes.statics.data.sdf.SDf03; @@ -19,9 +21,13 @@ import ru.spcex.platform.classes.base.interfaces.WithId; import ru.spcex.platform.enumeration.AccountType; import ru.spcex.platform.enumeration.ResultStatuses; import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgId; import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.utils.log.ExceptionUtils; import java.math.BigDecimal; +import java.math.RoundingMode; +import java.time.Instant; import java.util.*; import java.util.function.Function; import java.util.stream.Collectors; @@ -34,57 +40,125 @@ import java.util.stream.Collectors; public class VerificationResultComponent { private final Logger log = LoggerFactory.getLogger(getClass()); - // private final ImdgProvider imdgProvider; + private final ImdgProvider imdgProvider; private Imdg sdf01Imdg; private Imdg accountBalanceImdg; private Imdg accountImdg; + private Imdg companyImdg; + + private ImdgId idGenerator; + private Imdg verificationResultImdg; @Autowired - public VerificationResultComponent(ImdgProvider imdgProvider - ) { -// this.imdgProvider = imdgProvider; + public VerificationResultComponent(ImdgProvider imdgProvider) { + this.imdgProvider = imdgProvider; this.sdf01Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class); this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); + this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); - //this.idGenerator = imdgProvider.getImdgIdGenerator(); + this.idGenerator = imdgProvider.getImdgIdGenerator(); + this.verificationResultImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_VerificationResult, VerificationResult.class); //this.kafkaSender = KafkaSender kafkaSender } protected void executeRevision() { + log.debug("Prepare verification, get data..."); Collection allSDf01 = sdf01Imdg.getAllValues(); Collection allAccountBalance = accountBalanceImdg.getAllValues(); Collection allAccount = accountImdg.getAllValues(); + log.debug("Execute verification."); executeRevision(allSDf01, allAccountBalance, allAccount); - - //todo результат logic... см. как было в корпе? + log.debug("All verification was done."); } protected void executeRevision(Collection allSDf01, Collection allAccountBalance, Collection allAccount) { // 1. Сумму по остаткам - List vResLst = new ArrayList<>(); - /* todo use: - - - - - - - - - - - - - - - */ + List vResLst = new ArrayList<>(); + + Map> companyAccountBalance = indexList(allAccountBalance, AccountBalance::getCompanyId); + Map> companyAccount = indexList(allAccount, Account::getCompanyId); + Map> companySDf01; { + Map indexCompanyIdByAccount = new HashMap<>(); + for (Account account : allAccount) { + if (account.getAccount() != null && account.getCompanyId() != null) { + indexCompanyIdByAccount.put(account.getAccount(), account.getCompanyId()); + } + } + companySDf01 = indexList(allSDf01, sDf01 -> indexCompanyIdByAccount.get(sDf01.getAccount())); + } + + Set allPresentCompanyId = new HashSet<>(); + allPresentCompanyId.addAll(companyAccountBalance.keySet()); + allPresentCompanyId.addAll(companyAccount.keySet()); + allPresentCompanyId.addAll(companySDf01.keySet()); + log.info("Found {} AccountBalance, {} Account, {} SDf01 for {} companyId's.", + allAccountBalance.size(), allAccount.size(), allSDf01.size(), allPresentCompanyId.size()); + for (Long companyId : allPresentCompanyId) { + Company company = companyImdg.getSingleObjectByID(companyId); + if (company == null) { + log.warn("Company {} not found! Ignore verification for this.", companyId); + continue; + } + List localCompanyAccountBalance = companyAccountBalance.get(companyId); + List localCompanyAccount = companyAccount.get(companyId); + List localCompanySDf01 = companySDf01.get(companyId); + if (localCompanyAccountBalance == null) localCompanyAccountBalance = new ArrayList<>(); + if (localCompanyAccount == null) localCompanyAccount = new ArrayList<>(); + if (localCompanySDf01 == null) localCompanySDf01 = new ArrayList<>(); + log.debug("Verification company[{}] with {} AccountBalance, {} Account, {} SDf01.", + companyId, localCompanyAccountBalance.size(), localCompanyAccount.size(), + localCompanySDf01.size()); + try { + List result = checkOnCompany(company, + localCompanySDf01, localCompanyAccountBalance, localCompanyAccount); + log.trace("For company {} get {} ResultStatuses record", companyId, result.size()); + for (VerificationResult rItem : result) { + verificationResultImdg.insert(rItem); + } + } catch (Exception e) { + log.error("Error verification for company {}: {}", + companyId, ExceptionUtils.getStackTrace(e)); + } + } + } + + /** + * @param forCompany + * @param accountId Account.id by Account.account + * @return new + */ + VerificationResult newVerification(Company forCompany, Long accountId) { + VerificationResult vResult = new VerificationResult(); + vResult.setId(idGenerator.nextId()); // imdg + vResult.setCreated(Instant.now()); + if (forCompany != null) { + vResult.setClearingCode(forCompany.getClearingCode()); + } + if (accountId != null) { + vResult.setAccountId(accountId); // accountId bigint = Из accountBalance.account + } + return vResult; + } + + protected List checkOnCompany(Company forCompany, Collection allSDf01, + Collection allAccountBalance, + Collection allAccount) { + ArrayList checks = new ArrayList<>(); + + Map indexAccountIdByAccount = new HashMap<>(); + for (Account account : allAccount) { + if (account.getAccount() != null) { + indexAccountIdByAccount.put(account.getAccount(), account.getCompanyId()); + } + } + { // 1.70 verificationResult Map indexSDf01 = index(allSDf01, SDf01::getAccount); for (AccountBalance account : allAccountBalance) { - VerificationResult vResult = new VerificationResult(); - vResult.setAccountId(account.getAccountId()); + VerificationResult vResult = newVerification(forCompany, indexAccountIdByAccount.get(account.getAccount())); + checks.add(vResult); SDf01 document = indexSDf01.get(account.getAccount()); if (document == null) { @@ -100,9 +174,14 @@ public class VerificationResultComponent { } } BigDecimal balance = account.getCloseBalanceAmount() == null ? BigDecimal.ZERO : account.getCloseBalanceAmount(); - //todo сравнить правильно, remainder там без точек. remainder==balance - BigDecimal diff = balance.subtract(remainder).abs(); + // сравнить remainder==balance + BigDecimal diff = balance.subtract(remainder).setScale(2, RoundingMode.HALF_UP).abs(); vResult.setDiffSum(diff); + vResult.setInSum(account.getOpenBalanceAmount()); + vResult.setOutIntSum(account.getCloseBalanceAmount()); + vResult.setOutExtSum(remainder); + //todo похоже надо группировку по String account сделать, сверить с ТЗ. + log.trace("company[{}] AccountBalance[{}] diff = {}", forCompany.getId(), account.getId(), diff); if (BigDecimal.ZERO.compareTo(diff) == 0) { vResult.setResultStatus(ResultStatuses.success.getKey()); } else { @@ -115,7 +194,6 @@ public class VerificationResultComponent { // 2.1 Номера торговых/клиринговых счетов, соответствующие загруженным в КС // -sDf01.deal = account.account & accountType=CLRN & accountStatus=UNBL { -// Map indexSDf01 = index(allSDf01, SDf01::getDeal); Set sDf01Keys = allSDf01.stream() .filter(sdf01 -> sdf01.getDeal() != null) .map(sdf01 -> sdf01.getDeal()) @@ -126,35 +204,46 @@ public class VerificationResultComponent { .collect(Collectors.toSet()); boolean isOk = sDf01Keys.size() == accountKeys.size() && sDf01Keys.containsAll(accountKeys) && accountKeys.containsAll(sDf01Keys); -// for (Account account:allAccount) { -// if (AccountType.Clrn.equalsByKey(account.getAccountType()) & "UNBL".equals(account.getAccountStatus())) { -// // todo use enum/const ? -// SDf01 document = indexSDf01.get(account.getAccount()); -// if (document == null) { -// //todo найдено несоответствие. -// } else { -// } -// } -// } + + VerificationResult vResult = newVerification(forCompany, null); + checks.add(vResult); + if (isOk) { + vResult.setResultStatus(ResultStatuses.success.getKey()); + } else { + vResult.setResultStatus(ResultStatuses.notSuccess.getKey()); + } + log.trace("Control summ 1, count: sDf01Keys={}, accountKeys={}; check result:{}", + sDf01Keys.size(), accountKeys.size(), vResult.getResultStatus()); } // 2.2 Количество торговых/клиринговых счетов, соответствующие загруженным в КС - COUNT[sDf01.deal] = COUNT [account.account] { long countSDf01 = allSDf01.stream().filter(sDf01 -> sDf01.getDeal() != null).count(); long countAccount = allAccount.stream().filter(account -> account.getAccount() != null).count(); - log.info("countSDf01={}, countAccount={}", countSDf01 ,countAccount); - //todo countSDf01 != countAccount + boolean isOk = countSDf01 == countAccount; + VerificationResult vResult = newVerification(forCompany, null); + checks.add(vResult); + if (isOk) { + vResult.setResultStatus(ResultStatuses.success.getKey()); + } else { + vResult.setResultStatus(ResultStatuses.notSuccess.getKey()); + } + log.trace("countSDf01={}, countAccount={}, result: {}", + countSDf01, countAccount, vResult.getResultStatus()); } // 2.3 Суммарный остаток по счетам { - //todo не понял условия [sDf01.account = accountBalance.account] - long summSDf01 = 0; + Map summOfSDf01 = new HashMap<>(); for (SDf01 document : allSDf01) { if (StringUtils.isEmpty(document.getRemainder())) { try { - long value = Long.parseLong(document.getRemainder()); - summSDf01 += value; + String account = document.getAccount(); + BigDecimal value = new BigDecimal(document.getRemainder()); + BigDecimal a = summOfSDf01.get(account); + if (a == null) a = BigDecimal.ZERO; + a = a.add(value); + summOfSDf01.put(account, a); } catch (NumberFormatException nfe) { log.warn("SDf01[{}].remainder=\"{}\" is not parseable: {}", document.getId(), document.getRemainder(), nfe.getMessage()); @@ -163,29 +252,55 @@ public class VerificationResultComponent { log.debug("SDf01[{}].remainder is null or empty", document.getId()); } } - long summAccount = 0; + Map summOfAccountBalance = new HashMap<>(); for (AccountBalance account : allAccountBalance) { if (account.getCloseBalanceAmount() != null) { - long value = account.getCloseBalanceAmount().longValue(); - summAccount += value; + String accountKey = account.getAccount(); + BigDecimal value = account.getCloseBalanceAmount(); + ; + BigDecimal a = summOfAccountBalance.get(accountKey); + if (a == null) a = BigDecimal.ZERO; + a = a.add(value); + summOfAccountBalance.put(accountKey, a); } } - // todo summSDf01==summAccount теперь с точностью и погрешностью сравнений проблема. + // summSDf01==summAccount + Set allAccountStr = new HashSet<>(); + allAccountStr.addAll(summOfSDf01.keySet()); + allAccountStr.addAll(summOfAccountBalance.keySet()); + for (String account : allAccountStr) { + BigDecimal fromBalance = summOfAccountBalance.get(account); + BigDecimal fromSDf01 = summOfSDf01.get(account); + if (fromBalance == null) + fromBalance = BigDecimal.ZERO; + else + fromBalance = fromBalance.setScale(2, RoundingMode.HALF_UP); + if (fromSDf01 == null) + fromSDf01 = BigDecimal.ZERO; + else + fromSDf01 = fromSDf01.setScale(2, RoundingMode.HALF_UP); + BigDecimal diff = fromBalance.subtract(fromSDf01).setScale(2, RoundingMode.HALF_UP).abs(); + + VerificationResult vResult = newVerification(forCompany, indexAccountIdByAccount.get(account)); + checks.add(vResult); + if (BigDecimal.ZERO.compareTo(diff) == 0) { + vResult.setResultStatus(ResultStatuses.success.getKey()); + } else { + vResult.setResultStatus(ResultStatuses.notSuccess.getKey()); + } + vResult.setDiffSum(diff); + vResult.setOutExtSum(fromSDf01); + log.trace("for comapny[{}], account \"{}\" summ of fromSDf01={}, of fromBalance={}; result {}", + forCompany.getId(), account, fromSDf01, fromBalance, vResult.getResultStatus()); + } } - // 3. Сверка остатков по клиринговым счетам СПВБ - { - //todo не понял [sDf01.account = accountBalance.account & accountType=INFO] - } - } - - - protected void onSuccessRevisionResult() { - //todo 17.1 - Сообщение пользователю об успешной сверке - } - - protected void onDetectDiffRevisionResult() { - //todo 17.2 - Сообщение пользователю в случае выявления расхождений + boolean hasMissmatch = checks.stream() + .anyMatch(check -> ResultStatuses.notSuccess.equalsByKey(check.getResultStatus())); + final String finalStatus = hasMissmatch ? ResultStatuses.notSuccess.getKey() : ResultStatuses.success.getKey(); + log.trace("For company {} set GenerationStatus = {}", forCompany.getId(), finalStatus); + for (VerificationResult check : checks) check.setGenerationStatus(finalStatus); + return checks; } /* @@ -211,89 +326,14 @@ public class VerificationResultComponent { return index; } - //todo to classes: VerificationResult! - static class VerificationResult extends BusinessObject { - private String clearingCode; // type="2" - private Long accountId; // type="1" - private BigDecimal inSum; // type="11" - private BigDecimal outIntSum; // type="11" - private BigDecimal outExtSum; // type="11" - private BigDecimal diffSum; // type="11" - private Long generationId; // type="1" - private String generationStatus; // type="12" - private String resultStatus; // type="12" - - public String getClearingCode() { - return clearingCode; - } - - public void setClearingCode(String clearingCode) { - this.clearingCode = clearingCode; - } - - public Long getAccountId() { - return accountId; - } - - public void setAccountId(Long accountId) { - this.accountId = accountId; - } - - public BigDecimal getInSum() { - return inSum; - } - - public void setInSum(BigDecimal inSum) { - this.inSum = inSum; - } - - public BigDecimal getOutIntSum() { - return outIntSum; - } - - public void setOutIntSum(BigDecimal outIntSum) { - this.outIntSum = outIntSum; - } - - public BigDecimal getOutExtSum() { - return outExtSum; - } - - public void setOutExtSum(BigDecimal outExtSum) { - this.outExtSum = outExtSum; - } - - public BigDecimal getDiffSum() { - return diffSum; - } - - public void setDiffSum(BigDecimal diffSum) { - this.diffSum = diffSum; - } - - public Long getGenerationId() { - return generationId; - } - - public void setGenerationId(Long generationId) { - this.generationId = generationId; - } - - public String getGenerationStatus() { - return generationStatus; - } - - public void setGenerationStatus(String generationStatus) { - this.generationStatus = generationStatus; - } - - public String getResultStatus() { - return resultStatus; - } - - public void setResultStatus(String resultStatus) { - this.resultStatus = resultStatus; + public static Map> indexList(Collection from, Function indexFieldExtractor) { + Map> index = new HashMap<>(); + for (V obj : from) { + K key = indexFieldExtractor.apply(obj); + List lst = index.computeIfAbsent(key, (_key_) -> new ArrayList<>()); + lst.add(obj); } + return index; } } diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/VerificationResultMapStore.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/VerificationResultMapStore.java new file mode 100644 index 000000000..6be9d9717 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/VerificationResultMapStore.java @@ -0,0 +1,76 @@ +package ru.spcex.clearing.imdg.object; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.clearing.VerificationResult; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.imdg.base.TemplateMapStore; +import ru.spcex.platform.utils.time.TimeUtil; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; + +@Component +public class VerificationResultMapStore extends TemplateMapStore { + + public VerificationResultMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_VerificationResult; + } + + @Override + public String getTableName() { + return "VERIFICATION_RESULT"; + } + + @Override + public String[] getFields() { + return new String[]{ + "CLEARING_CODE", "ACCOUNT_ID", "IN_SUM", "OUT_INT_SUM", "OUT_EXT_SUM", "DIFF_SUM", "GENERATION_ID", "GENERATION_STATUS", "RESULT_STATUS", + "ID", "CREATED_AT", "UPDATED_AT" + }; + } + + @Override + public VerificationResult objectReader(ResultSet resultSet) throws SQLException { + VerificationResult object = new VerificationResult(); + object.setClearingCode(resultSet.getObject("CLEARING_CODE", String.class)); + object.setAccountId(resultSet.getObject("ACCOUNT_ID", Long.class)); + object.setInSum(resultSet.getObject("IN_SUM", BigDecimal.class)); + object.setOutIntSum(resultSet.getObject("OUT_INT_SUM", BigDecimal.class)); + object.setOutExtSum(resultSet.getObject("OUT_EXT_SUM", BigDecimal.class)); + object.setDiffSum(resultSet.getObject("DIFF_SUM", BigDecimal.class)); + object.setGenerationId(resultSet.getObject("GENERATION_ID", Long.class)); + object.setGenerationStatus(resultSet.getObject("GENERATION_STATUS", String.class)); + object.setResultStatus(resultSet.getObject("RESULT_STATUS", String.class)); + object.setId(resultSet.getObject("ID", Long.class)); + object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT")); + object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT")); + return object; + } + + @Override + public Object[] objectToField(VerificationResult object) { + Object[] args = new Object[]{ + object.getClearingCode(), + object.getAccountId(), + object.getInSum(), + object.getOutIntSum(), + object.getOutExtSum(), + object.getDiffSum(), + object.getGenerationId(), + object.getGenerationStatus(), + object.getResultStatus(), + object.getId(), + TimeUtil.toDateFromInstant(object.getCreated()), + TimeUtil.toDateFromInstant(object.getUpdated()) + }; + return args; + } + +} diff --git a/clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/structure/RunnableMapNamesForTesting.java b/clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/structure/RunnableMapNamesForTesting.java index b40d6f16f..b267a93f2 100644 --- a/clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/structure/RunnableMapNamesForTesting.java +++ b/clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/structure/RunnableMapNamesForTesting.java @@ -1,6 +1,7 @@ package ru.spcex.clearing.imdg.structure; import ru.clearing.classes.statics.data.account.*; +import ru.clearing.classes.statics.data.clearing.VerificationResult; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.company.CompanyHistory; import ru.clearing.classes.statics.data.company.CompanyRoleSet; @@ -77,6 +78,7 @@ public class RunnableMapNamesForTesting { new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("23.22")}))); businessObjectAndBusinessEventForCheckMapStores.add(new BusinessObjectAndBusinessEventForCheckMapStore<>(IMDGDistributedNames.Map_UserConnect, UserConnect.class)); businessObjectAndBusinessEventForCheckMapStores.add(new BusinessObjectAndBusinessEventForCheckMapStore<>(IMDGDistributedNames.Map_User, User.class)); + businessObjectAndBusinessEventForCheckMapStores.add(new BusinessObjectAndBusinessEventForCheckMapStore<>(IMDGDistributedNames.Map_VerificationResult, VerificationResult.class)); //dictionary dictionaryObjectForCheckMapStores.add(new DictionaryObjectForCheckMapStore<>(IMDGDistributedNames.Map_AccountStatusDictionary, AccountStatusDictionary.class)); diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java index 055c72b9b..ed239339f 100644 --- a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java +++ b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java @@ -119,8 +119,9 @@ public final class IMDGDistributedNames { public static final String Map_ReportRegister = "Map_ReportRegister"; public static final String Map_ContractRegister = "Map_ContractRegister"; public static final String Map_OrderRegister = "Map_OrderRegister"; + public static final String Map_VerificationResult = "Map_VerificationResult"; - public static final String MAP_SEQUENCE_NAME = "MAP_SEQUENCE_NAME"; // todo вынести idGenerator отдельно и завернуть в метод, чтобы не напрямую обращаться. + public static final String MAP_SEQUENCE_NAME = "MAP_SEQUENCE_NAME"; private IMDGDistributedNames() { }