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

new search parameters added

Browse source
This commit is contained in:
Ivan Nikolaev-Axenov 2026-05-25 17:54:52 +03:00
parent 0f431b54c1
commit 99fc4ed500
60 changed files with 1329 additions and 2885 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/main/java/ru/nbch/indicsearchservice/aggregator/FileAggregator.java
View file

@ -9,13 +9,11 @@ import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
public interface FileAggregator {
List<DataType> getSuitableDataTypes();
List<SearchParameter> getSuitableSearchParameters();
List<String> getRequiredTables();
default boolean isSuitableForDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter) {
return getSuitableDataTypes().contains(dataType) && getSuitableSearchParameters().contains(searchParameter);
}
Path aggregateFiles(Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter, UUID taskId);
Path aggregateFiles(UUID taskId,
DataType dataType,
SearchParameter searchParameter,
String searchValue,
String memberCode,
Map<String, Path> tableFileMap,
MutableLong rowCounter);
}

22
src/main/java/ru/nbch/indicsearchservice/aggregator/FileAggregatorCommon.java
View file

@ -52,7 +52,12 @@ public class FileAggregatorCommon {
"RU_ALL_ARREARS"
);
void aggregateRuUidFiles(BufferedWriter aggregatedFileWriter, Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter) {
void aggregateRuUidFiles(BufferedWriter aggregatedFileWriter,
Map<String, Path> tableFileMap,
String memberCode,
String acctNum,
String uuid,
MutableLong rowCounter) {
try (BufferedReader ruUidFileReader = Files.newBufferedReader(tableFileMap.get("RU_UID"))) {
Map<String, MovableBufferedReader> childTablesReadersMap = new LinkedHashMap<>();
for (String tableName : RU_UID_CHILD_TABLES) {
@ -75,6 +80,21 @@ public class FileAggregatorCommon {
continue;
}
if (acctNum != null) {
Optional<String> foundAcctNum = IndicSearchCommon.getRowValue(lineList, "ACCT_NUM");
if (foundAcctNum.isPresent() && !foundAcctNum.get().equals(acctNum)) {
continue;
}
}
if (uuid != null) {
Optional<String> foundUuid = IndicSearchCommon.getRowValue(lineList, "UUID");
if (foundUuid.isPresent() && !foundUuid.get().equals(uuid)) {
continue;
}
}
aggregatedFileWriter.write(ruUidLine);
aggregatedFileWriter.newLine();
rowCounter.increment();

95
src/main/java/ru/nbch/indicsearchservice/aggregator/GutdfFidFileAggregator.java
View file

@ -1,95 +0,0 @@
package ru.nbch.indicsearchservice.aggregator;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import org.apache.commons.lang3.mutable.MutableLong;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchCommon;
@Component
public class GutdfFidFileAggregator implements FileAggregator {
private static final List<String> REQUIRED_TABLES = List.of(
"RU_UID",
"RU_APPLICATION",
"RU_OBLIGPARTTAKE",
"RU_BANKRUPTCY",
"RU_SETTLED",
"RU_OTHERLEGAL",
"RU_CAPABILITY",
"RU_DEBT_BURDEN_INFO"
);
private final ApplicationSettings settings;
private final FileAggregatorCommon fileAggregatorCommon;
public GutdfFidFileAggregator(ApplicationSettings settings,
FileAggregatorCommon fileAggregatorCommon) {
this.settings = settings;
this.fileAggregatorCommon = fileAggregatorCommon;
}
@Override
public List<DataType> getSuitableDataTypes() {
return List.of(DataType.GUTDF, DataType.RUTDF);
}
@Override
public List<SearchParameter> getSuitableSearchParameters() {
return List.of(SearchParameter.FID);
}
@Override
public List<String> getRequiredTables() {
return REQUIRED_TABLES;
}
@Override
public Path aggregateFiles(Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter, UUID taskId) {
Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
for (String tableName : getRequiredTables()) {
if (tableName.equals("RU_UID")) {
fileAggregatorCommon.aggregateRuUidFiles(aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
} else if (tableName.equals("RU_BANKRUPTCY")) {
fileAggregatorCommon.aggregateBlocksTableFile(tableName, aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
} else {
try (BufferedReader reader = Files.newBufferedReader(tableFileMap.get(tableName))) {
String line;
while ((line = reader.readLine()) != null) {
Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(line, "MEMBER_CODE");
if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
continue;
}
aggregatedFileWriter.write(line);
aggregatedFileWriter.newLine();
rowCounter.increment();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
aggregatedFileWriter.write("EOF");
} catch (IOException e) {
throw new RuntimeException(e);
}
return aggregatedFile;
}
}

92
src/main/java/ru/nbch/indicsearchservice/aggregator/GutdfFidPassportOgrnFileAggregator.java Normal file
View file

@ -0,0 +1,92 @@
package ru.nbch.indicsearchservice.aggregator;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import org.apache.commons.lang3.mutable.MutableLong;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchCommon;
@Component
public class GutdfFidPassportOgrnFileAggregator implements FileAggregator {
private static final List<String> REQUIRED_TABLES = List.of(
"RU_UID",
"RU_APPLICATION",
"RU_OBLIGPARTTAKE",
"RU_BANKRUPTCY",
"RU_SETTLED",
"RU_OTHERLEGAL",
"RU_CAPABILITY",
"RU_DEBT_BURDEN_INFO"
);
private final ApplicationSettings settings;
private final FileAggregatorCommon fileAggregatorCommon;
public GutdfFidPassportOgrnFileAggregator(ApplicationSettings settings,
FileAggregatorCommon fileAggregatorCommon) {
this.settings = settings;
this.fileAggregatorCommon = fileAggregatorCommon;
}
@Override
public Path aggregateFiles(UUID taskId,
DataType dataType,
SearchParameter searchParameter,
String searchValue,
String memberCode,
Map<String, Path> tableFileMap,
MutableLong rowCounter) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.FID || searchParameter == SearchParameter.OGRN || searchParameter == SearchParameter.PASSPORT) {
Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
for (String tableName : REQUIRED_TABLES) {
if (tableName.equals("RU_UID")) {
fileAggregatorCommon.aggregateRuUidFiles(aggregatedFileWriter, tableFileMap, memberCode, null, null, rowCounter);
} else if (tableName.equals("RU_BANKRUPTCY")) {
fileAggregatorCommon.aggregateBlocksTableFile(tableName, aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
} else {
try (BufferedReader reader = Files.newBufferedReader(tableFileMap.get(tableName))) {
String line;
while ((line = reader.readLine()) != null) {
Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(line, "MEMBER_CODE");
if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
continue;
}
aggregatedFileWriter.write(line);
aggregatedFileWriter.newLine();
rowCounter.increment();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
aggregatedFileWriter.write("EOF");
} catch (IOException e) {
throw new RuntimeException(e);
}
return aggregatedFile;
}
}
return null;
}
}

77
src/main/java/ru/nbch/indicsearchservice/aggregator/GutdfRuApplicationFileAggregator.java Normal file
View file

@ -0,0 +1,77 @@
package ru.nbch.indicsearchservice.aggregator;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import org.apache.commons.lang3.mutable.MutableLong;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchCommon;
@Component
public class GutdfRuApplicationFileAggregator implements FileAggregator {
private final ApplicationSettings settings;
public GutdfRuApplicationFileAggregator(ApplicationSettings settings) {
this.settings = settings;
}
@Override
public Path aggregateFiles(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap, MutableLong rowCounter) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.APPLICATION_NUMBER || searchParameter == SearchParameter.OLD_APP_NUM) {
Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND);
BufferedReader reader = Files.newBufferedReader(tableFileMap.get("RU_APPLICATION"))) {
String line;
while ((line = reader.readLine()) != null) {
Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(line, "MEMBER_CODE");
if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
continue;
}
if (searchParameter == SearchParameter.APPLICATION_NUMBER && searchValue != null) {
searchValue = searchValue.length() > 38 ? searchValue.substring(0, 38) : searchValue;
Optional<String> foundApplicationNumber = IndicSearchCommon.getRowValue(line, "APPLICATION_NUMBER");
if (foundApplicationNumber.isPresent() && !foundApplicationNumber.get().equals(searchValue)) {
continue;
}
}
if (searchParameter == SearchParameter.OLD_APP_NUM && searchValue != null) {
Optional<String> foundOldAppNum = IndicSearchCommon.getRowValue(line, "OLD_APP_NUM");
if (foundOldAppNum.isPresent() && !foundOldAppNum.get().equals(searchValue)) {
continue;
}
}
aggregatedFileWriter.write(line);
aggregatedFileWriter.newLine();
rowCounter.increment();
}
aggregatedFileWriter.write("EOF");
} catch (IOException e) {
throw new RuntimeException(e);
}
return aggregatedFile;
}
}
return null;
}
}

55
src/main/java/ru/nbch/indicsearchservice/aggregator/GutdfRuUidFileAggregator.java Normal file
View file

@ -0,0 +1,55 @@
package ru.nbch.indicsearchservice.aggregator;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import org.apache.commons.lang3.mutable.MutableLong;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchCommon;
@Component
public class GutdfRuUidFileAggregator implements FileAggregator {
private final ApplicationSettings settings;
private final FileAggregatorCommon fileAggregatorCommon;
public GutdfRuUidFileAggregator(ApplicationSettings settings,
FileAggregatorCommon fileAggregatorCommon) {
this.settings = settings;
this.fileAggregatorCommon = fileAggregatorCommon;
}
@Override
public Path aggregateFiles(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap, MutableLong rowCounter) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.UUID || searchParameter == SearchParameter.ACCT_NUM) {
Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
if (searchParameter == SearchParameter.UUID) {
fileAggregatorCommon.aggregateRuUidFiles(aggregatedFileWriter, tableFileMap, memberCode, null, searchValue, rowCounter);
} else {
fileAggregatorCommon.aggregateRuUidFiles(aggregatedFileWriter, tableFileMap, memberCode, searchValue, null, rowCounter);
}
aggregatedFileWriter.write("EOF");
} catch (IOException e) {
throw new RuntimeException(e);
}
return aggregatedFile;
}
}
return null;
}
}

6
src/main/java/ru/nbch/indicsearchservice/exporter/ExcelExporter.java
View file

@ -41,7 +41,11 @@ public class ExcelExporter implements Exporter {
this.settings = settings;
}
public void writeExcelFile(Path aggregatedFile, UUID taskId, Long totalRows) {
public void writeExcelFile(@Nullable Path aggregatedFile, UUID taskId, Long totalRows) {
if (aggregatedFile == null) {
return;
}
Path excelFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".xlsx");
try (OutputStream os = Files.newOutputStream(excelFile);

7
src/main/java/ru/nbch/indicsearchservice/exporter/JsonExporter.java
View file

@ -1,5 +1,6 @@
package ru.nbch.indicsearchservice.exporter;
import jakarta.annotation.Nullable;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
@ -30,7 +31,11 @@ public class JsonExporter implements Exporter {
this.jsonMapper = jsonMapper;
}
public void writeJsonFile(Path aggregatedFile, UUID taskId) {
public void writeJsonFile(@Nullable Path aggregatedFile, UUID taskId) {
if (aggregatedFile == null) {
return;
}
Path jsonFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".json");
try (BufferedReader reader = Files.newBufferedReader(aggregatedFile);

16
src/main/java/ru/nbch/indicsearchservice/loader/FirstLevelTableLoader.java Normal file
View file

@ -0,0 +1,16 @@
package ru.nbch.indicsearchservice.loader;
import java.nio.file.Path;
import java.util.Map;
import java.util.UUID;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
public interface FirstLevelTableLoader extends TableLoader {
void searchBy(UUID taskId,
DataType dataType,
SearchParameter searchParameter,
String searchValue,
String memberCode,
Map<String, Path> tableFileMap);
}

71
src/main/java/ru/nbch/indicsearchservice/loader/IdTableLoader.java Normal file
View file

@ -0,0 +1,71 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class IdTableLoader implements FirstLevelTableLoader {
private final MapperHolder mapperHolder;
private final List<TableLoaderForId> tableLoaders;
public IdTableLoader(MapperHolder mapperHolder,
List<TableLoaderForId> tableLoaders) {
this.mapperHolder = mapperHolder;
this.tableLoaders = tableLoaders;
}
@Override
public String getTableName() {
return "ID";
}
@Override
@Transactional(readOnly = true)
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.OGRN || searchParameter == SearchParameter.PASSPORT) {
Set<Integer> foundFids = new HashSet<>();
try (Cursor<LinkedHashMap<String, Object>> cursor = searchParameter == SearchParameter.OGRN ?
mapperHolder.getIndicMapper().findFidsByOgrnFromId(searchValue) :
mapperHolder.getIndicMapper().findFidsByPassportFromId(searchValue)) {
for (LinkedHashMap<String, Object> row : cursor) {
for (Map.Entry<String, Object> entry : row.entrySet()) {
String columnName = entry.getKey();
Object columnValue = entry.getValue();
if (columnName != null && columnValue != null) {
if (columnName.equals("FID")) {
foundFids.add(Integer.parseInt(columnValue.toString()));
}
}
}
}
} catch (IOException e) {
throw new RuntimeException(e);
}
tableLoaders.parallelStream().forEach(tl -> tl.searchById(
taskId,
dataType,
searchParameter,
foundFids,
memberCode,
tableFileMap
));
}
}
}
}

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

@ -1,9 +1,14 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.model.enums.DataType;
@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuApplicationTableLoader implements TableLoader {
public class RuApplicationTableLoader implements FirstLevelTableLoader, TableLoaderForId {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +27,6 @@ public class RuApplicationTableLoader implements TableLoader {
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";
@ -39,7 +34,37 @@ public class RuApplicationTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fidSet), taskId);
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.APPLICATION_NUMBER || searchParameter == SearchParameter.OLD_APP_NUM) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByMemberCodeFromRuApplication(memberCode)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
} else if (searchParameter == SearchParameter.FID) {
Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuApplication(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Override
@Transactional(readOnly = true)
public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuApplication(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}

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

@ -1,9 +1,14 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.model.enums.DataType;
@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuBankruptcyTableLoader implements TableLoader {
public class RuBankruptcyTableLoader implements FirstLevelTableLoader, TableLoaderForId {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +27,6 @@ public class RuBankruptcyTableLoader implements TableLoader {
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";
@ -39,7 +34,31 @@ public class RuBankruptcyTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fidSet), taskId);
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.FID) {
Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuBankruptcy(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Override
@Transactional(readOnly = true)
public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuBankruptcy(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}

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

@ -1,9 +1,14 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.model.enums.DataType;
@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuCapabilityTableLoader implements TableLoader {
public class RuCapabilityTableLoader implements FirstLevelTableLoader, TableLoaderForId {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +27,6 @@ public class RuCapabilityTableLoader implements TableLoader {
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";
@ -39,7 +34,31 @@ public class RuCapabilityTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fidSet), taskId);
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.FID) {
Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCapability(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Override
@Transactional(readOnly = true)
public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCapability(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}

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

@ -1,9 +1,14 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.model.enums.DataType;
@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuDebtBurdenInfoTableLoader implements TableLoader {
public class RuDebtBurdenInfoTableLoader implements FirstLevelTableLoader, TableLoaderForId {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +27,6 @@ public class RuDebtBurdenInfoTableLoader implements TableLoader {
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";
@ -39,7 +34,31 @@ public class RuDebtBurdenInfoTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fidSet), taskId);
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.FID) {
Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuDebtBurdenInfo(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Override
@Transactional(readOnly = true)
public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuDebtBurdenInfo(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}

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

@ -1,9 +1,14 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.model.enums.DataType;
@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuObligPartTakeTableLoader implements TableLoader {
public class RuObligPartTakeTableLoader implements FirstLevelTableLoader, TableLoaderForId {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +27,6 @@ public class RuObligPartTakeTableLoader implements TableLoader {
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";
@ -39,7 +34,31 @@ public class RuObligPartTakeTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fidSet), taskId);
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.FID) {
Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligPartTake(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Override
@Transactional(readOnly = true)
public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligPartTake(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}

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

@ -1,9 +1,14 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.model.enums.DataType;
@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuOtherLegalTableLoader implements TableLoader {
public class RuOtherLegalTableLoader implements FirstLevelTableLoader, TableLoaderForId {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +27,6 @@ public class RuOtherLegalTableLoader implements TableLoader {
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";
@ -39,7 +34,31 @@ public class RuOtherLegalTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fidSet), taskId);
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.FID) {
Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuOtherLegal(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Override
@Transactional(readOnly = true)
public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuOtherLegal(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}

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

@ -1,9 +1,14 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.model.enums.DataType;
@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;
@Component
public class RuSettledTableLoader implements TableLoader {
public class RuSettledTableLoader implements FirstLevelTableLoader, TableLoaderForId {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +27,6 @@ public class RuSettledTableLoader implements TableLoader {
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";
@ -39,7 +34,31 @@ public class RuSettledTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fidSet), taskId);
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.FID) {
Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSettled(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Override
@Transactional(readOnly = true)
public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSettled(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}

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

@ -1,35 +1,36 @@
package ru.nbch.indicsearchservice.loader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.loader.subtable.RuUidSubTableLoader;
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 {
public class RuUidTableLoader implements FirstLevelTableLoader, TableLoaderForId {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
private final List<RuUidSubTableLoader> ruUidSubTableLoaders;
public RuUidTableLoader(MapperHolder mapperHolder,
IndicSearchUtils indicSearchUtils) {
IndicSearchUtils indicSearchUtils,
List<RuUidSubTableLoader> ruUidSubTableLoaders) {
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);
this.ruUidSubTableLoaders = ruUidSubTableLoaders;
}
@Override
@ -39,7 +40,40 @@ public class RuUidTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuUid(fidSet), taskId);
public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.UUID || searchParameter == SearchParameter.ACCT_NUM) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByMemberCodeFromRuUid(memberCode)) {
Set<Integer> foundFids = new HashSet<>();
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids));
ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, foundFids, tableFileMap));
} catch (IOException e) {
throw new RuntimeException(e);
}
} else if (searchParameter == SearchParameter.FID) {
Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuUid(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, fids, tableFileMap));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Override
@Transactional(readOnly = true)
public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuUid(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}

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

@ -1,20 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.Map;
import java.util.UUID;
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);
}
Path searchByFid(Set<Integer> fids, UUID taskId);
}

12
src/main/java/ru/nbch/indicsearchservice/loader/TableLoaderForId.java Normal file
View file

@ -0,0 +1,12 @@
package ru.nbch.indicsearchservice.loader;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
public interface TableLoaderForId extends FirstLevelTableLoader {
void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap);
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuAccountAmtTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAccountAmtTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuAccountAmtTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuAccountAmtTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuAccountAmtTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAccountAmt(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerIndividTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAcquirerIndividTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuAcquirerIndividTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuAcquirerIndividTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuAcquirerIndividTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAcquirerIndivid(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerLegalTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAcquirerLegalTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuAcquirerLegalTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuAcquirerLegalTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuAcquirerLegalTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAcquirerLegal(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuAllArrearsTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAllArrearsTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuAllArrearsTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuAllArrearsTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuAllArrearsTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAllArrears(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuAmendmentTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAmendmentTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuAmendmentTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuAmendmentTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuAmendmentTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAmendment(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuAmountInfoTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAmountInfoTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuAmountInfoTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuAmountInfoTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuAmountInfoTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAmountInfo(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuArrearTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuArrearTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuArrearTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuArrearTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuArrearTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuArrear(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyBlocksTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuBankruptcyBlocksTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuBankruptcyBlocksTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuBankruptcyBlocksTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuBankruptcyBlocksTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuBankruptcyBlocks(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuCoborrowerTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCoborrowerTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuCoborrowerTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuCoborrowerTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuCoborrowerTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCoborrower(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuCollatInsuredTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCollatInsuredTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuCollatInsuredTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuCollatInsuredTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuCollatInsuredTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollatInsured(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuCollatRepayTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCollatRepayTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuCollatRepayTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuCollatRepayTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuCollatRepayTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollatRepay(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralBlocksTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCollateralBlocksTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuCollateralBlocksTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuCollateralBlocksTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuCollateralBlocksTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollateralBlocks(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCollateralTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuCollateralTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuCollateralTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuCollateralTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollateral(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuContractTermsChangesTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuContractTermsChangesTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuContractTermsChangesTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuContractTermsChangesTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuContractTermsChangesTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuContractTermsChanges(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuDueArrearTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuDueArrearTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuDueArrearTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuDueArrearTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuDueArrearTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuDueArrear(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuFundDateTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuFundDateTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuFundDateTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuFundDateTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuFundDateTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuFundDate(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuGuaranteeRepayTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuGuaranteeRepayTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuGuaranteeRepayTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuGuaranteeRepayTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuGuaranteeRepayTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuGuaranteeRepay(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuGuarantorTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuGuarantorTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuGuarantorTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuGuarantorTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuGuarantorTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuGuarantor(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuIndepGuarantorTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuIndepGuarantorTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuIndepGuarantorTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuIndepGuarantorTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuIndepGuarantorTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuIndepGuarantor(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuLegalRecordTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuLegalRecordTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuLegalRecordTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuLegalRecordTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuLegalRecordTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuLegalRecord(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuMonthAverPaymtTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuMonthAverPaymtTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuMonthAverPaymtTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuMonthAverPaymtTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuMonthAverPaymtTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuMonthAverPaymt(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuObligAccountTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuObligAccountTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuObligAccountTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuObligAccountTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuObligAccountTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligAccount(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuObligTerminationTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuObligTerminationTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuObligTerminationTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuObligTerminationTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuObligTerminationTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligTermination(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcBankruptTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuObligsRcBankruptTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuObligsRcBankruptTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuObligsRcBankruptTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuObligsRcBankruptTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligsRcBankrupt(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcLiquidTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuObligsRcLiquidTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuObligsRcLiquidTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuObligsRcLiquidTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuObligsRcLiquidTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligsRcLiquid(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuOverallvalTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuOverallvalTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuOverallvalTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -23,16 +24,6 @@ public class RuOverallvalTableLoader implements TableLoader {
}
@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";
@ -40,7 +31,11 @@ public class RuOverallvalTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuOverallval(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuPastDueArrearTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuPastDueArrearTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuPastDueArrearTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuPastDueArrearTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuPastDueArrearTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPastDueArrear(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtConditionTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuPaymtConditionTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuPaymtConditionTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuPaymtConditionTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuPaymtConditionTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPaymtCondition(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuPaymtTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuPaymtTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuPaymtTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuPaymtTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPaymt(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuServiceCoTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuServiceCoTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuServiceCoTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuServiceCoTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuServiceCoTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuServiceCo(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuSourceNonMonetObligTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuSourceNonMonetObligTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuSourceNonMonetObligTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuSourceNonMonetObligTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuSourceNonMonetObligTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSourceNonMonetOblig(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuSubjectNonMonetObligTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuSubjectNonMonetObligTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuSubjectNonMonetObligTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuSubjectNonMonetObligTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuSubjectNonMonetObligTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSubjectNonMonetOblig(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuSubmitHoldTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuSubmitHoldTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuSubmitHoldTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuSubmitHoldTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuSubmitHoldTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSubmitHold(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

29
src/main/java/ru/nbch/indicsearchservice/loader/RuTradeTableLoader.java → src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuTradeTableLoader.java
View file

@ -1,18 +1,19 @@
package ru.nbch.indicsearchservice.loader;
package ru.nbch.indicsearchservice.loader.subtable;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
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 {
public class RuTradeTableLoader implements RuUidSubTableLoader {
private final MapperHolder mapperHolder;
private final IndicSearchUtils indicSearchUtils;
@ -22,16 +23,6 @@ public class RuTradeTableLoader implements TableLoader {
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";
@ -39,7 +30,11 @@ public class RuTradeTableLoader implements TableLoader {
@Override
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fidSet), taskId);
public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuTrade(fids)) {
tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

10
src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuUidSubTableLoader.java Normal file
View file

@ -0,0 +1,10 @@
package ru.nbch.indicsearchservice.loader.subtable;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
public interface RuUidSubTableLoader extends SubTableLoader {
void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap);
}

10
src/main/java/ru/nbch/indicsearchservice/loader/subtable/SubTableLoader.java Normal file
View file

@ -0,0 +1,10 @@
package ru.nbch.indicsearchservice.loader.subtable;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import ru.nbch.indicsearchservice.loader.TableLoader;
public interface SubTableLoader extends TableLoader {
}

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

@ -11,212 +11,52 @@ import ru.nbch.indicsearchservice.repository.MyBatisRepository;
public interface IndicMapper extends MyBatisRepository {
List<LinkedHashMap<String, String>> getTableColumnsByTableNames(List<String> tables);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuUid(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuTrade(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuApplication(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAccountAmt(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerIndivid(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerLegal(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAllArrears(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAmendment(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAmountInfo(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuArrear(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcy(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcyBlocks(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCapability(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCoborrower(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollateral(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollateralBlocks(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollatInsured(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollatRepay(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuContractTermsChanges(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuDebtBurdenInfo(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuDueArrear(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuFundDate(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuGuaranteeRepay(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuGuarantor(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuIndepGuarantor(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuLegalRecord(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuMonthAverPaymt(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligAccount(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligPartTake(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcBankrupt(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcLiquid(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligTermination(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuOtherLegal(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuOverallval(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPastDueArrear(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPaymtCondition(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPaymt(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuServiceCo(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSettled(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSourceNonMonetOblig(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSubjectNonMonetOblig(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSubmitHold(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuUid(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuApplication(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligPartTake(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuBankruptcy(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSettled(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuOtherLegal(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCapability(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuDebtBurdenInfo(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);
Cursor<LinkedHashMap<String, Object>> findAllByApplicationNumberAndMemberCodeFromRuApplicationCursor(String columns, String applicationNumber, String memberCode);
Long countAllByApplicationNumberAndMemberCodeFromRuApplication(String applicationNumber, String memberCode);
List<LinkedHashMap<String, Object>> findAllByUuidFromRuUid(String columns, String uuid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByUuidFromRuUidCursor(String columns, String uuid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByOgrnFromId(String idNorm);
Cursor<LinkedHashMap<String, Object>> findAllByOgrnFromIdCursor(String idNorm);
List<String> findAllDistinctFidByOgrnFromId(String idNorm);
List<LinkedHashMap<String, Object>> findAllByOgrnTutdfFromId(String idNorm);
Cursor<LinkedHashMap<String, Object>> findAllByOgrnTutdfFromIdCursor(String idNorm);
List<String> findAllDistinctFidByOgrnTutdfFromId(String idNorm);
List<LinkedHashMap<String, Object>> findAllByPassportFromId(String idNorm);
Cursor<LinkedHashMap<String, Object>> findAllByPassportFromIdCursor(String idNorm);
List<String> findAllDistinctFidByPassportFromId(String idNorm);
List<LinkedHashMap<String, Object>> findAllByPassportTutdfFromId(String idNorm);
Cursor<LinkedHashMap<String, Object>> findAllByPassportTutdfFromIdCursor(String idNorm);
List<String> findAllDistinctFidByPassportTutdfFromId(String idNorm);
List<LinkedHashMap<String, Object>> findAllByOldAppNumFromRuApplication(String columns, String oldAppNum, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByOldAppNumFromRuApplicationCursor(String columns, String oldAppNum, String memberCode);
Long countAllByOldAppNumFromRuApplication(String oldAppNum, String memberCode);
List<LinkedHashMap<String, Object>> findAllByAcctNumFromAccount(String columns, String acctNum, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByAcctNumFromAccountCursor(String columns, String acctNum, String memberCode);
List<LinkedHashMap<String, Object>> findAllBySerialNumFromAccount(String columns, String serialNum, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllBySerialNumFromAccountCursor(String columns, String serialNum, String memberCode);
List<LinkedHashMap<String, Object>> findAllByUuidFromAccount(String columns, String uuid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByUuidFromAccountCursor(String columns, String uuid, String memberCode);
List<LinkedHashMap<String, Object>> findAllBySerialNumAndMemberCodeFromInformation(String columns, String serialNum, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllBySerialNumAndMemberCodeFromInformationCursor(String columns, String serialNum, String memberCode);
Long countAllBySerialNumAndMemberCodeFromInformation(String serialNum, String memberCode);
List<LinkedHashMap<String, Object>> findAllByAppNumAndMemberCodeFromInformation(String columns, String appNum, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByAppNumAndMemberCodeFromInformationCursor(String columns, String appNum, String memberCode);
Long countAllByAppNumAndMemberCodeFromInformation(String appNum, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByMemberCodeFromRuUid(String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByMemberCodeFromRuApplication(String memberCode);
Cursor<LinkedHashMap<String, Object>> findFidsByOgrnFromId(String idNorm);
Cursor<LinkedHashMap<String, Object>> findFidsByPassportFromId(String idNorm);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuTrade(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuTradeCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAccountAmt(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAccountAmtCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCoborrower(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCoborrowerCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtCondition(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtConditionCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuOverallval(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuOverallvalCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmendment(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmendmentCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuFunddate(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuFunddateCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuArrear(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuArrearCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuDuearrear(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuDuearrearCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPastduearrear(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPastduearrearCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymt(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuMonthaverpaymt(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuMonthaverpaymtCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSourcenonmonetoblig(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSourcenonmonetobligCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubjectnonmonetoblig(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubjectnonmonetobligCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollateral(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollateralCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuarantor(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuarantorCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuIndepguarantor(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuIndepguarantorCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollatinsured(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollatinsuredCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollatrepay(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollatrepayCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuaranteerepay(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuaranteerepayCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligtermination(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligterminationCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubmithold(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubmitholdCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAcquirerlegal(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAcquirerlegalCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAcquirerindivid(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAcquirerindividCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuServiceco(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuServicecoCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligaccount(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligaccountCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuLegalrecord(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuLegalrecordCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligsrcbankrupt(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligsrcbankruptCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligsrcliquid(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligsrcliquidCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmountInfo(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmountInfoCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuContractTermsChanges(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuContractTermsChangesCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAllArrears(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAllArrearsCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromAccountAmend(String columns, String accSerialNum, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromAccountAmendCursor(String columns, String accSerialNum, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromPayment(String columns, String accSerialNum, String memberCode, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromPaymentCursor(String columns, String accSerialNum, String memberCode, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromCollateral(String columns, String accSerialNum, String memberCode, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromCollateralCursor(String columns, String accSerialNum, String memberCode, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromGuarantor(String columns, String accSerialNum, String memberCode, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromGuarantorCursor(String columns, String accSerialNum, String memberCode, String fid);
List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromBankGuarantee(String columns, String accSerialNum, String memberCode, String fid);
Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromBankGuaranteeCursor(String columns, String accSerialNum, String memberCode, String fid);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuUid(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuUidCursor(String columns, String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuUidWithoutRealMemberCode(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuUidWithoutRealMemberCodeCursor(String columns, String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuApplication(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuApplicationCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromRuApplication(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuObligparttake(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuObligparttakeCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromRuObligparttake(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuBankruptcy(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuBankruptcyCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromRuBankruptcyWithBlocks(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuSettled(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuSettledCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromRuSettled(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuOtherlegal(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuOtherlegalCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromRuOtherlegal(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuCapability(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuCapabilityCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromRuCapability(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuDebtBurdenInfo(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuDebtBurdenInfoCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromRuDebtBurdenInfo(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromAccount(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromAccountCursor(String columns, String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromInformation(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromInformationCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromInformation(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromBankruptcy(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromBankruptcyCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromBankruptcy(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromConsumerBankruptcy(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromConsumerBankruptcyCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromConsumerBankruptcy(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromLegal(String columns, String fid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromLegalCursor(String columns, String fid, String memberCode);
Long countAllByFidAndMemberCodeFromLegal(String fid, String memberCode);
List<LinkedHashMap<String, Object>> findAllByFidAndParentSerialNumFromRuCollateralBlocks(String columns, String fid, String parentSerialNum);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndParentSerialNumFromRuCollateralBlocksCursor(String columns, String fid, String parentSerialNum);
List<LinkedHashMap<String, Object>> findAllByFidAndParentSerialNumFromRuBankruptcyBlocks(String columns, String fid, String parentSerialNum);
Cursor<LinkedHashMap<String, Object>> findAllByFidAndParentSerialNumFromRuBankruptcyBlocksCursor(String columns, String fid, String parentSerialNum);
List<LinkedHashMap<String, Object>> countAllRuUidChildTablesByAcctNum(String acctNum, String memberCode);
List<LinkedHashMap<String, Object>> countAllRuUidChildTablesByFid(String fid, String memberCode);
List<LinkedHashMap<String, Object>> countAllRuUidChildTablesByFidWithoutRealMemberCode(String fid, String memberCode);
List<LinkedHashMap<String, Object>> countAllRuUidChildTablesByUuid(String uuid, String memberCode);
List<LinkedHashMap<String, Object>> countAllAccountChildTablesByAcctNum(String acctNum, String memberCode);
List<LinkedHashMap<String, Object>> countAllAccountChildTablesByFid(String fid, String memberCode);
List<LinkedHashMap<String, Object>> countAllAccountChildTablesBySerialNum(String serialNum, String memberCode);
List<LinkedHashMap<String, Object>> countAllAccountChildTablesByUuid(String uuid, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuTrade(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAccountAmt(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAcquirerIndivid(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAcquirerLegal(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAllArrears(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAmendment(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAmountInfo(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuArrear(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuBankruptcyBlocks(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCoborrower(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollateral(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollateralBlocks(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollatInsured(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollatRepay(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuContractTermsChanges(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuDueArrear(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuFundDate(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuGuaranteeRepay(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuGuarantor(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuIndepGuarantor(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuLegalRecord(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuMonthAverPaymt(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligAccount(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligsRcBankrupt(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligsRcLiquid(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligTermination(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuOverallval(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPastDueArrear(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPaymtCondition(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPaymt(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuServiceCo(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSourceNonMonetOblig(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSubjectNonMonetOblig(Set<Integer> fids);
Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSubmitHold(Set<Integer> fids);
}

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

@ -3,10 +3,8 @@ 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.UUID;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.commons.lang3.mutable.MutableLong;
@ -21,8 +19,7 @@ import ru.nbch.indicsearchservice.dto.response.AddSearchJobResponseDto;
import ru.nbch.indicsearchservice.dto.response.JobStatusResponseDto;
import ru.nbch.indicsearchservice.exporter.ExcelExporter;
import ru.nbch.indicsearchservice.exporter.JsonExporter;
import ru.nbch.indicsearchservice.loader.TableLoader;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.loader.FirstLevelTableLoader;
@Service
public class IndicSearchService {
@ -30,20 +27,17 @@ public class IndicSearchService {
private static final boolean IS_EXPORT_AS_EXCEL = false;
private final List<TableLoader> tableLoaders;
private final List<FirstLevelTableLoader> tableLoaders;
private final List<FileAggregator> fileAggregators;
private final IndicSearchUtils indicSearchUtils;
private final ExcelExporter excelExporter;
private final JsonExporter jsonExporter;
public IndicSearchService(List<TableLoader> tableLoaders,
public IndicSearchService(List<FirstLevelTableLoader> tableLoaders,
List<FileAggregator> fileAggregators,
IndicSearchUtils indicSearchUtils,
ExcelExporter excelExporter,
JsonExporter jsonExporter) {
this.tableLoaders = tableLoaders;
this.fileAggregators = fileAggregators;
this.indicSearchUtils = indicSearchUtils;
this.excelExporter = excelExporter;
this.jsonExporter = jsonExporter;
}
@ -57,26 +51,15 @@ public class IndicSearchService {
log.info("First step started. Getting data from database and filling csv files");
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(
Map<String, Path> tableFileMap = new ConcurrentHashMap<>();
tableLoaders.parallelStream().forEach(tl -> tl.searchBy(
taskId,
request.getDataType(),
request.getSearchParameter(),
request.getSearchValue()
);
Map<String, Path> tableFileMap = new ConcurrentHashMap<>();
suitableTableLoaders.parallelStream().forEach(tl -> {
String tableName = tl.getTableName();
Path tableFile = tl.searchByFid(foundFids, taskId);
tableFileMap.put(tableName, tableFile);
});
request.getSearchValue(),
request.getMemberCode().substring(0, 6),
tableFileMap
));
sw.stop();
log.info(sw.prettyPrint());
@ -86,13 +69,17 @@ public class IndicSearchService {
log.info("Second step started. Aggregating table files into one.");
sw.start();
FileAggregator fileAggregator = fileAggregators.stream()
.filter(fa -> fa.isSuitableForDataTypeAndSearchParameter(request.getDataType(), request.getSearchParameter()))
.findFirst()
.orElseThrow(() -> new RuntimeException("There is no suitable file aggregator for data type " + request.getDataType() + " and search parameter " + request.getSearchParameter()));
MutableLong rowCounter = new MutableLong();
Path aggregatedFile = fileAggregator.aggregateFiles(tableFileMap, request.getMemberCode().substring(0, 6), rowCounter, taskId);
Path aggregatedFile = fileAggregators.stream().map(fa -> fa.aggregateFiles(
taskId,
request.getDataType(),
request.getSearchParameter(),
request.getSearchValue(),
request.getMemberCode().substring(0, 6),
tableFileMap,
rowCounter))
.findFirst()
.orElse(null);
sw.stop();
log.info(sw.prettyPrint());

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

@ -5,17 +5,13 @@ import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.function.Function;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
@Component
public class IndicSearchUtils {
@ -25,15 +21,20 @@ public class IndicSearchUtils {
this.settings = settings;
}
public Path writeRowsToFile(String tableName,
Set<Integer> fids,
Function<Set<Integer>, Cursor<LinkedHashMap<String, Object>>> mapperFunc,
UUID taskId) {
public Path writeRowsToFile(UUID taskId,
String tableName,
Cursor<LinkedHashMap<String, Object>> databaseCursor) {
return writeRowsToFile(taskId, tableName, databaseCursor, null);
}
public Path writeRowsToFile(UUID taskId,
String tableName,
Cursor<LinkedHashMap<String, Object>> databaseCursor,
Set<Integer> foundFids) {
Path resultFile = settings.getStorageDirectory().toPath().resolve(tableName + "_" + taskId + ".csv");
try (BufferedWriter writer = Files.newBufferedWriter(resultFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND);
Cursor<LinkedHashMap<String, Object>> cursor = mapperFunc.apply(fids)) {
for (LinkedHashMap<String, Object> row : cursor) {
try (BufferedWriter writer = Files.newBufferedWriter(resultFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
for (LinkedHashMap<String, Object> row : databaseCursor) {
StringBuilder sb = new StringBuilder();
sb.append(tableName).append("%%%");
@ -44,6 +45,10 @@ public class IndicSearchUtils {
sb.append(columnName.toUpperCase()).append("%%%");
if (columnValue != null) {
if (foundFids != null && columnName.equals("FID")) {
foundFids.add(Integer.parseInt(columnValue.toString()));
}
sb.append(columnValue).append("%%%");
} else {
sb.append("%%%");
@ -60,24 +65,4 @@ public class IndicSearchUtils {
return resultFile;
}
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;
}
}

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

File diff suppressed because it is too large Load diff