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

v3 version added

Browse source
This commit is contained in:
Ivan Nikolaev-Axenov 2026-05-21 18:11:59 +03:00
parent ffca0f853c
commit 8a05605558
54 changed files with 1047 additions and 737 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -0,0 +1,21 @@
package ru.nbch.indicsearchservice.aggregator;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.apache.commons.lang3.mutable.MutableLong;
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);
}

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

@ -0,0 +1,217 @@
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.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.mutable.MutableLong;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.util.MovableBufferedReader;
@Component
public class FileAggregatorCommon {
private static final List<String> RU_UID_CHILD_TABLES = List.of(
"RU_TRADE",
"RU_ACCOUNT_AMT",
"RU_COBORROWER",
"RU_PAYMT_CONDITION",
"RU_OVERALLVAL",
"RU_AMENDMENT",
"RU_FUNDDATE",
"RU_ARREAR",
"RU_DUEARREAR",
"RU_PASTDUEARREAR",
"RU_PAYMT",
"RU_MONTHAVERPAYMT",
"RU_SOURCENONMONETOBLIG",
"RU_SUBJECTNONMONETOBLIG",
"RU_COLLATERAL",
"RU_GUARANTOR",
"RU_INDEPGUARANTOR",
"RU_COLLATINSURED",
"RU_COLLATREPAY",
"RU_GUARANTEEREPAY",
"RU_OBLIGTERMINATION",
"RU_SUBMITHOLD",
"RU_ACQUIRERLEGAL",
"RU_ACQUIRERINDIVID",
"RU_SERVICECO",
"RU_OBLIGACCOUNT",
"RU_LEGALRECORD",
"RU_OBLIGSRCBANKRUPT",
"RU_OBLIGSRCLIQUID",
"RU_AMOUNT_INFO",
"RU_CONTRACT_TERMS_CHANGES",
"RU_ALL_ARREARS"
);
void aggregateRuUidFiles(Path aggregatedFile, Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter) {
try (BufferedReader ruUidFileReader = Files.newBufferedReader(tableFileMap.get("RU_UID"));
BufferedWriter writer = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
Map<String, MovableBufferedReader> childTablesReadersMap = new LinkedHashMap<>();
for (String tableName : RU_UID_CHILD_TABLES) {
if (!tableFileMap.containsKey(tableName)) {
continue;
}
MovableBufferedReader childTablesReader = new MovableBufferedReader(Files.newBufferedReader(tableFileMap.get(tableName)));
if (childTablesReader.getCurrentLine() != null) {
childTablesReadersMap.put(tableName, childTablesReader);
}
}
String ruUidLine;
while ((ruUidLine = ruUidFileReader.readLine()) != null) {
List<String> lineList = Arrays.asList(ruUidLine.split(";"));
int memberCodeIndex = lineList.indexOf("MEMBER_CODE");
if (memberCodeIndex != -1) {
if (!lineList.get(memberCodeIndex + 1).startsWith(memberCode)) {
continue;
}
}
writer.write(ruUidLine);
writer.newLine();
rowCounter.increment();
Long ruUidSerialNum = Long.parseLong(ruUidLine.split(";")[2]);
for (Map.Entry<String, MovableBufferedReader> entry : childTablesReadersMap.entrySet()) {
String childTableName = entry.getKey();
MovableBufferedReader childReader = entry.getValue();
String childLine = childReader.getCurrentLine();
if (childLine == null) {
continue;
}
Long childAccSerialNum = Long.parseLong(childLine.split(";")[3]);
if (ruUidSerialNum > childAccSerialNum) {
while ((childLine = childReader.nextLine()) != null) {
childAccSerialNum = Long.parseLong(childLine.split(";")[3]);
if (childAccSerialNum.equals(ruUidSerialNum)) {
writer.write(childLine);
writer.newLine();
rowCounter.increment();
if (childTableName.equals("RU_COLLATERAL")) {
aggregateBlocksTableFile(childTableName, aggregatedFile, tableFileMap, memberCode, rowCounter);
}
}
if (childAccSerialNum > ruUidSerialNum) {
break;
}
}
} else if (ruUidSerialNum.equals(childAccSerialNum)) {
writer.write(childLine);
writer.newLine();
rowCounter.increment();
if (childTableName.equals("RU_COLLATERAL")) {
aggregateBlocksTableFile(childTableName, aggregatedFile, tableFileMap, memberCode, rowCounter);
}
while ((childLine = childReader.nextLine()) != null) {
childAccSerialNum = Long.parseLong(childLine.split(";")[3]);
if (childAccSerialNum.equals(ruUidSerialNum)) {
writer.write(childLine);
writer.newLine();
rowCounter.increment();
if (childTableName.equals("RU_COLLATERAL")) {
aggregateBlocksTableFile(childTableName, aggregatedFile, tableFileMap, memberCode, rowCounter);
}
}
if (childAccSerialNum > ruUidSerialNum) {
break;
}
}
}
}
}
for (MovableBufferedReader br : childTablesReadersMap.values()) {
br.getReader().close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
void aggregateBlocksTableFile(String parentTableName, Path aggregatedFile, Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter) {
try (BufferedReader parentFileReader = Files.newBufferedReader(tableFileMap.get(parentTableName));
MovableBufferedReader blocksFileReader = new MovableBufferedReader(Files.newBufferedReader(tableFileMap.get(parentTableName + "_BLOCKS")));
BufferedWriter writer = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
String parentLine;
while ((parentLine = parentFileReader.readLine()) != null) {
List<String> lineList = Arrays.asList(parentLine.split(";"));
int memberCodeIndex = lineList.indexOf("MEMBER_CODE");
if (memberCodeIndex != -1) {
if (!lineList.get(memberCodeIndex + 1).startsWith(memberCode)) {
continue;
}
}
writer.write(parentLine);
writer.newLine();
rowCounter.increment();
Long parentSerialNum = Long.parseLong(parentLine.split(";")[2]);
String blocksLine = blocksFileReader.getCurrentLine();
if (blocksLine == null) {
continue;
}
Long blocksParentSerialNum = Long.parseLong(blocksLine.split(";")[4]);
if (parentSerialNum > blocksParentSerialNum) {
while ((blocksLine = blocksFileReader.nextLine()) != null) {
blocksParentSerialNum = Long.parseLong(blocksLine.split(";")[4]);
if (blocksParentSerialNum.equals(parentSerialNum)) {
writer.write(blocksLine);
writer.newLine();
rowCounter.increment();
}
if (blocksParentSerialNum > parentSerialNum) {
break;
}
}
} else if (parentSerialNum.equals(blocksParentSerialNum)) {
writer.write(blocksLine);
writer.newLine();
rowCounter.increment();
while ((blocksLine = blocksFileReader.nextLine()) != null) {
blocksParentSerialNum = Long.parseLong(blocksLine.split(";")[4]);
if (blocksParentSerialNum.equals(parentSerialNum)) {
writer.write(blocksLine);
writer.newLine();
rowCounter.increment();
}
if (blocksParentSerialNum > parentSerialNum) {
break;
}
}
}
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

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

@ -0,0 +1,97 @@
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.Arrays;
import java.util.List;
import java.util.Map;
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;
@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");
for (String tableName : getRequiredTables()) {
if (tableName.equals("RU_UID")) {
fileAggregatorCommon.aggregateRuUidFiles(aggregatedFile, tableFileMap, memberCode, rowCounter);
} else if (tableName.equals("RU_BANKRUPTCY")) {
fileAggregatorCommon.aggregateBlocksTableFile(tableName, aggregatedFile, tableFileMap, memberCode, rowCounter);
} else {
try (BufferedReader reader = Files.newBufferedReader(tableFileMap.get(tableName));
BufferedWriter writer = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
String line;
while ((line = reader.readLine()) != null) {
List<String> lineList = Arrays.asList(line.split(";"));
int memberCodeIndex = lineList.indexOf("MEMBER_CODE");
if (memberCodeIndex != -1) {
if (!lineList.get(memberCodeIndex + 1).startsWith(memberCode)) {
continue;
}
}
writer.write(line);
writer.newLine();
rowCounter.increment();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
try (BufferedWriter writer = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
writer.write("EOF");
} catch (IOException e) {
throw new RuntimeException(e);
}
return aggregatedFile;
}
}

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

@ -11,19 +11,19 @@ import ru.nbch.indicsearchservice.model.TableData;
@Component
public class RuUidSecondLevelTableFilter implements SecondLevelTableFilter {
private static final Set<String> SUPPORTED_TABLE_NAMES = Set.of(
"RU_TRADE",
"RU_ACCOUNT_AMT",
"RU_COBORROWER",
"RU_PAYMT_CONDITION",
"RU_OVERALLVAL",
"RU_AMENDMENT",
"RU_FUNDDATE",
"RU_ARREAR",
"RU_COBORROWER",
"RU_DUEARREAR",
"RU_FUNDDATE",
"RU_MONTHAVERPAYMT",
"RU_OVERALLVAL",
"RU_PASTDUEARREAR",
"RU_PAYMT",
"RU_MONTHAVERPAYMT",
"RU_SOURCENONMONETOBLIG"
"RU_PAYMT_CONDITION",
"RU_SOURCENONMONETOBLIG",
"RU_TRADE"
);
@Override

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuAccountAmtTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuAcquirerIndividTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuAcquirerLegalTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuAllArrearsTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuAmendmentTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuAmountInfoTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuApplicationTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuArrearTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuBankruptcyBlocksTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuBankruptcyTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuCapabilityTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuCoborrowerTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuCollatInsuredTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuCollatRepayTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuCollateralBlocksTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuCollateralTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuContractTermsChangesTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuDebtBurdenInfoTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuDueArrearTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuFundDateTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuGuaranteeRepayTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuGuarantorTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuIndepGuarantorTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuLegalRecordTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuMonthAverPaymtTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuObligAccountTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuObligPartTakeTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuObligTerminationTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuObligsRcBankruptTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuObligsRcLiquidTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuOtherLegalTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -20,6 +20,7 @@ public class RuOverallvalTableLoader implements TableLoader {
IndicSearchUtils indicSearchUtils) {
this.mapperHolder = mapperHolder;
this.indicSearchUtils = indicSearchUtils;
}
@Override
@ -38,15 +39,8 @@ public class RuOverallvalTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuPastDueArrearTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuPaymtConditionTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuPaymtTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuServiceCoTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuSettledTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuSourceNonMonetObligTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuSubjectNonMonetObligTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuSubmitHoldTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuTradeTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fidSet), taskId);
}
}

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

@ -1,11 +1,11 @@
package ru.nbch.indicsearchservice.loader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
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;
@ -38,15 +38,8 @@ public class RuUidTableLoader implements TableLoader {
}
@Override
public List<TableData> searchByFid(Set<Integer> fids) {
List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuUid(fids);
List<TableData> resultTableData = new ArrayList<>();
for (LinkedHashMap<String, Object> row : foundTableRows) {
TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
resultTableData.add(parsedTableData);
}
return resultTableData;
@Transactional(readOnly = true)
public Path searchByFid(Set<Integer> fids, UUID taskId) {
return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuUid(fidSet), taskId);
}
}

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

@ -1,8 +1,9 @@
package ru.nbch.indicsearchservice.loader;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import ru.nbch.indicsearchservice.model.TableData;
import java.util.UUID;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
@ -15,5 +16,5 @@ public interface TableLoader {
return getSuitableDataTypes().contains(dataType) && getSuitableSearchParameters().contains(searchParameter);
}
List<TableData> searchByFid(Set<Integer> fids);
Path searchByFid(Set<Integer> fids, UUID taskId);
}

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

@ -11,48 +11,48 @@ import ru.nbch.indicsearchservice.repository.MyBatisRepository;
public interface IndicMapper extends MyBatisRepository {
List<LinkedHashMap<String, String>> getTableColumnsByTableNames(List<String> tables);
List<LinkedHashMap<String, Object>> findAllByFidFromRuUid(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuTrade(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuApplication(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAccountAmt(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerIndivid(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerLegal(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAllArrears(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAmendment(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuAmountInfo(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuArrear(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcy(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcyBlocks(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCapability(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCoborrower(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCollateral(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCollateralBlocks(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCollatInsured(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuCollatRepay(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuContractTermsChanges(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuDebtBurdenInfo(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuDueArrear(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuFundDate(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuGuaranteeRepay(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuGuarantor(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuIndepGuarantor(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuLegalRecord(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuMonthAverPaymt(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligAccount(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligPartTake(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcBankrupt(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcLiquid(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuObligTermination(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuOtherLegal(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuOverallval(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuPastDueArrear(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuPaymtCondition(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuPaymt(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuServiceCo(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuSettled(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuSourceNonMonetOblig(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuSubjectNonMonetOblig(Set<Integer> fids);
List<LinkedHashMap<String, Object>> findAllByFidFromRuSubmitHold(Set<Integer> fids);
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);
List<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUid(String columns, String acctNum, String memberCode);
Cursor<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUidCursor(String columns, String acctNum, String memberCode);

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

@ -7,20 +7,19 @@ 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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.StopWatch;
import ru.nbch.indicsearchservice.aggregator.FileAggregator;
import ru.nbch.indicsearchservice.dto.request.AddSearchJobRequestDto;
import ru.nbch.indicsearchservice.dto.response.AddSearchJobResponseDto;
import ru.nbch.indicsearchservice.dto.response.JobStatusResponseDto;
import ru.nbch.indicsearchservice.filter.firstlevel.DefaultFirstLevelTableFilter;
import ru.nbch.indicsearchservice.filter.secondlevel.SecondLevelTableFilter;
import ru.nbch.indicsearchservice.filter.thirdlevel.ThirdLevelTableFilter;
import ru.nbch.indicsearchservice.loader.TableLoader;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.util.ExcelWriter;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import tools.jackson.databind.json.JsonMapper;
@ -32,32 +31,31 @@ public class IndicSearchService {
private static final boolean IS_EXPORT_AS_EXCEL = true;
private final List<TableLoader> tableLoaders;
private final DefaultFirstLevelTableFilter firstLevelTableFilter;
private final List<SecondLevelTableFilter> secondLevelTableFilters;
private final List<ThirdLevelTableFilter> thirdLevelTableFilters;
private final List<FileAggregator> fileAggregators;
private final IndicSearchUtils indicSearchUtils;
private final ExcelWriter excelWriter;
private final JsonMapper jsonMapper;
public IndicSearchService(List<TableLoader> tableLoaders,
DefaultFirstLevelTableFilter firstLevelTableFilter,
List<SecondLevelTableFilter> secondLevelTableFilters,
List<ThirdLevelTableFilter> thirdLevelTableFilters,
List<FileAggregator> fileAggregators,
IndicSearchUtils indicSearchUtils,
ExcelWriter excelWriter,
JsonMapper jsonMapper) {
this.tableLoaders = tableLoaders;
this.firstLevelTableFilter = firstLevelTableFilter;
this.secondLevelTableFilters = secondLevelTableFilters;
this.thirdLevelTableFilters = thirdLevelTableFilters;
this.fileAggregators = fileAggregators;
this.indicSearchUtils = indicSearchUtils;
this.excelWriter = excelWriter;
this.jsonMapper = jsonMapper;
}
public AddSearchJobResponseDto addSearchJob(AddSearchJobRequestDto request) {
UUID taskId = UUID.randomUUID();
StopWatch sw = new StopWatch();
// Первый этап. Получение данных из БД и заполнение файлов
log.info("First step started. Getting data from database and filling csv files");
sw.start();
List<TableLoader> suitableTableLoaders = new ArrayList<>();
@ -73,28 +71,64 @@ public class IndicSearchService {
request.getSearchValue()
);
Map<String, List<TableData>> tableDataMapByFid = new ConcurrentHashMap<>();
suitableTableLoaders.parallelStream().forEach(tl -> tableDataMapByFid.put(tl.getTableName(), tl.searchByFid(foundFids)));
// for (TableLoader tableLoader : suitableTableLoaders) {
// tableDataMapByFid.put(tableLoader.getTableName(), tableLoader.searchByFid(foundFids));
// }
Map<String, Path> tableFileMap = new ConcurrentHashMap<>();
suitableTableLoaders.parallelStream().forEach(tl -> {
String tableName = tl.getTableName();
Path tableFile = tl.searchByFid(foundFids, taskId);
List<TableData> result = firstLevelTableFilter.applyFilter(tableDataMapByFid, request.getMemberCode());
secondLevelTableFilters.forEach(f -> f.applyFilter(result, tableDataMapByFid));
thirdLevelTableFilters.forEach(f -> f.applyFilter(result, tableDataMapByFid));
tableFileMap.put(tableName, tableFile);
});
sw.stop();
log.info(sw.prettyPrint());
sw = new StopWatch();
// Второй этап. Объединение файлов в один
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);
sw.stop();
log.info(sw.prettyPrint());
sw = new StopWatch();
for (Path tableFilePath : tableFileMap.values()) {
try {
Files.deleteIfExists(tableFilePath);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
// Третий этап. Экспорт агрегированного файла в JSON или XLSX
log.info("Third step started. Exporting aggregated file into JSON/XLSX.");
sw.start();
if (!IS_EXPORT_AS_EXCEL) {
// try {
// Files.write(Path.of("1.json"), jsonMapper.writeValueAsBytes(result));
// } catch (IOException e) {
// throw new RuntimeException(e);
// }
} else {
excelWriter.writeExcelFile(aggregatedFile, taskId);
}
sw.stop();
log.info(sw.prettyPrint());
if (!IS_EXPORT_AS_EXCEL) {
try {
Files.write(Path.of("1.json"), jsonMapper.writeValueAsBytes(result));
} catch (IOException e) {
throw new RuntimeException(e);
}
} else {
excelWriter.writeExcelFile(result);
}
// try {
// Files.deleteIfExists(aggregatedFile);
// } catch (IOException e) {
// throw new RuntimeException(e);
// }
return null;
}

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

@ -1,15 +1,21 @@
package ru.nbch.indicsearchservice.util;
import jakarta.annotation.Nullable;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.apache.commons.lang3.mutable.MutableInt;
import java.util.Set;
import java.util.UUID;
import org.apache.commons.lang3.mutable.MutableLong;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
@ -23,39 +29,62 @@ import org.apache.poi.xssf.usermodel.XSSFFont;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import ru.nbch.indicsearchservice.model.TableData;
import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
@Component
public class ExcelWriter {
private static final Logger log = LoggerFactory.getLogger(ExcelWriter.class);
private static final Long EXCEL_SHEET_MAX_SIZE = 1_048_575L;
public void writeExcelFile(List<TableData> tableDataList) {
Map<String, List<TableData>> tableDataGroupedByTables = tableDataList.stream()
.collect(Collectors.groupingBy(TableData::getTableName));
private static final Set<String> FIRST_LEVEL_TABLES = Set.of(
"RU_UID",
"RU_APPLICATION",
"RU_OBLIGPARTTAKE",
"RU_BANKRUPTCY",
"RU_SETTLED",
"RU_OTHERLEGAL",
"RU_CAPABILITY",
"RU_DEBT_BURDEN_INFO"
);
Path excelFile = Path.of("2.xlsx");
private final ApplicationSettings settings;
try (SXSSFWorkbook workbook = new SXSSFWorkbook();
OutputStream os = Files.newOutputStream(excelFile)) {
public ExcelWriter(ApplicationSettings settings) {
this.settings = settings;
}
public void writeExcelFile(Path aggregatedFile, UUID taskId) {
Path excelFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".xlsx");
try (OutputStream os = Files.newOutputStream(excelFile);
BufferedReader aggregatedFileReader = Files.newBufferedReader(aggregatedFile);
SXSSFWorkbook workbook = new SXSSFWorkbook()) {
CellStyle headerCellStyle = createHeaderCellStyle(workbook);
CellStyle cellStyle = createCellStyle(workbook);
for (Map.Entry<String, List<TableData>> entry : tableDataGroupedByTables.entrySet()) {
String tableName = entry.getKey();
List<TableData> tableRows = entry.getValue();
Iterator<String> iterator = aggregatedFileReader.lines().iterator();
Sheet tableSheet = createSheet(workbook, tableName.toUpperCase());
MutableInt currentRow = new MutableInt(0);
MutableLong sheetRowCounter = new MutableLong(0L);
MutableLong sheetTableCounter = new MutableLong(1L);
for (TableData tableRow : tableRows) {
writeDataSheetIntoSheetRow(
tableRow,
tableSheet,
currentRow,
headerCellStyle,
cellStyle
);
boolean isFirst = true;
String lastTableName = null;
List<String> rows = new ArrayList<>();
while (iterator.hasNext()) {
String line = iterator.next();
if (!isFirst && (FIRST_LEVEL_TABLES.contains(line.split(";")[0]) || line.equals("EOF"))) {
lastTableName = rows.getFirst().split(";")[0];
writeToExcel(workbook, rows, sheetRowCounter, sheetTableCounter, headerCellStyle, cellStyle);
if (lastTableName != null && !lastTableName.equals(line.split(";")[0])) {
sheetRowCounter.setValue(0L);
sheetTableCounter.setValue(1L);
}
rows.clear();
}
rows.add(line);
isFirst = false;
}
workbook.write(os);
@ -64,6 +93,61 @@ public class ExcelWriter {
}
}
private void writeToExcel(Workbook workbook,
List<String> rows,
MutableLong sheetRowCounter,
MutableLong sheetTableCounter,
CellStyle headerCellStyle,
CellStyle cellStyle) {
if (rows == null || rows.isEmpty()) {
return;
}
String parentTableName = rows.getFirst().split(";")[0];
Sheet tableSheet;
if (sheetRowCounter.longValue() + (rows.size() * 2L) >= EXCEL_SHEET_MAX_SIZE) {
tableSheet = createSheet(workbook, parentTableName.toUpperCase() + "_" + sheetTableCounter.incrementAndGet());
sheetRowCounter.setValue(0L);
} else {
tableSheet = createSheet(workbook, parentTableName.toUpperCase() + "_" + sheetTableCounter.longValue());
}
for (String row : rows) {
List<String> rowList = Arrays.asList(row.split(";", -1));
String tableName = rowList.getFirst();
List<String> rowSublist = rowList.subList(5, rowList.size());
Map<String, String> rowValues = new HashMap<>();
for (int i = 0; i + 1 <= rowSublist.size(); i = i + 2) {
rowValues.put(rowSublist.get(i), rowSublist.get(i + 1));
}
createHeaderRow(
tableName,
tableSheet,
sheetRowCounter,
headerCellStyle
);
for (Map.Entry<String, String> entry : rowValues.entrySet()) {
String columnName = entry.getKey();
String columnValue = entry.getValue();
writeFieldDataIntoSheetRow(
columnName,
columnName,
columnValue,
tableSheet,
sheetRowCounter,
cellStyle
);
}
sheetRowCounter.increment();
}
}
private CellStyle createHeaderCellStyle(Workbook workbook) {
CellStyle headerCellStyle = workbook.createCellStyle();
headerCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
@ -94,17 +178,23 @@ public class ExcelWriter {
}
private Sheet createSheet(Workbook workbook, String sheetName) {
Sheet sheet = workbook.createSheet(sheetName);
sheet.setColumnWidth(0, 25 * 256);
sheet.setColumnWidth(1, 115 * 256);
sheet.setColumnWidth(2, 38 * 256);
Sheet foundSheet = workbook.getSheet(sheetName);
return sheet;
if (foundSheet == null) {
Sheet sheet = workbook.createSheet(sheetName);
sheet.setColumnWidth(0, 25 * 256);
sheet.setColumnWidth(1, 115 * 256);
sheet.setColumnWidth(2, 38 * 256);
return sheet;
}
return foundSheet;
}
private void createHeaderRow(String localizedTableName,
Sheet sheet,
MutableInt currentRow,
MutableLong currentRow,
CellStyle headerCellStyle) {
Row headerRow = sheet.createRow(currentRow.intValue());
headerRow.setHeightInPoints(15);
@ -117,49 +207,11 @@ public class ExcelWriter {
currentRow.increment();
}
public void writeDataSheetIntoSheetRow(TableData tableData,
Sheet sheet,
MutableInt currentRow,
CellStyle headerCellStyle,
CellStyle cellStyle) {
createHeaderRow(
tableData.getTableName(),
sheet,
currentRow,
headerCellStyle
);
for (TableData.FieldData fieldData : tableData.getFieldData()) {
writeFieldDataIntoSheetRow(
fieldData.columnName(),
fieldData.columnName(),
fieldData.columnValue(),
sheet,
currentRow,
cellStyle
);
}
currentRow.increment();
if (!tableData.getRelatedTableData().isEmpty()) {
for (TableData relatedTableData : tableData.getRelatedTableData()) {
writeDataSheetIntoSheetRow(
relatedTableData,
sheet,
currentRow,
headerCellStyle,
cellStyle
);
}
}
}
private void writeFieldDataIntoSheetRow(String fieldKey,
String localizedFieldKey,
@Nullable Object fieldValue,
Sheet sheet,
MutableInt currentRow,
MutableLong currentRow,
CellStyle cellStyle) {
Row dataRow = sheet.createRow(currentRow.intValue());
dataRow.setHeightInPoints(15);

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

@ -1,21 +1,97 @@
package ru.nbch.indicsearchservice.util;
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.sql.Date;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
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.TableData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
@Component
public class IndicSearchUtils {
private final ApplicationSettings settings;
public IndicSearchUtils(ApplicationSettings settings) {
this.settings = settings;
}
public Path writeRowsToFile(String tableName,
Set<Integer> fids,
Function<Set<Integer>, Cursor<LinkedHashMap<String, Object>>> mapperFunc,
UUID taskId) {
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) {
StringBuilder sb = new StringBuilder();
sb.append(tableName).append(";");
if (row.containsKey("FID") && row.get("FID") != null) {
sb.append(row.get("FID").toString()).append(";");
} else {
sb.append(";");
}
if (row.containsKey("SERIAL_NUM") && row.get("SERIAL_NUM") != null) {
sb.append(row.get("SERIAL_NUM").toString()).append(";");
} else {
sb.append(";");
}
if (row.containsKey("ACC_SERIAL_NUM") && row.get("ACC_SERIAL_NUM") != null) {
sb.append(row.get("ACC_SERIAL_NUM").toString()).append(";");
} else {
sb.append(";");
}
if (row.containsKey("PARENT_SERIAL_NUM") && row.get("PARENT_SERIAL_NUM") != null) {
sb.append(row.get("PARENT_SERIAL_NUM").toString()).append(";");
} else {
sb.append(";");
}
for (Map.Entry<String, Object> entry : row.entrySet()) {
String columnName = entry.getKey();
Object columnValue = entry.getValue();
sb.append(columnName.toUpperCase()).append(";");
if (columnValue != null) {
sb.append(columnValue).append(";");
} else {
sb.append(";");
}
}
sb.deleteCharAt(sb.length() - 1);
writer.write(sb.toString());
writer.newLine();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
return resultFile;
}
public Set<Integer> getFidsBasedOnDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter, String searchValue) {
Set<Integer> fids = new HashSet<>();

61
src/main/java/ru/nbch/indicsearchservice/util/MovableBufferedReader.java Normal file
View file

@ -0,0 +1,61 @@
package ru.nbch.indicsearchservice.util;
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.util.Objects;
public class MovableBufferedReader implements Closeable {
private final BufferedReader reader;
private String currentLine;
public MovableBufferedReader(BufferedReader reader) {
this.reader = reader;
try {
this.currentLine = reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public String nextLine() {
try {
this.currentLine = reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
return this.currentLine;
}
public BufferedReader getReader() {
return reader;
}
public String getCurrentLine() {
return currentLine;
}
@Override
public boolean equals(Object o) {
if (o == null || getClass() != o.getClass()) return false;
MovableBufferedReader that = (MovableBufferedReader) o;
return Objects.equals(reader, that.reader) && Objects.equals(currentLine, that.currentLine);
}
@Override
public int hashCode() {
return Objects.hash(reader, currentLine);
}
@Override
public String toString() {
return "MovableBufferedReader{" +
"currentLine='" + currentLine + '\'' +
'}';
}
@Override
public void close() throws IOException {
this.reader.close();
}
}

4
src/main/resources/application.properties
View file

@ -12,4 +12,6 @@ app.data-source.validation-timeout=5000
app.data-source.idle-timeout=600000
app.data-source.max-pool-size=10
app.data-source.max-lifetime=1800000
app.data-source.keep-alive-time=120000
app.data-source.keep-alive-time=120000
app.storage-directory=C:\\Users\\inikolaev\\Desktop\\1

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

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