treshenkov/indic-search-service
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: treshenkov:v2
Branches Tags
treshenkov:dev
treshenkov:v4-async
treshenkov:v4
treshenkov:v3
treshenkov:v2
treshenkov:v1
..
compare: treshenkov:dev
Branches Tags
treshenkov:v4-async
treshenkov:v4
treshenkov:v3
treshenkov:v2
treshenkov:v1
treshenkov:dev

No commits in common. "v2" and "dev" have entirely different histories.
v2 ... dev

58 changed files with 2 additions and 3403 deletions
Show stats Expand all files Collapse all files

3
src/main/java/ru/nbch/indicsearchservice/config/ObjectMapperConfig.java
View file

@ -6,13 +6,14 @@ import org.springframework.context.annotation.Configuration;
import tools.jackson.core.StreamReadConstraints;
import tools.jackson.core.json.JsonFactory;
import tools.jackson.databind.MapperFeature;
import tools.jackson.databind.ObjectMapper;
import tools.jackson.databind.PropertyNamingStrategies;
import tools.jackson.databind.json.JsonMapper;
@Configuration
public class ObjectMapperConfig {
@Bean
public JsonMapper objectMapper() {
public ObjectMapper objectMapper() {
JsonFactory factory = JsonFactory.builder()
.streamReadConstraints(StreamReadConstraints.builder()
.maxStringLength(100_000_000)

5
src/main/java/ru/nbch/indicsearchservice/filter/TableFilter.java
View file

@ -1,5 +0,0 @@
package ru.nbch.indicsearchservice.filter;
public interface TableFilter {
}

50
src/main/java/ru/nbch/indicsearchservice/filter/firstlevel/DefaultFirstLevelTableFilter.java
View file

@ -1,50 +0,0 @@
package ru.nbch.indicsearchservice.filter.firstlevel;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
@Component
public class DefaultFirstLevelTableFilter implements FirstLevelTableFilter {
private static final Set<String> SUPPORTED_TABLE_NAMES = Set.of(
"RU_UID",
"RU_APPLICATION",
"RU_OBLIGPARTTAKE",
"RU_BANKRUPTCY",
"RU_SETTLED",
"RU_OTHERLEGAL",
"RU_CAPABILITY",
"RU_DEBT_BURDEN_INFO",
"ACCOUNT",
"INFORMATION",
"BANKRUPTCY",
"CONSUMER_BANKRUPTCY",
"LEGAL"
);
@Override
public List<TableData> applyFilter(Map<String, List<TableData>> tableDataMapByFid, String memberCode) {
List<TableData> result = new ArrayList<>();
for (Map.Entry<String, List<TableData>> entry : tableDataMapByFid.entrySet()) {
String tableName = entry.getKey();
List<TableData> tableRows = entry.getValue();
if (SUPPORTED_TABLE_NAMES.contains(tableName)) {
List<TableData> tableRowsWithMatchingMemberCode = tableRows.stream()
.filter(row -> row.getFieldData().stream()
.anyMatch(field -> "MEMBER_CODE".equals(field.columnName()) &&
field.columnValue() != null &&
field.columnValue().toString().startsWith(memberCode)))
.toList();
result.addAll(tableRowsWithMatchingMemberCode);
}
}
return result;
}
}

10
src/main/java/ru/nbch/indicsearchservice/filter/firstlevel/FirstLevelTableFilter.java
View file

@ -1,10 +0,0 @@
package ru.nbch.indicsearchservice.filter.firstlevel;
import java.util.List;
import java.util.Map;
import ru.nbch.indicsearchservice.filter.TableFilter;
import ru.nbch.indicsearchservice.model.TableData;
public interface FirstLevelTableFilter extends TableFilter {
List<TableData> applyFilter(Map<String, List<TableData>> tableDataMapByFid, String memberCode);
}

69
src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/AccountSecondLevelTableFilter.java
View file

@ -1,69 +0,0 @@
package ru.nbch.indicsearchservice.filter.secondlevel;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
@Component
public class AccountSecondLevelTableFilter implements SecondLevelTableFilter {
private static final Set<String> SUPPORTED_TABLE_NAMES = Set.of(
"ACCOUNT_AMEND",
"PAYMENT",
"COLLATERAL",
"GUARANTOR",
"BANK_GUARANTEE"
);
@Override
public void applyFilter(List<TableData> firstLevelTableDataList, Map<String, List<TableData>> tableDataMapByFid) {
if (firstLevelTableDataList == null || firstLevelTableDataList.isEmpty() || tableDataMapByFid == null) {
return;
}
Map<Object, List<TableData>> relatedTablesByAccSerialNum = new HashMap<>();
for (String supportedTableName : SUPPORTED_TABLE_NAMES) {
List<TableData> childTables = tableDataMapByFid.get(supportedTableName);
if (childTables != null) {
for (TableData childTable : childTables) {
Object accSerialNum = getFieldValue(childTable, "ACC_SERIAL_NUM");
if (accSerialNum != null) {
relatedTablesByAccSerialNum
.computeIfAbsent(accSerialNum, k -> new ArrayList<>())
.add(childTable);
}
}
}
}
for (TableData parentTable : firstLevelTableDataList) {
Object serialNum = getFieldValue(parentTable, "SERIAL_NUM");
if (serialNum != null) {
List<TableData> matchedParentTables = relatedTablesByAccSerialNum.get(serialNum);
if (matchedParentTables != null) {
parentTable.getRelatedTableData().addAll(matchedParentTables);
}
}
}
}
private Object getFieldValue(TableData tableData, String targetColumnName) {
if (tableData.getFieldData() == null) {
return null;
}
for (TableData.FieldData field : tableData.getFieldData()) {
if (targetColumnName.equals(field.columnName())) {
return field.columnValue();
}
}
return null;
}
}

77
src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuUidSecondLevelTableFilter.java
View file

@ -1,77 +0,0 @@
package ru.nbch.indicsearchservice.filter.secondlevel;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
@Component
public class RuUidSecondLevelTableFilter implements SecondLevelTableFilter {
private static final Set<String> SUPPORTED_TABLE_NAMES = Set.of(
"RU_TRADE",
"RU_ACCOUNT_AMT",
"RU_COBORROWER",
"RU_PAYMT_CONDITION",
"RU_OVERALLVAL",
"RU_AMENDMENT",
"RU_FUNDDATE",
"RU_ARREAR",
"RU_DUEARREAR",
"RU_PASTDUEARREAR",
"RU_PAYMT",
"RU_MONTHAVERPAYMT",
"RU_SOURCENONMONETOBLIG"
);
@Override
public void applyFilter(List<TableData> firstLevelTableDataList, Map<String, List<TableData>> tableDataMapByFid) {
if (firstLevelTableDataList == null || firstLevelTableDataList.isEmpty() || tableDataMapByFid == null) {
return;
}
Map<Object, List<TableData>> relatedTablesByAccSerialNum = new HashMap<>();
for (String supportedTableName : SUPPORTED_TABLE_NAMES) {
List<TableData> childTables = tableDataMapByFid.get(supportedTableName);
if (childTables != null) {
for (TableData childTable : childTables) {
Object accSerialNum = getFieldValue(childTable, "ACC_SERIAL_NUM");
if (accSerialNum != null) {
relatedTablesByAccSerialNum
.computeIfAbsent(accSerialNum, k -> new ArrayList<>())
.add(childTable);
}
}
}
}
for (TableData parentTable : firstLevelTableDataList) {
Object serialNum = getFieldValue(parentTable, "SERIAL_NUM");
if (serialNum != null) {
List<TableData> matchedParentTables = relatedTablesByAccSerialNum.get(serialNum);
if (matchedParentTables != null) {
parentTable.getRelatedTableData().addAll(matchedParentTables);
}
}
}
}
private Object getFieldValue(TableData tableData, String targetColumnName) {
if (tableData.getFieldData() == null) {
return null;
}
for (TableData.FieldData field : tableData.getFieldData()) {
if (targetColumnName.equals(field.columnName())) {
return field.columnValue();
}
}
return null;
}
}

10
src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/SecondLevelTableFilter.java
View file

@ -1,10 +0,0 @@
package ru.nbch.indicsearchservice.filter.secondlevel;
import java.util.List;
import java.util.Map;
import ru.nbch.indicsearchservice.filter.TableFilter;
import ru.nbch.indicsearchservice.model.TableData;
public interface SecondLevelTableFilter extends TableFilter {
void applyFilter(List<TableData> firstLevelTableDataList, Map<String, List<TableData>> tableDataMapByFid);
}

88
src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/BlocksThirdLevelTableFilter.java
View file

@ -1,88 +0,0 @@
package ru.nbch.indicsearchservice.filter.thirdlevel;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
@Component
public class BlocksThirdLevelTableFilter implements ThirdLevelTableFilter {
private static final Set<String> SUPPORTED_TABLE_NAMES = Set.of(
"RU_COLLATERAL_BLOCKS",
"RU_BANKRUPTCY_BLOCKS"
);
@Override
public void applyFilter(List<TableData> firstLevelTableDataList, Map<String, List<TableData>> tableDataMapByFid) {
if (firstLevelTableDataList == null || firstLevelTableDataList.isEmpty() || tableDataMapByFid == null) {
return;
}
Map<String, Map<Object, List<TableData>>> childTablesByParentAndSerial = new HashMap<>();
for (String tableName : SUPPORTED_TABLE_NAMES) {
String parentTableName = tableName.replace("_BLOCKS", "");
String childTableName = tableName;
List<TableData> childTables = tableDataMapByFid.get(childTableName);
if (childTables != null) {
Map<Object, List<TableData>> groupedChildTables = new HashMap<>();
for (TableData childTable : childTables) {
Object parentSerialNum = getFieldValue(childTable, "PARENT_SERIAL_NUM");
if (parentSerialNum != null) {
groupedChildTables
.computeIfAbsent(parentSerialNum, k -> new ArrayList<>())
.add(childTable);
}
}
childTablesByParentAndSerial.put(parentTableName, groupedChildTables);
}
}
for (TableData firstLevelTable : firstLevelTableDataList) {
if (firstLevelTable.getRelatedTableData() == null) {
continue;
}
for (TableData secondLevelTable : firstLevelTable.getRelatedTableData()) {
String tableName = secondLevelTable.getTableName();
String parentTableName = tableName;
String childTableName = tableName + "_BLOCKS";
if (SUPPORTED_TABLE_NAMES.contains(childTableName)) {
Map<Object, List<TableData>> availableChildTables = childTablesByParentAndSerial.get(parentTableName);
if (availableChildTables != null) {
Object serialNum = getFieldValue(secondLevelTable, "SERIAL_NUM");
if (serialNum != null) {
List<TableData> matchingChildTables = availableChildTables.get(serialNum);
if (matchingChildTables != null) {
secondLevelTable.getRelatedTableData().addAll(matchingChildTables);
}
}
}
}
}
}
}
private Object getFieldValue(TableData tableData, String targetColumnName) {
if (tableData.getFieldData() == null) {
return null;
}
for (TableData.FieldData field : tableData.getFieldData()) {
if (targetColumnName.equals(field.columnName())) {
return field.columnValue();
}
}
return null;
}
}

10
src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/ThirdLevelTableFilter.java
View file

@ -1,10 +0,0 @@
package ru.nbch.indicsearchservice.filter.thirdlevel;
import java.util.List;
import java.util.Map;
import ru.nbch.indicsearchservice.filter.TableFilter;
import ru.nbch.indicsearchservice.model.TableData;
public interface ThirdLevelTableFilter extends TableFilter {
void applyFilter(List<TableData> firstLevelTableDataList, Map<String, List<TableData>> tableDataMapByFid);
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuAccountAmtTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuAccountAmtTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuAccountAmtTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_ACCOUNT_AMT";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerIndividTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuAcquirerIndividTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuAcquirerIndividTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_ACQUIRERINDIVID";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerLegalTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuAcquirerLegalTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuAcquirerLegalTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_ACQUIRERLEGAL";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuAllArrearsTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuAllArrearsTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuAllArrearsTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_ALL_ARREARS";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuAmendmentTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuAmendmentTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuAmendmentTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_AMENDMENT";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuAmountInfoTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuAmountInfoTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuAmountInfoTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_AMOUNT_INFO";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuApplicationTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuApplicationTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuApplicationTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_APPLICATION";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuArrearTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuArrearTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuArrearTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_ARREAR";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyBlocksTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuBankruptcyBlocksTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuBankruptcyBlocksTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_BANKRUPTCY_BLOCKS";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuBankruptcyTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuBankruptcyTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_BANKRUPTCY";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuCapabilityTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuCapabilityTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuCapabilityTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_CAPABILITY";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuCoborrowerTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuCoborrowerTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuCoborrowerTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_COBORROWER";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuCollatInsuredTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuCollatInsuredTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuCollatInsuredTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_COLLATINSURED";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuCollatRepayTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuCollatRepayTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuCollatRepayTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_COLLATREPAY";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralBlocksTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuCollateralBlocksTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuCollateralBlocksTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_COLLATERAL_BLOCKS";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuCollateralTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuCollateralTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_COLLATERAL";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuContractTermsChangesTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuContractTermsChangesTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuContractTermsChangesTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_CONTRACT_TERMS_CHANGES";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuDebtBurdenInfoTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuDebtBurdenInfoTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuDebtBurdenInfoTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_DEBT_BURDEN_INFO";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuDueArrearTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuDueArrearTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuDueArrearTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_DUEARREAR";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuFundDateTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuFundDateTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuFundDateTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_FUNDDATE";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuGuaranteeRepayTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuGuaranteeRepayTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuGuaranteeRepayTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_GUARANTEEREPAY";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuGuarantorTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuGuarantorTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuGuarantorTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_GUARANTOR";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuIndepGuarantorTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuIndepGuarantorTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuIndepGuarantorTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_INDEPGUARANTOR";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuLegalRecordTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuLegalRecordTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuLegalRecordTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_LEGALRECORD";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuMonthAverPaymtTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuMonthAverPaymtTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuMonthAverPaymtTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_MONTHAVERPAYMT";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuObligAccountTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuObligAccountTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuObligAccountTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_OBLIGACCOUNT";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuObligPartTakeTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuObligPartTakeTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuObligPartTakeTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_OBLIGPARTTAKE";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuObligTerminationTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuObligTerminationTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuObligTerminationTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_OBLIGTERMINATION";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcBankruptTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuObligsRcBankruptTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuObligsRcBankruptTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_OBLIGSRCBANKRUPT";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcLiquidTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuObligsRcLiquidTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuObligsRcLiquidTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_OBLIGSRCLIQUID";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuOtherLegalTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuOtherLegalTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuOtherLegalTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_OTHERLEGAL";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuOverallvalTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuOverallvalTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuOverallvalTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_OVERALLVAL";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuPastDueArrearTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuPastDueArrearTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuPastDueArrearTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_PASTDUEARREAR";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtConditionTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuPaymtConditionTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuPaymtConditionTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_PAYMT_CONDITION";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuPaymtTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuPaymtTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_PAYMT";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuServiceCoTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuServiceCoTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuServiceCoTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_SERVICECO";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuSettledTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuSettledTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuSettledTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_SETTLED";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuSourceNonMonetObligTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuSourceNonMonetObligTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuSourceNonMonetObligTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_SOURCENONMONETOBLIG";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuSubjectNonMonetObligTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuSubjectNonMonetObligTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuSubjectNonMonetObligTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_SUBJECTNONMONETOBLIG";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuSubmitHoldTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuSubmitHoldTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuSubmitHoldTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_SUBMITHOLD";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuTradeTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuTradeTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuTradeTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_TRADE";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

52
src/main/java/ru/nbch/indicsearchservice/loader/RuUidTableLoader.java
View file

@ -1,52 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuUidTableLoader implements TableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
public RuUidTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public String getTableName() {
return "RU_UID";
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuUid(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
}
}

19
src/main/java/ru/nbch/indicsearchservice/loader/TableLoader.java
View file

@ -1,19 +0,0 @@
package ru.nbch.indicsearchservice.loader;
import java.util.List;
import java.util.Set;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
public interface TableLoader {
List<DataType> getSuitableDataTypes();
List<SearchParameter> getSuitableSearchParameters();
String getTableName();
default boolean isSuitableForDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter) {
return getSuitableDataTypes().contains(dataType) && getSuitableSearchParameters().contains(searchParameter);
}
List<TableData> searchByFid(Set<Integer> fids);
}

62
src/main/java/ru/nbch/indicsearchservice/model/TableData.java
View file

@ -1,62 +0,0 @@
package ru.nbch.indicsearchservice.model;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
public class TableData {
private String tableName;
private List<FieldData> fieldData = new ArrayList<>();
private List<TableData> relatedTableData = new ArrayList<>();
public TableData() {
}
public TableData(String tableName, List<FieldData> fieldData) {
this.tableName = tableName;
this.fieldData = fieldData;
}
public TableData(String tableName, List<FieldData> fieldData, List<TableData> relatedTableData) {
this.tableName = tableName;
this.fieldData = fieldData;
this.relatedTableData = relatedTableData;
}
public String getTableName() {
return tableName;
}
public List<FieldData> getFieldData() {
return fieldData;
}
public List<TableData> getRelatedTableData() {
return relatedTableData;
}
@Override
public boolean equals(Object o) {
if (o == null || getClass() != o.getClass()) return false;
TableData tableData = (TableData) o;
return Objects.equals(tableName, tableData.tableName) && Objects.equals(fieldData, tableData.fieldData) && Objects.equals(relatedTableData, tableData.relatedTableData);
}
@Override
public int hashCode() {
return Objects.hash(tableName, fieldData, relatedTableData);
}
@Override
public String toString() {
return "TableData{" +
"tableName='" + tableName + '\'' +
", fieldData=" + fieldData +
", relatedTableData=" + relatedTableData +
'}';
}
public record FieldData(String columnName,
Object columnValue) {
}
}

44
src/main/java/ru/nbch/indicsearchservice/repository/indic/IndicMapper.java
View file

@ -2,7 +2,6 @@ package ru.nbch.indicsearchservice.repository.indic;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.cursor.Cursor;
import ru.nbch.indicsearchservice.repository.MyBatisRepository;
@ -11,49 +10,6 @@ import ru.nbch.indicsearchservice.repository.MyBatisRepository;
public interface IndicMapper extends MyBatisRepository {
List<LinkedHashMap<String, String>> getTableColumnsByTableNames(List<String> tables);
List<LinkedHashMap<String, Object>> findAllByFidFromRuUid(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuTrade(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuApplication(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAccountAmt(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerIndivid(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerLegal(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAllArrears(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAmendment(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAmountInfo(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuArrear(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcy(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcyBlocks(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCapability(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCoborrower(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCollateral(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCollateralBlocks(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCollatInsured(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCollatRepay(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuContractTermsChanges(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuDebtBurdenInfo(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuDueArrear(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuFundDate(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuGuaranteeRepay(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuGuarantor(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuIndepGuarantor(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuLegalRecord(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuMonthAverPaymt(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligAccount(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligPartTake(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcBankrupt(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcLiquid(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligTermination(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuOtherLegal(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuOverallval(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuPastDueArrear(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuPaymtCondition(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuPaymt(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuServiceCo(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuSettled(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuSourceNonMonetOblig(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuSubjectNonMonetOblig(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuSubmitHold(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUid(String columns, String acctNum, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUidCursor(String columns, String acctNum, String memberCode);
List<LinkedHashMap<String, Object>> findAllByApplicationNumberAndMemberCodeFromRuApplication(String columns, String applicationNumber, String memberCode);

87
src/main/java/ru/nbch/indicsearchservice/service/IndicSearchService.java
View file

@ -1,101 +1,14 @@
package ru.nbch.indicsearchservice.service;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.StopWatch;
import ru.nbch.indicsearchservice.dto.request.AddSearchJobRequestDto;
import ru.nbch.indicsearchservice.dto.response.AddSearchJobResponseDto;
import ru.nbch.indicsearchservice.dto.response.JobStatusResponseDto;
import ru.nbch.indicsearchservice.filter.firstlevel.DefaultFirstLevelTableFilter;
import ru.nbch.indicsearchservice.filter.secondlevel.SecondLevelTableFilter;
import ru.nbch.indicsearchservice.filter.thirdlevel.ThirdLevelTableFilter;
import ru.nbch.indicsearchservice.loader.TableLoader;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.util.ExcelWriter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import tools.jackson.databind.json.JsonMapper;
@Service
public class IndicSearchService {
private static final Logger log = LoggerFactory.getLogger(IndicSearchService.class);
private static final boolean IS_EXPORT_AS_EXCEL = true;
private final List<TableLoader> tableLoaders;
private final DefaultFirstLevelTableFilter firstLevelTableFilter;
private final List<SecondLevelTableFilter> secondLevelTableFilters;
private final List<ThirdLevelTableFilter> thirdLevelTableFilters;
private final IndicSearchUtils indicSearchUtils;
private final ExcelWriter excelWriter;
private final JsonMapper jsonMapper;
public IndicSearchService(List<TableLoader> tableLoaders,
DefaultFirstLevelTableFilter firstLevelTableFilter,
List<SecondLevelTableFilter> secondLevelTableFilters,
List<ThirdLevelTableFilter> thirdLevelTableFilters,
IndicSearchUtils indicSearchUtils,
ExcelWriter excelWriter,
JsonMapper jsonMapper) {
this.tableLoaders = tableLoaders;
this.firstLevelTableFilter = firstLevelTableFilter;
this.secondLevelTableFilters = secondLevelTableFilters;
this.thirdLevelTableFilters = thirdLevelTableFilters;
this.indicSearchUtils = indicSearchUtils;
this.excelWriter = excelWriter;
this.jsonMapper = jsonMapper;
}
public AddSearchJobResponseDto addSearchJob(AddSearchJobRequestDto request) {
StopWatch sw = new StopWatch();
sw.start();
List<TableLoader> suitableTableLoaders = new ArrayList<>();
for (TableLoader tableLoader : tableLoaders) {
if (tableLoader.isSuitableForDataTypeAndSearchParameter(request.getDataType(), request.getSearchParameter())) {
suitableTableLoaders.add(tableLoader);
}
}
Set<Integer> foundFids = indicSearchUtils.getFidsBasedOnDataTypeAndSearchParameter(
request.getDataType(),
request.getSearchParameter(),
request.getSearchValue()
);
Map<String, List<TableData>> tableDataMapByFid = new ConcurrentHashMap<>();
suitableTableLoaders.parallelStream().forEach(tl -> tableDataMapByFid.put(tl.getTableName(), tl.searchByFid(foundFids)));
// for (TableLoader tableLoader : suitableTableLoaders) {
// tableDataMapByFid.put(tableLoader.getTableName(), tableLoader.searchByFid(foundFids));
// }
List<TableData> result = firstLevelTableFilter.applyFilter(tableDataMapByFid, request.getMemberCode());
secondLevelTableFilters.forEach(f -> f.applyFilter(result, tableDataMapByFid));
thirdLevelTableFilters.forEach(f -> f.applyFilter(result, tableDataMapByFid));
sw.stop();
log.info(sw.prettyPrint());
if (!IS_EXPORT_AS_EXCEL) {
try {
Files.write(Path.of("1.json"), jsonMapper.writeValueAsBytes(result));
} catch (IOException e) {
throw new RuntimeException(e);
}
} else {
excelWriter.writeExcelFile(result);
}
return null;
}

181
src/main/java/ru/nbch/indicsearchservice/util/ExcelWriter.java
View file

@ -1,181 +0,0 @@
package ru.nbch.indicsearchservice.util;
import jakarta.annotation.Nullable;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.apache.commons.lang3.mutable.MutableInt;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
@Component
public class ExcelWriter {
private static final Logger log = LoggerFactory.getLogger(ExcelWriter.class);
public void writeExcelFile(List<TableData> tableDataList) {
Map<String, List<TableData>> tableDataGroupedByTables = tableDataList.stream()
.collect(Collectors.groupingBy(TableData::getTableName));
Path excelFile = Path.of("2.xlsx");
try (SXSSFWorkbook workbook = new SXSSFWorkbook();
OutputStream os = Files.newOutputStream(excelFile)) {
CellStyle headerCellStyle = createHeaderCellStyle(workbook);
CellStyle cellStyle = createCellStyle(workbook);
for (Map.Entry<String, List<TableData>> entry : tableDataGroupedByTables.entrySet()) {
String tableName = entry.getKey();
List<TableData> tableRows = entry.getValue();
Sheet tableSheet = createSheet(workbook, tableName.toUpperCase());
MutableInt currentRow = new MutableInt(0);
for (TableData tableRow : tableRows) {
writeDataSheetIntoSheetRow(
tableRow,
tableSheet,
currentRow,
headerCellStyle,
cellStyle
);
}
}
workbook.write(os);
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
private CellStyle createHeaderCellStyle(Workbook workbook) {
CellStyle headerCellStyle = workbook.createCellStyle();
headerCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
XSSFFont font = (XSSFFont) workbook.createFont();
font.setFontName("SansSerif");
font.setFontHeightInPoints((short) 11);
font.setBold(true);
headerCellStyle.setFont(font);
return headerCellStyle;
}
private CellStyle createCellStyle(Workbook workbook) {
CellStyle cellStyle = workbook.createCellStyle();
cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
cellStyle.setBorderBottom(BorderStyle.THIN);
cellStyle.setBorderLeft(BorderStyle.THIN);
cellStyle.setBorderTop(BorderStyle.THIN);
cellStyle.setBorderRight(BorderStyle.THIN);
XSSFFont font = (XSSFFont) workbook.createFont();
font.setFontName("Calibri");
font.setFontHeightInPoints((short) 11);
cellStyle.setFont(font);
return cellStyle;
}
private Sheet createSheet(Workbook workbook, String sheetName) {
Sheet sheet = workbook.createSheet(sheetName);
sheet.setColumnWidth(0, 25 * 256);
sheet.setColumnWidth(1, 115 * 256);
sheet.setColumnWidth(2, 38 * 256);
return sheet;
}
private void createHeaderRow(String localizedTableName,
Sheet sheet,
MutableInt currentRow,
CellStyle headerCellStyle) {
Row headerRow = sheet.createRow(currentRow.intValue());
headerRow.setHeightInPoints(15);
Cell headerCell = headerRow.createCell(0);
headerCell.setCellValue(localizedTableName);
headerCell.setCellStyle(headerCellStyle);
sheet.addMergedRegion(new CellRangeAddress(currentRow.intValue(), currentRow.intValue(), 0, 2));
currentRow.increment();
}
public void writeDataSheetIntoSheetRow(TableData tableData,
Sheet sheet,
MutableInt currentRow,
CellStyle headerCellStyle,
CellStyle cellStyle) {
createHeaderRow(
tableData.getTableName(),
sheet,
currentRow,
headerCellStyle
);
for (TableData.FieldData fieldData : tableData.getFieldData()) {
writeFieldDataIntoSheetRow(
fieldData.columnName(),
fieldData.columnName(),
fieldData.columnValue(),
sheet,
currentRow,
cellStyle
);
}
currentRow.increment();
if (!tableData.getRelatedTableData().isEmpty()) {
for (TableData relatedTableData : tableData.getRelatedTableData()) {
writeDataSheetIntoSheetRow(
relatedTableData,
sheet,
currentRow,
headerCellStyle,
cellStyle
);
}
}
}
private void writeFieldDataIntoSheetRow(String fieldKey,
String localizedFieldKey,
@Nullable Object fieldValue,
Sheet sheet,
MutableInt currentRow,
CellStyle cellStyle) {
Row dataRow = sheet.createRow(currentRow.intValue());
dataRow.setHeightInPoints(15);
Cell dataFieldCell = dataRow.createCell(0);
dataFieldCell.setCellValue(fieldKey.toUpperCase());
dataFieldCell.setCellStyle(cellStyle);
Cell descriptionCell = dataRow.createCell(1);
descriptionCell.setCellValue(localizedFieldKey);
descriptionCell.setCellStyle(cellStyle);
Cell dataValueCell = dataRow.createCell(2);
dataValueCell.setCellValue(Optional.ofNullable(fieldValue).orElse("").toString());
dataValueCell.setCellStyle(cellStyle);
currentRow.increment();
}
}

85
src/main/java/ru/nbch/indicsearchservice/util/IndicSearchUtils.java
View file

@ -1,85 +0,0 @@
package ru.nbch.indicsearchservice.util;
import java.sql.Date;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
@Component
public class IndicSearchUtils {
public Set<Integer> getFidsBasedOnDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter, String searchValue) {
Set<Integer> fids = new HashSet<>();
if (dataType == null || searchParameter == null) {
return fids;
}
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.FID) {
return Set.of(Integer.parseInt(searchValue));
}
} else if (dataType == DataType.TUTDF) {
if (searchParameter == SearchParameter.FID) {
return Set.of(Integer.parseInt(searchValue));
}
}
return fids;
}
public TableData mapToTableData(String table, Map<String, Object> row) {
List<TableData.FieldData> fields = row.entrySet().stream()
.map(e -> new TableData.FieldData(e.getKey(), parseTableValue(e.getValue())))
.toList();
return new TableData(table, fields);
}
private Object parseTableValue(Object value) {
return switch (value) {
case Timestamp timestamp ->
timestamp.toLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
case Date date -> {
LocalDate localDate = date.toLocalDate();
if (localDate.equals(Date.valueOf("0001-01-01").toLocalDate()) ||
localDate.equals(Date.valueOf("0001-01-03").toLocalDate())) {
yield null;
}
yield localDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
}
case Integer i -> {
if (i == Integer.MAX_VALUE) {
yield null;
}
yield i;
}
case Long l -> {
if (l == Long.MAX_VALUE) {
yield null;
}
yield l;
}
case null -> null;
default -> value;
};
}
public List<TableData> getFirstLevelTables(Map<String, List<TableData>> tableDataMapByFid) {
List<TableData> result = new ArrayList<>();
for (Map.Entry<String, List<TableData>> entry : tableDataMapByFid.entrySet()) {
if (entry.getKey().equals("RU_UID")) {}
}
return result;
}
}

421
src/main/resources/mappers/indic/indic_mapper.xml
View file

@ -14,427 +14,6 @@
WITH UR
</select>
<select id="findAllByFidFromRuUid" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_UID
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuTrade" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_TRADE
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuApplication" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_APPLICATION
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuAccountAmt" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_ACCOUNT_AMT
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuAcquirerIndivid" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_ACQUIRERINDIVID
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuAcquirerLegal" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_ACQUIRERLEGAL
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuAllArrears" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_ALL_ARREARS
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuAmendment" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_AMENDMENT
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuAmountInfo" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_AMOUNT_INFO
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuArrear" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_ARREAR
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuBankruptcy" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_BANKRUPTCY
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuBankruptcyBlocks" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_BANKRUPTCY_BLOCKS
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuCapability" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_CAPABILITY
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuCoborrower" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_COBORROWER
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuCollateral" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_COLLATERAL
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuCollateralBlocks" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_COLLATERAL_BLOCKS
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuCollatInsured" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_COLLATINSURED
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuCollatRepay" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_COLLATREPAY
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuContractTermsChanges" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_CONTRACT_TERMS_CHANGES
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuDebtBurdenInfo" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_DEBT_BURDEN_INFO
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuDueArrear" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_DUEARREAR
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuFundDate" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_FUNDDATE
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuGuaranteeRepay" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_GUARANTEEREPAY
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuGuarantor" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_GUARANTOR
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuIndepGuarantor" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_INDEPGUARANTOR
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuLegalRecord" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_LEGALRECORD
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuMonthAverPaymt" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_MONTHAVERPAYMT
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuObligAccount" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_OBLIGACCOUNT
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuObligPartTake" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_OBLIGPARTTAKE
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuObligsRcBankrupt" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_OBLIGSRCBANKRUPT
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuObligsRcLiquid" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_OBLIGSRCLIQUID
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuObligTermination" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_OBLIGTERMINATION
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuOtherLegal" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_OTHERLEGAL
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuOverallval" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_OVERALLVAL
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuPastDueArrear" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_PASTDUEARREAR
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuPaymtCondition" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_PAYMT_CONDITION
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuPaymt" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_PAYMT
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuServiceCo" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_SERVICECO
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuSettled" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_SETTLED
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuSourceNonMonetOblig" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_SOURCENONMONETOBLIG
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuSubjectNonMonetOblig" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_SUBJECTNONMONETOBLIG
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByFidFromRuSubmitHold" resultType="java.util.LinkedHashMap" timeout="60">
SELECT *
FROM INDIC.RU_SUBMITHOLD
WHERE FID IN
<foreach item="fid" collection="fids" open="(" separator="," close=")">
#{fid}
</foreach>
WITH UR
</select>
<select id="findAllByAcctNumAndMemberCodeFromRuUid" resultType="java.util.LinkedHashMap" timeout="60">
SELECT ${columns}
FROM INDIC.RU_UID