diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/A_D_RegistryMapStore.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/A_D_RegistryMapStore.java new file mode 100644 index 000000000..65d9e16e6 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/A_D_RegistryMapStore.java @@ -0,0 +1,28 @@ +package ru.spcex.clearing.imdg.businessobject; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.enumeration.RegistryDesignation; + +@Component +public class A_D_RegistryMapStore extends OptionalRegistryMapStore { + public A_D_RegistryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_A_D_Registry; + } + + @Override + protected String statusFilter() { + return trueFilter(); + } + + @Override + protected String designationFilter() { + return buildFilter("or", "registry_designation", RegistryDesignation.O, RegistryDesignation.T); + } +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/FailObligationRegistryMapStore.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/FailObligationRegistryMapStore.java new file mode 100644 index 000000000..7b5e20585 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/FailObligationRegistryMapStore.java @@ -0,0 +1,41 @@ +package ru.spcex.clearing.imdg.businessobject; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.imdg.filter.RegistrySqlFilter; + +@Component +public class FailObligationRegistryMapStore extends OptionalRegistryMapStore { + public FailObligationRegistryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected RegistrySqlFilter registrySqlFilter() { + return null; + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_FailObligationRegistry; + } + + @Override + protected String statusFilter() { + return null; +// return buildFilter("or", "status", +// RegistryStatus.FAIL, RegistryStatus.UNCV, RegistryStatus.NACK, RegistryStatus.NACC); + } + + @Override + protected String dateFilter() { + return ""; + } + + @Override + protected String designationFilter() { + return null; +// return buildFilter("or", "registry_designation", RegistryDesignation.O, RegistryDesignation.T); + } +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/OkObligationRegistryMapStore.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/OkObligationRegistryMapStore.java new file mode 100644 index 000000000..fc6c77b32 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/OkObligationRegistryMapStore.java @@ -0,0 +1,48 @@ +package ru.spcex.clearing.imdg.businessobject; + +import java.time.LocalDate; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.imdg.filter.RegistrySqlFilter; +import ru.spcex.clearing.imdg.filter.RegistrySqlFilterBuilder; +import ru.spcex.platform.enumeration.RegistryDesignation; +import ru.spcex.platform.enumeration.RegistryStatus; + +@Component +public class OkObligationRegistryMapStore extends OptionalRegistryMapStore { + public OkObligationRegistryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected RegistrySqlFilter registrySqlFilter() { + return RegistrySqlFilterBuilder.BUILDER + .designationFilter(RegistryDesignation.O, RegistryDesignation.T) + .statusFilter(RegistryStatus.OK, RegistryStatus.CLRD) + .dateFilter(LocalDate.now()) + .build(); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_OkObligationRegistry; + } + + @Override + protected String statusFilter() { + return buildFilter("or", "status", + RegistryStatus.OK.getKey(), RegistryStatus.CLRD.getKey()); + } + + @Override + protected String designationFilter() { + return buildFilter("or", "registry_designation", RegistryDesignation.O.getKey(), RegistryDesignation.T.getKey()); + } + + @Override + protected String dateFilter() { + return null; + } + +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/OptionalRegistryMapStore.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/OptionalRegistryMapStore.java new file mode 100644 index 000000000..28cd42742 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/OptionalRegistryMapStore.java @@ -0,0 +1,181 @@ +package ru.spcex.clearing.imdg.businessobject; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.time.LocalDate; +import java.util.List; +import com.hazelcast.config.MapIndexConfig; +import org.apache.commons.lang3.exception.ExceptionUtils; +import org.springframework.jdbc.core.JdbcTemplate; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.spcex.clearing.imdg.filter.RegistrySqlFilter; +import ru.spcex.clearing.imdg.base.TemplateMapStore; +import ru.spcex.platform.utils.time.TimeUtil; + +public abstract class OptionalRegistryMapStore extends TemplateMapStore { + private final MapIndexConfig[] indexes; + + public OptionalRegistryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + indexes = new MapIndexConfig[]{ + new MapIndexConfig().setAttribute("sessionId").setOrdered(false), + new MapIndexConfig().setAttribute("tradingClearingRegistryId").setOrdered(false), + new MapIndexConfig().setAttribute("companyId").setOrdered(false), + new MapIndexConfig().setAttribute("accountId").setOrdered(false), + new MapIndexConfig().setAttribute("settlementDate").setOrdered(false), + new MapIndexConfig().setAttribute("groupId").setOrdered(false), + }; + } + + @Override + public String getTableName() { + return "REGISTRY"; + } + + @Override + public MapIndexConfig[] getIndexes() { + return indexes; + } + + @Override + public Iterable loadAllKeys() { + LocalDate today = LocalDate.now(); + log.debug("loadAllKeys from {} with condition and today {}", getTableName(), today); + List keys; + RegistrySqlFilter registrySqlFilter = registrySqlFilter(); + String sql = "select id from " + getTableName() + + " WHERE " + registrySqlFilter.getSqlCondition(); + try { + keys = jdbcTemplate.query(sql, + (resultSet, i) -> resultSet.getLong("id"), + registrySqlFilter.getArgs()); + } catch (Throwable e) { + log.error("At load keys from {} (sql \"{}\"): {}", getTableName(), sql, ExceptionUtils.getStackTrace(e)); + throw e; + } + return keys; + } + + protected abstract RegistrySqlFilter registrySqlFilter(); + + protected String trueFilter() { + return "true"; + } + + @Override + public String[] getFields() { + return new String[]{ + "COMPANY_ID", "TRADING_CODE", "CLEARING_CODE", "SHORT_NAME", "FULL_NAME", "ACCOUNT_ID", "ACCOUNT_TYPE", "ACCOUNT", "REGISTRY_DESIGNATION", "REGISTRY_INSTRUMENT_TYPE", "REGISTRY_CAPACITY", "REGISTRY_UNIT", "REGISTRY_CODE", "TRADING_CLEARING_REGISTRY_ID", "TRADING_CLEARING_REGISTRY", "REGISTRY_STATUS", "SECURITY_SYMBOL", "BALANCE", "OPEN_BALANCE", "CLOSE_BALANCE", "CREDIT", "DEBIT", "SETTLED_CREDIT", "SETTLED_DEBIT", "CHECK_BALANCE", "DIFF_BALANCE", "PLAN_BALANCE", "BALANCE_DIMENSION", "SETTLEMENT_DATE", "SETTLEMENT_CODE", "TRADING_DATE", "CLEARING_DATE", "REFUND_DATE", "VALUE_DATE", "PRICE", "CONTRACT", "COUNTER_PARTY_ID", "COMMENT", "PARENT_ID", "GROUP_ID", "SESSION_ID", "SESSION_TYPE", "PAYMENT_ID", "ID", "CREATED_AT", "UPDATED_AT", "SECURITY_ID", "SECTION" + }; + } + + @Override + public Registry objectReader(ResultSet resultSet) throws SQLException { + Registry object = new Registry(); + object.setCompanyId(resultSet.getObject("COMPANY_ID", Long.class)); + object.setTradingCode(resultSet.getObject("TRADING_CODE", String.class)); + object.setClearingCode(resultSet.getObject("CLEARING_CODE", String.class)); + object.setShortName(resultSet.getObject("SHORT_NAME", String.class)); + object.setFullName(resultSet.getObject("FULL_NAME", String.class)); + object.setAccountId(resultSet.getObject("ACCOUNT_ID", Long.class)); + object.setAccountType(resultSet.getObject("ACCOUNT_TYPE", String.class)); + object.setAccount(resultSet.getObject("ACCOUNT", String.class)); + object.setRegistryDesignation(resultSet.getObject("REGISTRY_DESIGNATION", String.class)); + object.setRegistryInstrumentType(resultSet.getObject("REGISTRY_INSTRUMENT_TYPE", String.class)); + object.setRegistryCapacity(resultSet.getObject("REGISTRY_CAPACITY", String.class)); + object.setRegistryUnit(resultSet.getObject("REGISTRY_UNIT", String.class)); + object.setRegistryCode(resultSet.getObject("REGISTRY_CODE", String.class)); + object.setTradingClearingRegistryId(resultSet.getObject("TRADING_CLEARING_REGISTRY_ID", Long.class)); + object.setTradingClearingRegistry(resultSet.getObject("TRADING_CLEARING_REGISTRY", String.class)); + object.setRegistryStatus(resultSet.getObject("REGISTRY_STATUS", String.class)); + object.setSecuritySymbol(resultSet.getObject("SECURITY_SYMBOL", String.class)); + object.setBalance(resultSet.getObject("BALANCE", BigDecimal.class)); + object.setOpenBalance(resultSet.getObject("OPEN_BALANCE", BigDecimal.class)); + object.setCloseBalance(resultSet.getObject("CLOSE_BALANCE", BigDecimal.class)); + object.setCredit(resultSet.getObject("CREDIT", BigDecimal.class)); + object.setDebit(resultSet.getObject("DEBIT", BigDecimal.class)); + object.setSettledCredit(resultSet.getObject("SETTLED_CREDIT", BigDecimal.class)); + object.setSettledDebit(resultSet.getObject("SETTLED_DEBIT", BigDecimal.class)); + object.setCheckBalance(resultSet.getObject("CHECK_BALANCE", BigDecimal.class)); + object.setDiffBalance(resultSet.getObject("DIFF_BALANCE", BigDecimal.class)); + object.setPlanBalance(resultSet.getObject("PLAN_BALANCE", BigDecimal.class)); + object.setBalanceDimension(resultSet.getObject("BALANCE_DIMENSION", String.class)); + object.setSettlementDate(getLocalDateFromSqlDate(resultSet, "SETTLEMENT_DATE")); + object.setSettlementCode(resultSet.getObject("SETTLEMENT_CODE", String.class)); + object.setTradingDate(getLocalDateFromSqlDate(resultSet, "TRADING_DATE")); + object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE")); + object.setRefundDate(getLocalDateFromSqlDate(resultSet, "REFUND_DATE")); + object.setValueDate(getLocalDateFromSqlDate(resultSet, "VALUE_DATE")); + object.setPrice(resultSet.getObject("PRICE", BigDecimal.class)); + object.setContract(resultSet.getObject("CONTRACT", String.class)); + object.setCounterPartyId(resultSet.getObject("COUNTER_PARTY_ID", Long.class)); + object.setComment(resultSet.getObject("COMMENT", String.class)); + object.setParentId(resultSet.getObject("PARENT_ID", Long.class)); + object.setGroupId(resultSet.getObject("GROUP_ID", Long.class)); + object.setSessionId(resultSet.getObject("SESSION_ID", Long.class)); + object.setSessionType(resultSet.getObject("SESSION_TYPE", String.class)); + object.setPaymentId(resultSet.getObject("PAYMENT_ID", Long.class)); + object.setId(resultSet.getObject("ID", Long.class)); + object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT")); + object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT")); + object.setSecurityId(resultSet.getObject("SECURITY_ID", Long.class)); + object.setSection(resultSet.getObject("SECTION", String.class)); + return object; + } + + @Override + public Object[] objectToField(Registry object) { + Object[] args = new Object[]{ + object.getCompanyId(), + object.getTradingCode(), + object.getClearingCode(), + object.getShortName(), + object.getFullName(), + object.getAccountId(), + object.getAccountType(), + object.getAccount(), + object.getRegistryDesignation(), + object.getRegistryInstrumentType(), + object.getRegistryCapacity(), + object.getRegistryUnit(), + object.getRegistryCode(), + object.getTradingClearingRegistryId(), + object.getTradingClearingRegistry(), + object.getRegistryStatus(), + object.getSecuritySymbol(), + object.getBalance(), + object.getOpenBalance(), + object.getCloseBalance(), + object.getCredit(), + object.getDebit(), + object.getSettledCredit(), + object.getSettledDebit(), + object.getCheckBalance(), + object.getDiffBalance(), + object.getPlanBalance(), + object.getBalanceDimension(), + TimeUtil.toDateFromLocalDate(object.getSettlementDate()), + object.getSettlementCode(), + TimeUtil.toDateFromLocalDate(object.getTradingDate()), + TimeUtil.toDateFromLocalDate(object.getClearingDate()), + TimeUtil.toDateFromLocalDate(object.getRefundDate()), + TimeUtil.toDateFromLocalDate(object.getValueDate()), + object.getPrice(), + object.getContract(), + object.getCounterPartyId(), + object.getComment(), + object.getParentId(), + object.getGroupId(), + object.getSessionId(), + object.getSessionType(), + object.getPaymentId(), + object.getId(), + TimeUtil.toDateFromInstant(object.getCreated()), + TimeUtil.toDateFromInstant(object.getUpdated()), + object.getSecurityId(), + object.getSection() + }; + return args; + } +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/ProcObligationRegistryMapStore.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/ProcObligationRegistryMapStore.java new file mode 100644 index 000000000..56c74e550 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/ProcObligationRegistryMapStore.java @@ -0,0 +1,48 @@ +package ru.spcex.clearing.imdg.businessobject; + +import java.time.LocalDate; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.imdg.filter.RegistrySqlFilter; +import ru.spcex.clearing.imdg.filter.RegistrySqlFilterBuilder; +import ru.spcex.platform.enumeration.RegistryDesignation; +import ru.spcex.platform.enumeration.RegistryStatus; + +@Component +public class ProcObligationRegistryMapStore extends OptionalRegistryMapStore { + public ProcObligationRegistryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected RegistrySqlFilter registrySqlFilter() { + return RegistrySqlFilterBuilder.BUILDER + .designationFilter(RegistryDesignation.O, RegistryDesignation.T) + .statusFilter(RegistryStatus.PROC, RegistryStatus.MNG, RegistryStatus.SPLT) + .dateFilter(LocalDate.now()); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_ProcObligationRegistry; + } + +// @Override +// protected String statusFilter() { +// return null; +//// return buildFilter("or", "status", +//// RegistryStatus.PROC, RegistryStatus.MNG, RegistryStatus.SPLT); +// } +// +// @Override +// protected String dateFilter() { +// return ""; +// } +// +// @Override +// protected String designationFilter() { +// return null; +//// return buildFilter("or", "registry_designation", RegistryDesignation.O, RegistryDesignation.T); +// } +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/GroupOfConditions.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/GroupOfConditions.java new file mode 100644 index 000000000..fcfc05552 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/GroupOfConditions.java @@ -0,0 +1,14 @@ +package ru.spcex.clearing.imdg.filter; + +public class GroupOfConditions { + private SqlCondition[] conditions; + private String operatorBetweenConditions; + + public SqlCondition[] getConditions() { + return conditions; + } + + public String getOperatorBetweenConditions() { + return operatorBetweenConditions; + } +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/RegistrySqlFilter.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/RegistrySqlFilter.java new file mode 100644 index 000000000..7049e8bea --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/RegistrySqlFilter.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.imdg.filter; + +public class RegistrySqlFilter { + private String sqlCondition; + private Object[] args; + + public RegistrySqlFilter(String sqlCondition, Object[] args) { + this.sqlCondition = sqlCondition; + this.args = args; + } + + public String getSqlCondition() { + return sqlCondition; + } + + public Object[] getArgs() { + return args; + } +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/RegistrySqlFilterBuilder.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/RegistrySqlFilterBuilder.java new file mode 100644 index 000000000..322c7ff52 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/RegistrySqlFilterBuilder.java @@ -0,0 +1,82 @@ +package ru.spcex.clearing.imdg.filter; + +import java.time.LocalDate; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.stream.Collectors; +import ru.spcex.platform.enumeration.RegistryDesignation; +import ru.spcex.platform.enumeration.RegistryStatus; + +public enum RegistrySqlFilterBuilder { + BUILDER; + + private RegistryDesignation[] designations; + private RegistryStatus[] statuses; + private LocalDate[] dates = null; + private List conditions = new ArrayList<>(); + + public RegistrySqlFilterBuilder addCondition(GroupOfConditions groupOfConditions) { + this.conditions.add(groupOfConditions); + return this; + } + + public RegistrySqlFilterBuilder designationFilter(RegistryDesignation... designations) { + this.designations = designations; + return this; + } + + public RegistrySqlFilterBuilder statusFilter(RegistryStatus... statuses) { + this.statuses = statuses; + return this; + } + + public RegistrySqlFilterBuilder dateFilter(LocalDate... dates) { + this.dates = dates; + return this; + } + + public RegistrySqlFilter build() { + List sqlFilters = new ArrayList<>(); + Iterator iterator = conditions.iterator(); + while (iterator.hasNext()) { + GroupOfConditions conditions = iterator.next(); + Arrays.stream(conditions.getConditions()).map(this::buildFilter).c + } + + + if (designations != null) { + String filter = buildFilter("or", "registry_designation", + Arrays.stream(designations).map(RegistryDesignation::getKey).toArray(String[]::new)); + sqlFilters.add(filter); + } + if (statuses != null) { + String filter = buildFilter("or", "status", + Arrays.stream(statuses).map(RegistryStatus::getKey).toArray(String[]::new)); + sqlFilters.add(filter); + } + if (dates != null){ + String filter = "settlement_date > ?"; + } + return new RegistrySqlFilter(String.join("and", sqlFilters), dates); + } + + private Filter buildFilter(SqlCondition sqlCondition) { + String sql = String.format("%s %s '%s'", sqlCondition.getFieldName(), sqlCondition.getSqlOperators().getKey(), sqlCondition.getValue()); + return new Filter(sql, sqlCondition.isStrictCondition() ? "and" : "or"); +// return Arrays.stream(values) +// .map(value -> String.format("%s %s '%s'", filteringFieldName, sqlOperator.getKey(), value)) +// .collect(Collectors.joining(String.format(" %s ", operatorValue))); + } + + private static class Filter { + private final String sqlFilter; + private final String conditionOperator; + + private Filter(String sqlFilter, String conditionOperator) { + this.sqlFilter = sqlFilter; + this.conditionOperator = conditionOperator; + } + } +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/SqlCondition.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/SqlCondition.java new file mode 100644 index 000000000..06064da2d --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/SqlCondition.java @@ -0,0 +1,40 @@ +package ru.spcex.clearing.imdg.filter; + +public class SqlCondition { + private String fieldName; + private String value; + private SqlOperators sqlOperators; + private boolean isStrictCondition; + + public String getFieldName() { + return fieldName; + } + + public void setFieldName(String fieldName) { + this.fieldName = fieldName; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + public SqlOperators getSqlOperators() { + return sqlOperators; + } + + public void setSqlOperators(SqlOperators sqlOperators) { + this.sqlOperators = sqlOperators; + } + + public boolean isStrictCondition() { + return isStrictCondition; + } + + public void setStrictCondition(boolean strictCondition) { + isStrictCondition = strictCondition; + } +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/SqlOperators.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/SqlOperators.java new file mode 100644 index 000000000..691be4e6c --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/filter/SqlOperators.java @@ -0,0 +1,22 @@ +package ru.spcex.clearing.imdg.filter; + +import ru.spcex.platform.utils.enumeration.IEnumKey; + +public enum SqlOperators implements IEnumKey { + EQUALS("="), + GREATER_THAN(">="), + GREATER(">"), + LESS_THAN("<="), + LESS("<"); + + private final String key; + + SqlOperators(String key) { + this.key = key; + } + + @Override + public String getKey() { + return ""; + } +} 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 0249ad7b1..b3d5a7d10 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 @@ -187,6 +187,11 @@ public final class IMDGDistributedNames { public static final String Map_TradingClearingRegistry = "Map_TradingClearingRegistry"; public static final String Map_TradingClearingRegistryHistory = "Map_TradingClearingRegistryHistory"; public static final String Map_Registry = "Map_Registry"; + //----------------SPECIFIC REGISTRY MAP STORES BY STATUS AND DESIGNATION--------------- + public static final String Map_OkObligationRegistry = "Map_OkObligationRegistry"; + public static final String Map_ProcObligationRegistry = "Map_ProcObligationRegistry"; + public static final String Map_FailObligationRegistry = "Map_FailObligationRegistry"; + public static final String Map_A_D_Registry = "Map_A_D_Registry"; public static final String Map_RegistryHistory = "Map_RegistryHistory"; public static final String Map_DepoAccount = "Map_DepoAccount"; public static final String Map_DepoAccountHistory = "Map_DepoAccountHistory";