diff --git a/src/main/java/ru/nbch/indicsearchservice/config/ObjectMapperConfig.java b/src/main/java/ru/nbch/indicsearchservice/config/ObjectMapperConfig.java index c5a1dc5..f34f6b0 100644 --- a/src/main/java/ru/nbch/indicsearchservice/config/ObjectMapperConfig.java +++ b/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) diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/TableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/TableFilter.java new file mode 100644 index 0000000..c452830 --- /dev/null +++ b/src/main/java/ru/nbch/indicsearchservice/filter/TableFilter.java @@ -0,0 +1,5 @@ +package ru.nbch.indicsearchservice.filter; + +public interface TableFilter { + String getTableName(); +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/firstlevel/FirstLevelTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/firstlevel/FirstLevelTableFilter.java new file mode 100644 index 0000000..2d99d17 --- /dev/null +++ b/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 { +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/firstlevel/SameLevelTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/firstlevel/SameLevelTableFilter.java new file mode 100644 index 0000000..1b8cb01 --- /dev/null +++ b/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 ""; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAccountAmtTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAccountAmtTableFilter.java new file mode 100644 index 0000000..ec82762 --- /dev/null +++ b/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 parentTableDataList, List childTableDataList) { + for (TableData parentTableData : parentTableDataList) { + Optional serialNumFieldData = parentTableData.getFieldData().stream() + .filter(d -> d.columnName().equals("SERIAL_NUM")) + .findFirst(); + if (serialNumFieldData.isEmpty()) { + continue; + } + + for (TableData childTableData : childTableDataList) { + Optional 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); + } + } + } + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAcquirerIndividTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAcquirerIndividTableFilter.java new file mode 100644 index 0000000..878dca5 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ACQUIRERINDIVID"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAcquirerLegalTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAcquirerLegalTableFilter.java new file mode 100644 index 0000000..50b00c9 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ACQUIRERLEGAL"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAllArrearsTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAllArrearsTableFilter.java new file mode 100644 index 0000000..0ced518 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ALL_ARREARS"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAmendmentTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAmendmentTableFilter.java new file mode 100644 index 0000000..4358ff1 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_AMENDMENT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAmountInfoTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuAmountInfoTableFilter.java new file mode 100644 index 0000000..c18e19d --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_AMOUNT_INFO"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuArrearTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuArrearTableFilter.java new file mode 100644 index 0000000..f6d6c04 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ARREAR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuCoborrowerTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuCoborrowerTableFilter.java new file mode 100644 index 0000000..736d89c --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COBORROWER"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuCollatInsuredTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuCollatInsuredTableFilter.java new file mode 100644 index 0000000..93763f1 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COLLATINSURED"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuCollatRepayTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuCollatRepayTableFilter.java new file mode 100644 index 0000000..4f66045 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COLLATREPAY"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuContractTermsChangesTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuContractTermsChangesTableFilter.java new file mode 100644 index 0000000..68e01f5 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_CONTRACT_TERMS_CHANGES"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuDueArrearTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuDueArrearTableFilter.java new file mode 100644 index 0000000..6d10063 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_DUEARREAR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuFundDateTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuFundDateTableFilter.java new file mode 100644 index 0000000..a3c6244 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_FUNDDATE"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuGuaranteeRepayTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuGuaranteeRepayTableFilter.java new file mode 100644 index 0000000..16a900b --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_GUARANTEEREPAY"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuGuarantorTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuGuarantorTableFilter.java new file mode 100644 index 0000000..2aefd1b --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_GUARANTOR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuIndepGuarantorTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuIndepGuarantorTableFilter.java new file mode 100644 index 0000000..59b1c4f --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_INDEPGUARANTOR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuLegalRecordTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuLegalRecordTableFilter.java new file mode 100644 index 0000000..65174c7 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_LEGALRECORD"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuMonthAverPaymtTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuMonthAverPaymtTableFilter.java new file mode 100644 index 0000000..4baf12c --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_MONTHAVERPAYMT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuObligAccountTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuObligAccountTableFilter.java new file mode 100644 index 0000000..e908999 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGACCOUNT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuObligTerminationTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuObligTerminationTableFilter.java new file mode 100644 index 0000000..7cfbf59 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGTERMINATION"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuObligsRcBankruptTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuObligsRcBankruptTableFilter.java new file mode 100644 index 0000000..f8d6894 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGSRCBANKRUPT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuObligsRcLiquidTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuObligsRcLiquidTableFilter.java new file mode 100644 index 0000000..63cbfb1 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGSRCLIQUID"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuOverallvalTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuOverallvalTableFilter.java new file mode 100644 index 0000000..0ecd3c2 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OVERALLVAL"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuPastDueArrearTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuPastDueArrearTableFilter.java new file mode 100644 index 0000000..04e2f19 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_PASTDUEARREAR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuPaymtConditionTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuPaymtConditionTableFilter.java new file mode 100644 index 0000000..c84a944 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_PAYMT_CONDITION"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuPaymtTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuPaymtTableFilter.java new file mode 100644 index 0000000..ba75b20 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_PAYMT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuServiceCoTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuServiceCoTableFilter.java new file mode 100644 index 0000000..1cf8a67 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SERVICECO"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuSourceNonMonetObligTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuSourceNonMonetObligTableFilter.java new file mode 100644 index 0000000..a1d837f --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SOURCENONMONETOBLIG"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuSubjectNonMonetObligTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuSubjectNonMonetObligTableFilter.java new file mode 100644 index 0000000..8686ef4 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SUBJECTNONMONETOBLIG"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuSubmitHoldTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuSubmitHoldTableFilter.java new file mode 100644 index 0000000..ad36f96 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SUBMITHOLD"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuTradeTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuTradeTableFilter.java new file mode 100644 index 0000000..2371590 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_TRADE"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/SecondLevelTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/SecondLevelTableFilter.java new file mode 100644 index 0000000..c99a090 --- /dev/null +++ b/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 { +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/RuBankruptcyBlocksTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/RuBankruptcyBlocksTableFilter.java new file mode 100644 index 0000000..136221c --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_BANKRUPTCY_BLOCKS"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/RuCollateralBlocksTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/RuCollateralBlocksTableFilter.java new file mode 100644 index 0000000..951649b --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COLLATERAL_BLOCKS"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/ThirdLevelTableFilter.java b/src/main/java/ru/nbch/indicsearchservice/filter/thirdlevel/ThirdLevelTableFilter.java new file mode 100644 index 0000000..87b4021 --- /dev/null +++ b/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 { +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuAccountAmtTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuAccountAmtTableLoader.java new file mode 100644 index 0000000..b4c736d --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ACCOUNT_AMT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerIndividTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerIndividTableLoader.java new file mode 100644 index 0000000..596fe19 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ACQUIRERINDIVID"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerLegalTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuAcquirerLegalTableLoader.java new file mode 100644 index 0000000..50e8ac8 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ACQUIRERLEGAL"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuAllArrearsTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuAllArrearsTableLoader.java new file mode 100644 index 0000000..fde1844 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ALL_ARREARS"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuAmendmentTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuAmendmentTableLoader.java new file mode 100644 index 0000000..4d1645e --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_AMENDMENT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuAmountInfoTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuAmountInfoTableLoader.java new file mode 100644 index 0000000..71ac678 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_AMOUNT_INFO"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuApplicationTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuApplicationTableLoader.java new file mode 100644 index 0000000..f5f1ae9 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_APPLICATION"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuArrearTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuArrearTableLoader.java new file mode 100644 index 0000000..761f9a8 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_ARREAR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyBlocksTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyBlocksTableLoader.java new file mode 100644 index 0000000..1dd136f --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_BANKRUPTCY_BLOCKS"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyTableLoader.java new file mode 100644 index 0000000..f82ec60 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_BANKRUPTCY"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuCapabilityTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuCapabilityTableLoader.java new file mode 100644 index 0000000..e93b359 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_CAPABILITY"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuCoborrowerTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuCoborrowerTableLoader.java new file mode 100644 index 0000000..54ca0ef --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COBORROWER"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuCollatInsuredTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuCollatInsuredTableLoader.java new file mode 100644 index 0000000..e5e25d0 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COLLATINSURED"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuCollatRepayTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuCollatRepayTableLoader.java new file mode 100644 index 0000000..d384585 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COLLATREPAY"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralBlocksTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralBlocksTableLoader.java new file mode 100644 index 0000000..e5ef500 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COLLATERAL_BLOCKS"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuCollateralTableLoader.java new file mode 100644 index 0000000..57fa78f --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_COLLATERAL"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuContractTermsChangesTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuContractTermsChangesTableLoader.java new file mode 100644 index 0000000..76e964f --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_CONTRACT_TERMS_CHANGES"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuDebtBurdenInfoTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuDebtBurdenInfoTableLoader.java new file mode 100644 index 0000000..92f56f5 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_DEBT_BURDEN_INFO"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuDueArrearTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuDueArrearTableLoader.java new file mode 100644 index 0000000..f209a7c --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_DUEARREAR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuFundDateTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuFundDateTableLoader.java new file mode 100644 index 0000000..5983478 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_FUNDDATE"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuGuaranteeRepayTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuGuaranteeRepayTableLoader.java new file mode 100644 index 0000000..a234113 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_GUARANTEEREPAY"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuGuarantorTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuGuarantorTableLoader.java new file mode 100644 index 0000000..0b344f9 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_GUARANTOR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuIndepGuarantorTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuIndepGuarantorTableLoader.java new file mode 100644 index 0000000..2c76999 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_INDEPGUARANTOR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuLegalRecordTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuLegalRecordTableLoader.java new file mode 100644 index 0000000..1c47485 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_LEGALRECORD"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuMonthAverPaymtTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuMonthAverPaymtTableLoader.java new file mode 100644 index 0000000..521ecbf --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_MONTHAVERPAYMT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuObligAccountTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuObligAccountTableLoader.java new file mode 100644 index 0000000..bfc758e --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGACCOUNT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuObligPartTakeTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuObligPartTakeTableLoader.java new file mode 100644 index 0000000..ee0bce3 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGPARTTAKE"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuObligTerminationTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuObligTerminationTableLoader.java new file mode 100644 index 0000000..131bbf6 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGTERMINATION"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcBankruptTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcBankruptTableLoader.java new file mode 100644 index 0000000..dd1a5ec --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGSRCBANKRUPT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcLiquidTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuObligsRcLiquidTableLoader.java new file mode 100644 index 0000000..b54b18c --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OBLIGSRCLIQUID"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuOtherLegalTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuOtherLegalTableLoader.java new file mode 100644 index 0000000..2418394 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OTHERLEGAL"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuOverallvalTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuOverallvalTableLoader.java new file mode 100644 index 0000000..dbcb87b --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_OVERALLVAL"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuPastDueArrearTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuPastDueArrearTableLoader.java new file mode 100644 index 0000000..447e50c --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_PASTDUEARREAR"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtConditionTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtConditionTableLoader.java new file mode 100644 index 0000000..00530b9 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_PAYMT_CONDITION"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuPaymtTableLoader.java new file mode 100644 index 0000000..618cbda --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_PAYMT"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuServiceCoTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuServiceCoTableLoader.java new file mode 100644 index 0000000..3f41f03 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SERVICECO"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuSettledTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuSettledTableLoader.java new file mode 100644 index 0000000..5c19d06 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SETTLED"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuSourceNonMonetObligTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuSourceNonMonetObligTableLoader.java new file mode 100644 index 0000000..1ff11a7 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SOURCENONMONETOBLIG"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuSubjectNonMonetObligTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuSubjectNonMonetObligTableLoader.java new file mode 100644 index 0000000..8fed736 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SUBJECTNONMONETOBLIG"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuSubmitHoldTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuSubmitHoldTableLoader.java new file mode 100644 index 0000000..d86ecba --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_SUBMITHOLD"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuTradeTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuTradeTableLoader.java new file mode 100644 index 0000000..f3f88c4 --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_TRADE"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/RuUidTableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/RuUidTableLoader.java new file mode 100644 index 0000000..857fa6d --- /dev/null +++ b/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 getSuitableDataTypes() { + return List.of(DataType.GUTDF, DataType.RUTDF); + } + + @Override + public List getSuitableSearchParameters() { + return List.of(SearchParameter.FID); + } + + @Override + public String getTableName() { + return "RU_UID"; + } + + @Override + public List searchByFid(Set fids) { + List> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuUid(fids); + + List resultTableData = new ArrayList<>(); + for (LinkedHashMap row : foundTableRows) { + TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row); + resultTableData.add(parsedTableData); + } + + return resultTableData; + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/loader/TableLoader.java b/src/main/java/ru/nbch/indicsearchservice/loader/TableLoader.java new file mode 100644 index 0000000..072a85b --- /dev/null +++ b/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 getSuitableDataTypes(); + List getSuitableSearchParameters(); + String getTableName(); + + default boolean isSuitableForDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter) { + return getSuitableDataTypes().contains(dataType) && getSuitableSearchParameters().contains(searchParameter); + } + + List searchByFid(Set fids); +} diff --git a/src/main/java/ru/nbch/indicsearchservice/model/TableData.java b/src/main/java/ru/nbch/indicsearchservice/model/TableData.java new file mode 100644 index 0000000..859421e --- /dev/null +++ b/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 = new ArrayList<>(); + private List relatedTableData = new ArrayList<>(); + + public TableData() { + } + + public TableData(String tableName, List fieldData) { + this.tableName = tableName; + this.fieldData = fieldData; + } + + public TableData(String tableName, List fieldData, List relatedTableData) { + this.tableName = tableName; + this.fieldData = fieldData; + this.relatedTableData = relatedTableData; + } + + public String getTableName() { + return tableName; + } + + public List getFieldData() { + return fieldData; + } + + public List 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) { + } +} diff --git a/src/main/java/ru/nbch/indicsearchservice/repository/indic/IndicMapper.java b/src/main/java/ru/nbch/indicsearchservice/repository/indic/IndicMapper.java index 9b59e09..a21aa56 100644 --- a/src/main/java/ru/nbch/indicsearchservice/repository/indic/IndicMapper.java +++ b/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> getTableColumnsByTableNames(List tables); + List> findAllByFidFromRuUid(Set fids); + List> findAllByFidFromRuTrade(Set fids); + List> findAllByFidFromRuApplication(Set fids); + List> findAllByFidFromRuAccountAmt(Set fids); + List> findAllByFidFromRuAcquirerIndivid(Set fids); + List> findAllByFidFromRuAcquirerLegal(Set fids); + List> findAllByFidFromRuAllArrears(Set fids); + List> findAllByFidFromRuAmendment(Set fids); + List> findAllByFidFromRuAmountInfo(Set fids); + List> findAllByFidFromRuArrear(Set fids); + List> findAllByFidFromRuBankruptcy(Set fids); + List> findAllByFidFromRuBankruptcyBlocks(Set fids); + List> findAllByFidFromRuCapability(Set fids); + List> findAllByFidFromRuCoborrower(Set fids); + List> findAllByFidFromRuCollateral(Set fids); + List> findAllByFidFromRuCollateralBlocks(Set fids); + List> findAllByFidFromRuCollatInsured(Set fids); + List> findAllByFidFromRuCollatRepay(Set fids); + List> findAllByFidFromRuContractTermsChanges(Set fids); + List> findAllByFidFromRuDebtBurdenInfo(Set fids); + List> findAllByFidFromRuDueArrear(Set fids); + List> findAllByFidFromRuFundDate(Set fids); + List> findAllByFidFromRuGuaranteeRepay(Set fids); + List> findAllByFidFromRuGuarantor(Set fids); + List> findAllByFidFromRuIndepGuarantor(Set fids); + List> findAllByFidFromRuLegalRecord(Set fids); + List> findAllByFidFromRuMonthAverPaymt(Set fids); + List> findAllByFidFromRuObligAccount(Set fids); + List> findAllByFidFromRuObligPartTake(Set fids); + List> findAllByFidFromRuObligsRcBankrupt(Set fids); + List> findAllByFidFromRuObligsRcLiquid(Set fids); + List> findAllByFidFromRuObligTermination(Set fids); + List> findAllByFidFromRuOtherLegal(Set fids); + List> findAllByFidFromRuOverallval(Set fids); + List> findAllByFidFromRuPastDueArrear(Set fids); + List> findAllByFidFromRuPaymtCondition(Set fids); + List> findAllByFidFromRuPaymt(Set fids); + List> findAllByFidFromRuServiceCo(Set fids); + List> findAllByFidFromRuSettled(Set fids); + List> findAllByFidFromRuSourceNonMonetOblig(Set fids); + List> findAllByFidFromRuSubjectNonMonetOblig(Set fids); + List> findAllByFidFromRuSubmitHold(Set fids); + List> findAllByAcctNumAndMemberCodeFromRuUid(String columns, String acctNum, String memberCode); Cursor> findAllByAcctNumAndMemberCodeFromRuUidCursor(String columns, String acctNum, String memberCode); List> findAllByApplicationNumberAndMemberCodeFromRuApplication(String columns, String applicationNumber, String memberCode); diff --git a/src/main/java/ru/nbch/indicsearchservice/service/IndicSearchService.java b/src/main/java/ru/nbch/indicsearchservice/service/IndicSearchService.java index 366586f..6aa83d2 100644 --- a/src/main/java/ru/nbch/indicsearchservice/service/IndicSearchService.java +++ b/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 tableLoaders; + private final List tableFilters; + private final IndicSearchUtils indicSearchUtils; + + public IndicSearchService(List tableLoaders, + List tableFilters, + IndicSearchUtils indicSearchUtils) { + this.tableLoaders = tableLoaders; + this.tableFilters = tableFilters; + this.indicSearchUtils = indicSearchUtils; + } + public AddSearchJobResponseDto addSearchJob(AddSearchJobRequestDto request) { + List suitableTableLoaders = new ArrayList<>(); + for (TableLoader tableLoader : tableLoaders) { + if (tableLoader.isSuitableForDataTypeAndSearchParameter(request.getDataType(), request.getSearchParameter())) { + suitableTableLoaders.add(tableLoader); + } + } + + Set foundFids = indicSearchUtils.getFidsBasedOnDataTypeAndSearchParameter( + request.getDataType(), + request.getSearchParameter(), + request.getSearchValue() + ); + + Map> tableDataMapByFid = new HashMap<>(); + for (TableLoader tableLoader : suitableTableLoaders) { + tableDataMapByFid.put(tableLoader.getTableName(), tableLoader.searchByFid(foundFids)); + } + + Map> firstLevelTables = new HashMap<>(); + Map> secondLevelTables = new HashMap<>(); + Map> thirdLevelTables = new HashMap<>(); + return null; } diff --git a/src/main/java/ru/nbch/indicsearchservice/util/IndicSearchUtils.java b/src/main/java/ru/nbch/indicsearchservice/util/IndicSearchUtils.java new file mode 100644 index 0000000..c87606f --- /dev/null +++ b/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 getFidsBasedOnDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter, String searchValue) { + Set 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 row) { + List 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; + }; + } +} diff --git a/src/main/resources/mappers/indic/indic_mapper.xml b/src/main/resources/mappers/indic/indic_mapper.xml index 1fccf72..aa2a226 100644 --- a/src/main/resources/mappers/indic/indic_mapper.xml +++ b/src/main/resources/mappers/indic/indic_mapper.xml @@ -14,6 +14,427 @@ WITH UR + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +