csv separator changed to %%%

src/main/java/ru/nbch/indicsearchservice/aggregator/FileAggregator.java

@@ -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);
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/FileAggregatorCommon.java

@@ -0,0 +1,252 @@
+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.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+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(BufferedWriter aggregatedFileWriter, Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter) {
+        try (BufferedReader ruUidFileReader = Files.newBufferedReader(tableFileMap.get("RU_UID"))) {
+            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("%%%"));
+                Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(lineList, "MEMBER_CODE");
+
+                if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                    continue;
+                }
+
+                aggregatedFileWriter.write(ruUidLine);
+                aggregatedFileWriter.newLine();
+                rowCounter.increment();
+
+                Optional<String> foundRuUidSerialNum = IndicSearchCommon.getRowValue(lineList, "SERIAL_NUM");
+                if (foundRuUidSerialNum.isEmpty()) {
+                    throw new RuntimeException("SERIAL_NUM was not found!");
+                }
+                Long ruUidSerialNum = Long.parseLong(foundRuUidSerialNum.get());
+
+                for (Map.Entry<String, MovableBufferedReader> entry : childTablesReadersMap.entrySet()) {
+                    String childTableName = entry.getKey();
+                    MovableBufferedReader childReader = entry.getValue();
+
+                    String childLine = childReader.getCurrentLine();
+                    if (childLine == null) {
+                        continue;
+                    }
+
+                    List<String> childLineList = Arrays.asList(childLine.split("%%%"));
+                    Optional<String> foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                    if (foundChildAccSerialNum.isEmpty()) {
+                        throw new RuntimeException("ACC_SERIAL_NUM was not found!");
+                    }
+                    Long childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                    if (ruUidSerialNum > childAccSerialNum) {
+                        while ((childLine = childReader.nextLine()) != null) {
+                            childLineList = Arrays.asList(childLine.split("%%%"));
+                            foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                            if (foundChildAccSerialNum.isEmpty()) {
+                                throw new RuntimeException("ACC_SERIAL_NUM was not found!");
+                            }
+                            childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                            if (childAccSerialNum.equals(ruUidSerialNum)) {
+                                aggregatedFileWriter.write(childLine);
+                                aggregatedFileWriter.newLine();
+                                rowCounter.increment();
+
+                                if (childTableName.equals("RU_COLLATERAL")) {
+                                    aggregateBlocksTableFile(childTableName, aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+                                }
+                            }
+
+                            if (childAccSerialNum > ruUidSerialNum) {
+                                break;
+                            }
+                        }
+                    } else if (ruUidSerialNum.equals(childAccSerialNum)) {
+                        aggregatedFileWriter.write(childLine);
+                        aggregatedFileWriter.newLine();
+                        rowCounter.increment();
+
+                        if (childTableName.equals("RU_COLLATERAL")) {
+                            aggregateBlocksTableFile(childTableName, aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+                        }
+
+                        while ((childLine = childReader.nextLine()) != null) {
+                            childLineList = Arrays.asList(childLine.split("%%%"));
+                            foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                            if (foundChildAccSerialNum.isEmpty()) {
+                                throw new RuntimeException("ACC_SERIAL_NUM was not found!");
+                            }
+                            childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                            if (childAccSerialNum.equals(ruUidSerialNum)) {
+                                aggregatedFileWriter.write(childLine);
+                                aggregatedFileWriter.newLine();
+                                rowCounter.increment();
+
+                                if (childTableName.equals("RU_COLLATERAL")) {
+                                    aggregateBlocksTableFile(childTableName, aggregatedFileWriter, 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, BufferedWriter aggregatedFileWriter, 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")))) {
+            String parentLine;
+            while ((parentLine = parentFileReader.readLine()) != null) {
+                List<String> parentLineList = Arrays.asList(parentLine.split("%%%"));
+                Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(parentLineList, "MEMBER_CODE");
+
+                if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                    continue;
+                }
+
+                aggregatedFileWriter.write(parentLine);
+                aggregatedFileWriter.newLine();
+                rowCounter.increment();
+
+                Optional<String> foundParentSerialNum = IndicSearchCommon.getRowValue(parentLineList, "SERIAL_NUM");
+                if (foundParentSerialNum.isEmpty()) {
+                    throw new RuntimeException("SERIAL_NUM was not found!");
+                }
+                Long parentSerialNum = Long.parseLong(foundParentSerialNum.get());
+
+                String blocksLine = blocksFileReader.getCurrentLine();
+                if (blocksLine == null) {
+                    continue;
+                }
+
+                List<String> childLineList = Arrays.asList(blocksLine.split("%%%"));
+                Optional<String> foundChildParentSerialNum = IndicSearchCommon.getRowValue(childLineList, "PARENT_SERIAL_NUM");
+                if (foundChildParentSerialNum.isEmpty()) {
+                    throw new RuntimeException("PARENT_SERIAL_NUM was not found!");
+                }
+                Long blocksParentSerialNum = Long.parseLong(foundChildParentSerialNum.get());
+
+                if (parentSerialNum > blocksParentSerialNum) {
+                    while ((blocksLine = blocksFileReader.nextLine()) != null) {
+                        childLineList = Arrays.asList(blocksLine.split("%%%"));
+                        foundChildParentSerialNum = IndicSearchCommon.getRowValue(childLineList, "PARENT_SERIAL_NUM");
+                        if (foundChildParentSerialNum.isEmpty()) {
+                            throw new RuntimeException("PARENT_SERIAL_NUM was not found!");
+                        }
+                        blocksParentSerialNum = Long.parseLong(foundChildParentSerialNum.get());
+
+                        if (blocksParentSerialNum.equals(parentSerialNum)) {
+                            aggregatedFileWriter.write(blocksLine);
+                            aggregatedFileWriter.newLine();
+                            rowCounter.increment();
+                        }
+
+                        if (blocksParentSerialNum > parentSerialNum) {
+                            break;
+                        }
+                    }
+                } else if (parentSerialNum.equals(blocksParentSerialNum)) {
+                    aggregatedFileWriter.write(blocksLine);
+                    aggregatedFileWriter.newLine();
+                    rowCounter.increment();
+
+                    while ((blocksLine = blocksFileReader.nextLine()) != null) {
+                        childLineList = Arrays.asList(blocksLine.split("%%%"));
+                        foundChildParentSerialNum = IndicSearchCommon.getRowValue(childLineList, "PARENT_SERIAL_NUM");
+                        if (foundChildParentSerialNum.isEmpty()) {
+                            throw new RuntimeException("PARENT_SERIAL_NUM was not found!");
+                        }
+                        blocksParentSerialNum = Long.parseLong(foundChildParentSerialNum.get());
+
+                        if (blocksParentSerialNum.equals(parentSerialNum)) {
+                            aggregatedFileWriter.write(blocksLine);
+                            aggregatedFileWriter.newLine();
+                            rowCounter.increment();
+                        }
+
+                        if (blocksParentSerialNum > parentSerialNum) {
+                            break;
+                        }
+                    }
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/GutdfFidFileAggregator.java

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

src/main/java/ru/nbch/indicsearchservice/config/ObjectMapperConfig.java

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

src/main/java/ru/nbch/indicsearchservice/exporter/ExcelExporter.java

@@ -0,0 +1,231 @@
+package ru.nbch.indicsearchservice.exporter;
+
+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.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.apache.poi.ss.usermodel.BorderStyle;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellStyle;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.VerticalAlignment;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.xssf.streaming.SXSSFWorkbook;
+import org.apache.poi.xssf.usermodel.XSSFFont;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+
+@Component
+public class ExcelExporter implements Exporter {
+    private static final Logger log = LoggerFactory.getLogger(ExcelExporter.class);
+    private static final Long EXCEL_SHEET_MAX_SIZE = 1_048_575L;
+
+    private final ApplicationSettings settings;
+
+    public ExcelExporter(ApplicationSettings settings) {
+        this.settings = settings;
+    }
+
+    public void writeExcelFile(Path aggregatedFile, UUID taskId, Long totalRows) {
+        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);
+
+            Iterator<String> iterator = aggregatedFileReader.lines().iterator();
+
+            MutableLong sheetRowCounter = new MutableLong(0L);
+            MutableLong sheetTableCounter = new MutableLong(1L);
+
+            long count = 0L;
+
+            boolean isFirst = true;
+            String lastTableName;
+            List<String> rows = new ArrayList<>();
+            while (iterator.hasNext()) {
+                String line = iterator.next();
+                List<String> lineList = Arrays.asList(line.split("%%%"));
+
+                log.info("Processing row: {} / {}", count++, totalRows);
+
+                if (!isFirst && (FIRST_LEVEL_TABLES.contains(lineList.getFirst()) || line.equals("EOF"))) {
+                    lastTableName = rows.getFirst().split("%%%")[0];
+                    writeToExcel(workbook, rows, sheetRowCounter, sheetTableCounter, headerCellStyle, cellStyle);
+                    if (lastTableName != null && !lastTableName.equals(lineList.getFirst())) {
+                        sheetRowCounter.setValue(0L);
+                        sheetTableCounter.setValue(1L);
+                    }
+                    rows.clear();
+                }
+
+                rows.add(line);
+                isFirst = false;
+            }
+
+            workbook.write(os);
+        } catch (IOException e) {
+            log.error(e.getMessage(), e);
+        }
+    }
+
+    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;
+        int rowsApproximateSize = rows.stream().mapToInt(r -> r.split("%%%", -1).length).sum();
+        if (sheetRowCounter.longValue() + (rowsApproximateSize * 2L) >= EXCEL_SHEET_MAX_SIZE) {
+            tableSheet = createSheet(workbook, parentTableName.toUpperCase() + "_" + sheetTableCounter.incrementAndGet());
+            sheetRowCounter.setValue(0L);
+        } else {
+            tableSheet = createSheet(workbook, parentTableName.toUpperCase());
+        }
+
+        for (String row : rows) {
+            List<String> rowList = Arrays.asList(row.split("%%%", -1));
+            String tableName = rowList.getFirst();
+
+            List<String> rowSublist = rowList.subList(1, rowList.size());
+            Map<String, String> rowValues = new LinkedHashMap<>();
+            for (int i = 0; i + 1 <= rowSublist.size(); i = i + 2) {
+                try {
+                    rowValues.put(rowSublist.get(i), rowSublist.get(i + 1));
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            }
+
+            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);
+
+        XSSFFont font = (XSSFFont) workbook.createFont();
+        font.setFontName("SansSerif");
+        font.setFontHeightInPoints((short) 11);
+        font.setBold(true);
+        headerCellStyle.setFont(font);
+
+        return headerCellStyle;
+    }
+
+    private CellStyle createCellStyle(Workbook workbook) {
+        CellStyle cellStyle = workbook.createCellStyle();
+        cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
+        cellStyle.setBorderBottom(BorderStyle.THIN);
+        cellStyle.setBorderLeft(BorderStyle.THIN);
+        cellStyle.setBorderTop(BorderStyle.THIN);
+        cellStyle.setBorderRight(BorderStyle.THIN);
+
+        XSSFFont font = (XSSFFont) workbook.createFont();
+        font.setFontName("Calibri");
+        font.setFontHeightInPoints((short) 11);
+        cellStyle.setFont(font);
+
+        return cellStyle;
+    }
+
+    private Sheet createSheet(Workbook workbook, String sheetName) {
+        Sheet foundSheet = workbook.getSheet(sheetName);
+
+        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,
+                                 MutableLong currentRow,
+                                 CellStyle headerCellStyle) {
+        Row headerRow = sheet.createRow(currentRow.intValue());
+        headerRow.setHeightInPoints(15);
+
+        Cell headerCell = headerRow.createCell(0);
+        headerCell.setCellValue(localizedTableName);
+        headerCell.setCellStyle(headerCellStyle);
+        sheet.addMergedRegion(new CellRangeAddress(currentRow.intValue(), currentRow.intValue(), 0, 2));
+
+        currentRow.increment();
+    }
+
+    private void writeFieldDataIntoSheetRow(String fieldKey,
+                                            String localizedFieldKey,
+                                            @Nullable Object fieldValue,
+                                            Sheet sheet,
+                                            MutableLong currentRow,
+                                            CellStyle cellStyle) {
+        Row dataRow = sheet.createRow(currentRow.intValue());
+        dataRow.setHeightInPoints(15);
+
+        Cell dataFieldCell = dataRow.createCell(0);
+        dataFieldCell.setCellValue(fieldKey.toUpperCase());
+        dataFieldCell.setCellStyle(cellStyle);
+
+        Cell descriptionCell = dataRow.createCell(1);
+        descriptionCell.setCellValue(localizedFieldKey);
+        descriptionCell.setCellStyle(cellStyle);
+
+        Cell dataValueCell = dataRow.createCell(2);
+        dataValueCell.setCellValue(Optional.ofNullable(fieldValue).orElse("").toString());
+        dataValueCell.setCellStyle(cellStyle);
+
+        currentRow.increment();
+    }
+}

src/main/java/ru/nbch/indicsearchservice/exporter/Exporter.java

@@ -0,0 +1,16 @@
+package ru.nbch.indicsearchservice.exporter;
+
+import java.util.Set;
+
+public interface Exporter {
+    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"
+    );
+}

src/main/java/ru/nbch/indicsearchservice/exporter/JsonExporter.java

@@ -0,0 +1,113 @@
+package ru.nbch.indicsearchservice.exporter;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.model.TableData;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.json.JsonMapper;
+
+@Component
+public class JsonExporter implements Exporter {
+    private static final Logger log = LoggerFactory.getLogger(JsonExporter.class);
+
+    private final ApplicationSettings settings;
+    private final JsonMapper jsonMapper;
+
+    public JsonExporter(ApplicationSettings settings,
+                        JsonMapper jsonMapper) {
+        this.settings = settings;
+        this.jsonMapper = jsonMapper;
+    }
+
+    public void writeJsonFile(Path aggregatedFile, UUID taskId) {
+        Path jsonFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".json");
+
+        try (BufferedReader reader = Files.newBufferedReader(aggregatedFile);
+             JsonGenerator jsonGenerator = jsonMapper.createGenerator(Files.newOutputStream(jsonFile))) {
+            jsonGenerator.writeStartArray();
+
+            Iterator<String> iterator = reader.lines().iterator();
+            List<String> rows = new ArrayList<>();
+            boolean isFirst = true;
+
+            while (iterator.hasNext()) {
+                String line = iterator.next();
+
+                if (line == null || line.trim().isEmpty()) {
+                    continue;
+                }
+
+                List<String> lineList = Arrays.asList(line.split("%%%", -1));
+                String tableName = lineList.getFirst();
+
+                if (!isFirst && (FIRST_LEVEL_TABLES.contains(tableName) || line.equals("EOF"))) {
+                    TableData parentData = buildTableDataHierarchy(rows);
+                    if (parentData != null) {
+                        jsonMapper.writeValue(jsonGenerator, parentData);
+                    }
+                    rows.clear();
+                }
+
+                rows.add(line);
+                isFirst = false;
+            }
+
+            jsonGenerator.writeEndArray();
+        } catch (IOException e) {
+            log.error(e.getMessage(), e);
+        }
+    }
+
+    private TableData buildTableDataHierarchy(List<String> rows) {
+        if (rows == null || rows.isEmpty()) {
+            return null;
+        }
+
+        TableData parentTableData = parseSingleRow(rows.getFirst());
+        if (parentTableData == null) {
+            return null;
+        }
+
+        for (int i = 1; i < rows.size(); i++) {
+            TableData childTableData = parseSingleRow(rows.get(i));
+            if (childTableData != null) {
+                parentTableData.getRelatedTableData().add(childTableData);
+            }
+        }
+
+        return parentTableData;
+    }
+
+    private TableData parseSingleRow(String row) {
+        String[] parts = row.split("%%%", -1);
+
+        if (parts.length == 0 || parts[0].isEmpty()) {
+            return null;
+        }
+
+        String tableName = parts[0];
+        List<TableData.FieldData> fieldData = new ArrayList<>();
+
+        for (int i = 1; i + 1 < parts.length; i += 2) {
+            String columnName = parts[i];
+            String columnValue = parts[i + 1];
+
+            if (columnName != null && !columnName.isEmpty()) {
+                fieldData.add(new TableData.FieldData(columnName, columnValue));
+            }
+        }
+
+        return new TableData(tableName, fieldData);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/filter/TableFilter.java

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

src/main/java/ru/nbch/indicsearchservice/filter/firstlevel/DefaultFirstLevelTableFilter.java

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

src/main/java/ru/nbch/indicsearchservice/filter/firstlevel/FirstLevelTableFilter.java

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

src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/AccountSecondLevelTableFilter.java

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

src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuUidSecondLevelTableFilter.java

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

src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/SecondLevelTableFilter.java

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

src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/BlocksThirdLevelTableFilter.java

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

src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/ThirdLevelTableFilter.java

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

src/main/java/ru/nbch/indicsearchservice/loader/RuAccountAmtTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAccountAmtTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAccountAmtTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ACCOUNT_AMT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerIndividTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAcquirerIndividTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAcquirerIndividTableLoader(MapperHolder mapperHolder,
+                                        IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ACQUIRERINDIVID";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerLegalTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAcquirerLegalTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAcquirerLegalTableLoader(MapperHolder mapperHolder,
+                                      IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ACQUIRERLEGAL";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuAllArrearsTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAllArrearsTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAllArrearsTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ALL_ARREARS";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuAmendmentTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAmendmentTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAmendmentTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_AMENDMENT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuAmountInfoTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAmountInfoTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAmountInfoTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_AMOUNT_INFO";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuApplicationTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuApplicationTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuApplicationTableLoader(MapperHolder mapperHolder,
+                                    IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_APPLICATION";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuArrearTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuArrearTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuArrearTableLoader(MapperHolder mapperHolder,
+                               IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ARREAR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyBlocksTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuBankruptcyBlocksTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuBankruptcyBlocksTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_BANKRUPTCY_BLOCKS";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuBankruptcyTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuBankruptcyTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_BANKRUPTCY";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuCapabilityTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCapabilityTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCapabilityTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_CAPABILITY";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuCoborrowerTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCoborrowerTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCoborrowerTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COBORROWER";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuCollatInsuredTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCollatInsuredTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCollatInsuredTableLoader(MapperHolder mapperHolder,
+                                      IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COLLATINSURED";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuCollatRepayTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCollatRepayTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCollatRepayTableLoader(MapperHolder mapperHolder,
+                                    IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COLLATREPAY";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralBlocksTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCollateralBlocksTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCollateralBlocksTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COLLATERAL_BLOCKS";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCollateralTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCollateralTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COLLATERAL";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuContractTermsChangesTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuContractTermsChangesTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuContractTermsChangesTableLoader(MapperHolder mapperHolder,
+                                             IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_CONTRACT_TERMS_CHANGES";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuDebtBurdenInfoTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuDebtBurdenInfoTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuDebtBurdenInfoTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_DEBT_BURDEN_INFO";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuDueArrearTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuDueArrearTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuDueArrearTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_DUEARREAR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuFundDateTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuFundDateTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuFundDateTableLoader(MapperHolder mapperHolder,
+                                 IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_FUNDDATE";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuGuaranteeRepayTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuGuaranteeRepayTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuGuaranteeRepayTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_GUARANTEEREPAY";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuGuarantorTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuGuarantorTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuGuarantorTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_GUARANTOR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuIndepGuarantorTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuIndepGuarantorTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuIndepGuarantorTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_INDEPGUARANTOR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuLegalRecordTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuLegalRecordTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuLegalRecordTableLoader(MapperHolder mapperHolder,
+                                    IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_LEGALRECORD";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuMonthAverPaymtTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuMonthAverPaymtTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuMonthAverPaymtTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_MONTHAVERPAYMT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuObligAccountTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligAccountTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligAccountTableLoader(MapperHolder mapperHolder,
+                                     IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGACCOUNT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuObligPartTakeTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligPartTakeTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligPartTakeTableLoader(MapperHolder mapperHolder,
+                                      IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGPARTTAKE";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuObligTerminationTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligTerminationTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligTerminationTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGTERMINATION";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcBankruptTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligsRcBankruptTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligsRcBankruptTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGSRCBANKRUPT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcLiquidTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligsRcLiquidTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligsRcLiquidTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGSRCLIQUID";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuOtherLegalTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuOtherLegalTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuOtherLegalTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OTHERLEGAL";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuOverallvalTableLoader.java

@@ -0,0 +1,46 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuOverallvalTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuOverallvalTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OVERALLVAL";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuPastDueArrearTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuPastDueArrearTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuPastDueArrearTableLoader(MapperHolder mapperHolder,
+                                      IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_PASTDUEARREAR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtConditionTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuPaymtConditionTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuPaymtConditionTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_PAYMT_CONDITION";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuPaymtTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuPaymtTableLoader(MapperHolder mapperHolder,
+                              IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_PAYMT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuServiceCoTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuServiceCoTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuServiceCoTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SERVICECO";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuSettledTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuSettledTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuSettledTableLoader(MapperHolder mapperHolder,
+                                IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SETTLED";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuSourceNonMonetObligTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuSourceNonMonetObligTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuSourceNonMonetObligTableLoader(MapperHolder mapperHolder,
+                                            IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SOURCENONMONETOBLIG";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuSubjectNonMonetObligTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuSubjectNonMonetObligTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuSubjectNonMonetObligTableLoader(MapperHolder mapperHolder,
+                                             IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SUBJECTNONMONETOBLIG";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuSubmitHoldTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuSubmitHoldTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuSubmitHoldTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SUBMITHOLD";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuTradeTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuTradeTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuTradeTableLoader(MapperHolder mapperHolder,
+                              IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_TRADE";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuUidTableLoader.java

@@ -0,0 +1,45 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuUidTableLoader implements TableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuUidTableLoader(MapperHolder mapperHolder,
+                            IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public List<DataType> getSuitableDataTypes() {
+        return List.of(DataType.GUTDF, DataType.RUTDF);
+    }
+
+    @Override
+    public List<SearchParameter> getSuitableSearchParameters() {
+        return List.of(SearchParameter.FID);
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_UID";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuUid(fidSet), taskId);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/TableLoader.java

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

src/main/java/ru/nbch/indicsearchservice/model/TableData.java

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

src/main/java/ru/nbch/indicsearchservice/repository/indic/IndicMapper.java

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

src/main/java/ru/nbch/indicsearchservice/service/IndicSearchService.java

@@ -1,14 +1,130 @@
 package ru.nbch.indicsearchservice.service;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import org.apache.commons.lang3.mutable.MutableLong;
+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.exporter.ExcelExporter;
+import ru.nbch.indicsearchservice.exporter.JsonExporter;
+import ru.nbch.indicsearchservice.loader.TableLoader;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 
 @Service
 public class IndicSearchService {
+    private static final Logger log = LoggerFactory.getLogger(IndicSearchService.class);
+
+    private static final boolean IS_EXPORT_AS_EXCEL = false;
+
+    private final List<TableLoader> tableLoaders;
+    private final List<FileAggregator> fileAggregators;
+    private final IndicSearchUtils indicSearchUtils;
+    private final ExcelExporter excelExporter;
+    private final JsonExporter jsonExporter;
+
+    public IndicSearchService(List<TableLoader> tableLoaders,
+                              List<FileAggregator> fileAggregators,
+                              IndicSearchUtils indicSearchUtils,
+                              ExcelExporter excelExporter,
+                              JsonExporter jsonExporter) {
+        this.tableLoaders = tableLoaders;
+        this.fileAggregators = fileAggregators;
+        this.indicSearchUtils = indicSearchUtils;
+        this.excelExporter = excelExporter;
+        this.jsonExporter = jsonExporter;
+    }
+
     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<>();
+        for (TableLoader tableLoader : tableLoaders) {
+            if (tableLoader.isSuitableForDataTypeAndSearchParameter(request.getDataType(), request.getSearchParameter())) {
+                suitableTableLoaders.add(tableLoader);
+            }
+        }
+
+        Set<Integer> foundFids = indicSearchUtils.getFidsBasedOnDataTypeAndSearchParameter(
+            request.getDataType(),
+            request.getSearchParameter(),
+            request.getSearchValue()
+        );
+
+        Map<String, Path> tableFileMap = new ConcurrentHashMap<>();
+        suitableTableLoaders.parallelStream().forEach(tl -> {
+            String tableName = tl.getTableName();
+            Path tableFile = tl.searchByFid(foundFids, taskId);
+
+            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) {
+            jsonExporter.writeJsonFile(aggregatedFile, taskId);
+        } else {
+            excelExporter.writeExcelFile(aggregatedFile, taskId, rowCounter.longValue());
+        }
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+
+//        try {
+//            Files.deleteIfExists(aggregatedFile);
+//        } catch (IOException e) {
+//            throw new RuntimeException(e);
+//        }
+
         return null;
     }
 

src/main/java/ru/nbch/indicsearchservice/util/IndicSearchCommon.java

@@ -0,0 +1,19 @@
+package ru.nbch.indicsearchservice.util;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class IndicSearchCommon {
+    public static Optional<String> getRowValue(String string, String key) {
+        return getRowValue(Arrays.asList(string.split("%%%", -1)), key);
+    }
+
+    public static Optional<String> getRowValue(List<String> stringValues, String key) {
+        int keyIndex = stringValues.indexOf(key);
+        if (keyIndex != -1) {
+            return Optional.of(stringValues.get(keyIndex + 1));
+        }
+        return Optional.empty();
+    }
+}

src/main/java/ru/nbch/indicsearchservice/util/IndicSearchUtils.java

@@ -0,0 +1,83 @@
+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.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Function;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+@Component
+public class IndicSearchUtils {
+    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("%%%");
+
+                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<>();
+
+        if (dataType == null || searchParameter == null) {
+            return fids;
+        }
+
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                return Set.of(Integer.parseInt(searchValue));
+            }
+        } else if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                return Set.of(Integer.parseInt(searchValue));
+            }
+        }
+
+        return fids;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/util/MovableBufferedReader.java

@@ -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();
+    }
+}

src/main/resources/application.properties

@@ -13,3 +13,5 @@ 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.storage-directory=C:\\Users\\inikolaev\\Desktop\\1

src/main/resources/mappers/indic/indic_mapper.xml

@@ -14,6 +14,469 @@
         WITH UR
     </select>
 
+    <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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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>
+
+
     <select id="findAllByAcctNumAndMemberCodeFromRuUid" resultType="java.util.LinkedHashMap" timeout="60">
         SELECT ${columns}
         FROM INDIC.RU_UID