incomplete v2

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/filter/TableFilter.java

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

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

@@ -0,0 +1,6 @@
+package ru.nbch.indicsearchservice.filter.firstlevel;
+
+import ru.nbch.indicsearchservice.filter.TableFilter;
+
+public interface FirstLevelTableFilter extends TableFilter {
+}

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

@@ -0,0 +1,8 @@
+package ru.nbch.indicsearchservice.filter.firstlevel;
+
+public class SameLevelTableFilter implements FirstLevelTableFilter {
+    @Override
+    public String getTableName() {
+        return "";
+    }
+}

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

@@ -0,0 +1,38 @@
+package ru.nbch.indicsearchservice.filter.secondlevel;
+
+import java.util.List;
+import java.util.Optional;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.model.TableData;
+
+@Component
+public class RuAccountAmtTableFilter implements SecondLevelTableFilter {
+    @Override
+    public String getTableName() {
+        return "RU_ACCOUNT_AMT";
+    }
+
+    public void filterTableData(List<TableData> parentTableDataList, List<TableData> childTableDataList) {
+        for (TableData parentTableData : parentTableDataList) {
+            Optional<TableData.FieldData> serialNumFieldData = parentTableData.getFieldData().stream()
+                .filter(d -> d.columnName().equals("SERIAL_NUM"))
+                .findFirst();
+            if (serialNumFieldData.isEmpty()) {
+                continue;
+            }
+
+            for (TableData childTableData : childTableDataList) {
+                Optional<TableData.FieldData> accSerialNumFieldData = childTableData.getFieldData().stream()
+                    .filter(d -> d.columnName().equals("ACC_SERIAL_NUM"))
+                    .findFirst();
+                if (accSerialNumFieldData.isEmpty()) {
+                    continue;
+                }
+
+                if (serialNumFieldData.get().equals(accSerialNumFieldData.get())) {
+                    parentTableData.getRelatedTableData().add(childTableData);
+                }
+            }
+        }
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+package ru.nbch.indicsearchservice.filter.secondlevel;
+
+import ru.nbch.indicsearchservice.filter.TableFilter;
+
+public interface SecondLevelTableFilter extends TableFilter {
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+package ru.nbch.indicsearchservice.filter.thirdlevel;
+
+import ru.nbch.indicsearchservice.filter.TableFilter;
+
+public interface ThirdLevelTableFilter extends TableFilter {
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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);
 
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuUid(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuTrade(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuApplication(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuAccountAmt(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerIndivid(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerLegal(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuAllArrears(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuAmendment(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuAmountInfo(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuArrear(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcy(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcyBlocks(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuCapability(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuCoborrower(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuCollateral(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuCollateralBlocks(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuCollatInsured(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuCollatRepay(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuContractTermsChanges(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuDebtBurdenInfo(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuDueArrear(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuFundDate(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuGuaranteeRepay(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuGuarantor(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuIndepGuarantor(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuLegalRecord(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuMonthAverPaymt(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligAccount(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligPartTake(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcBankrupt(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcLiquid(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligTermination(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuOtherLegal(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuOverallval(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuPastDueArrear(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuPaymtCondition(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuPaymt(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuServiceCo(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuSettled(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuSourceNonMonetOblig(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuSubjectNonMonetOblig(Set<Integer> fids);
+    List<LinkedHashMap<String, Object>> findAllByFidFromRuSubmitHold(Set<Integer> fids);
+
     List<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUid(String columns, String acctNum, String memberCode);
     Cursor<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUidCursor(String columns, String acctNum, String memberCode);
     List<LinkedHashMap<String, Object>> findAllByApplicationNumberAndMemberCodeFromRuApplication(String columns, String applicationNumber, String memberCode);

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

@@ -1,14 +1,58 @@
 package ru.nbch.indicsearchservice.service;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import ru.nbch.indicsearchservice.dto.request.AddSearchJobRequestDto;
 import ru.nbch.indicsearchservice.dto.response.AddSearchJobResponseDto;
 import ru.nbch.indicsearchservice.dto.response.JobStatusResponseDto;
+import ru.nbch.indicsearchservice.filter.TableFilter;
+import ru.nbch.indicsearchservice.loader.TableLoader;
+import ru.nbch.indicsearchservice.model.TableData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 
 @Service
 public class IndicSearchService {
+    private final List<TableLoader> tableLoaders;
+    private final List<TableFilter> tableFilters;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public IndicSearchService(List<TableLoader> tableLoaders,
+                              List<TableFilter> tableFilters,
+                              IndicSearchUtils indicSearchUtils) {
+        this.tableLoaders = tableLoaders;
+        this.tableFilters = tableFilters;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
     public AddSearchJobResponseDto addSearchJob(AddSearchJobRequestDto request) {
+        List<TableLoader> suitableTableLoaders = new ArrayList<>();
+        for (TableLoader tableLoader : tableLoaders) {
+            if (tableLoader.isSuitableForDataTypeAndSearchParameter(request.getDataType(), request.getSearchParameter())) {
+                suitableTableLoaders.add(tableLoader);
+            }
+        }
+
+        Set<Integer> foundFids = indicSearchUtils.getFidsBasedOnDataTypeAndSearchParameter(
+            request.getDataType(),
+            request.getSearchParameter(),
+            request.getSearchValue()
+        );
+
+        Map<String, List<TableData>> tableDataMapByFid = new HashMap<>();
+        for (TableLoader tableLoader : suitableTableLoaders) {
+            tableDataMapByFid.put(tableLoader.getTableName(), tableLoader.searchByFid(foundFids));
+        }
+
+        Map<String, List<TableData>> firstLevelTables = new HashMap<>();
+        Map<String, List<TableData>> secondLevelTables = new HashMap<>();
+        Map<String, List<TableData>> thirdLevelTables = new HashMap<>();
+
         return null;
     }
 

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

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

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

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