diff --git a/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/builders/bean/KSRepLccValueReport.java b/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/builders/bean/KSRepLccValueReport.java index 96d6018ef..7463dadda 100644 --- a/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/builders/bean/KSRepLccValueReport.java +++ b/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/builders/bean/KSRepLccValueReport.java @@ -60,12 +60,12 @@ public class KSRepLccValueReport { private BigDecimal lockQuantity; @CsvBindByName(column = "FREE_QUANTITY") - @CsvBindByPosition(position = 10) + @CsvBindByPosition(position = 11) @CsvNumber(value = "#0.00", writeFormat = "#0.00") private BigDecimal freeQuantity; @CsvBindByName(column = "VALUE") - @CsvBindByPosition(position = 11) + @CsvBindByPosition(position = 12) private BigDecimal value; diff --git a/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/builders/ks/KSRepLccValueReportBuilder.java b/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/builders/ks/KSRepLccValueReportBuilder.java index 6de1da6f6..499f320c9 100644 --- a/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/builders/ks/KSRepLccValueReportBuilder.java +++ b/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/builders/ks/KSRepLccValueReportBuilder.java @@ -1,29 +1,52 @@ package ru.spcex.clearing.reports.builders.ks; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.time.LocalDate; +import java.time.LocalDateTime; import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; import org.springframework.stereotype.Component; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.security.Rates; +import ru.clearing.classes.statics.data.security.RiskParameter; +import ru.clearing.platform.dictionary.CurrencyPairDictionary; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.reports.builders.CSVReportBuilder; import ru.spcex.clearing.reports.builders.EmptyParams; import ru.spcex.clearing.reports.builders.bean.KSRepLccValueReport; +import ru.spcex.platform.enumeration.RegistryDesignation; +import ru.spcex.platform.enumeration.RegistryInstrumentType; +import ru.spcex.platform.enumeration.RegistryStatus; +import ru.spcex.platform.enumeration.RegistryTradingParams; +import ru.spcex.platform.enumeration.RegistryUnit; import ru.spcex.platform.enumeration.ReportBuilderType; import ru.spcex.platform.enumeration.ReportKeys; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder; +import ru.spcex.platform.utils.enumeration.IEnumKey; @Component public class KSRepLccValueReportBuilder extends CSVReportBuilder { private final Imdg registryImdg; private final Imdg ratesImdg; + private final Imdg riskParameterImdg; + private final Imdg currencyPairDictionaryImdg; private List rows = null; public KSRepLccValueReportBuilder(ImdgProvider imdgProvider) { registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); ratesImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Rates, Rates.class); + riskParameterImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_RiskParameter, RiskParameter.class); + currencyPairDictionaryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class); } @Override @@ -53,9 +76,231 @@ public class KSRepLccValueReportBuilder extends CSVReportBuilder(); + ImdgPredicateBuilder registryPB = registryImdg.predicateBuilder(); + ImdgPredicate baseRegistriesPredicate = RegistryCodeSqlBuilder.getInstance( + RegistryTradingParams.AM_F, + RegistryTradingParams.OM_T, + RegistryTradingParams.TM_T + ).buildPredicate(registryPB); + Collection baseRegistries = registryImdg.getCollectionObjectsByPredicate(baseRegistriesPredicate); + + Map> groupedByTKR = baseRegistries.stream() + .filter(registry -> { + if (registry.getTradingClearingRegistry() == null) { + log.warn("Skip registry (id = {}): empty trading_clearing_registry", registry.getId()); + return false; + } + if (registry.getSecuritySymbol() == null) { + log.warn("Skip registry (id = {}): empty security_symbol", registry.getId()); + return false; + } + return true; + }) + .collect(Collectors.groupingBy(Registry::getTradingClearingRegistry)); + + Map currencyRates = new HashMap<>(); + LocalDateTime nowTime = LocalDateTime.now(); + for (Map.Entry> entryTKR : groupedByTKR.entrySet()) { + try { + String tkr = entryTKR.getKey(); + List registriesForTKR = entryTKR.getValue(); + + String firmId = registriesForTKR.iterator().next().getTradingCode(); + + BigDecimal sumValue = BigDecimal.ZERO; + Map quantities = new HashMap<>(); + Map demandMoneys = new HashMap<>(); + Map obligMoneys = new HashMap<>(); + Map values = new HashMap<>(); + Map currencies = new HashMap<>(); + Map rates = new HashMap<>(); + for (Registry registry : registriesForTKR) { + String securitySymbol = registry.getSecuritySymbol(); + RegistryStatus status = IEnumKey.getEnumByKey(RegistryStatus.class, registry.getRegistryStatus()); + Rates currencyRate = getRate(securitySymbol, currencyRates); + rates.computeIfAbsent(currencyRate.getCurrencyId(), c -> currencyRate.getValue()); + + String currency = currencies.computeIfAbsent(currencyRate.getCurrencyId(), s -> registry.getSecuritySymbol()); + BigDecimal quantity = quantities.computeIfAbsent(currencyRate.getCurrencyId(), s -> BigDecimal.ZERO); + BigDecimal demandMoney = demandMoneys.computeIfAbsent(currencyRate.getCurrencyId(), s -> BigDecimal.ZERO); + BigDecimal obligMoney = obligMoneys.computeIfAbsent(currencyRate.getCurrencyId(), s -> BigDecimal.ZERO); + BigDecimal value = values.computeIfAbsent(currencyRate.getCurrencyId(), s -> BigDecimal.ZERO); + + if ( + registry.getRegistryDesignation().equals(RegistryDesignation.A.getKey()) && + registry.getRegistryInstrumentType().equals(RegistryInstrumentType.M.getKey()) && + registry.getRegistryUnit().equals(RegistryUnit.F.getKey()) + ) { + if (registry.getBalance() == null) continue; + BigDecimal forAdd = registry.getBalance().multiply(currencyRate.getValue()); + sumValue = sumValue.add(forAdd); + value = value.add(forAdd); + quantity = quantity.add(registry.getBalance()); + } + + + if ( + List.of(RegistryStatus.MNG, RegistryStatus.PROC).contains(status) && + registry.getRegistryInstrumentType().equals(RegistryInstrumentType.M.getKey()) && + registry.getRegistryUnit().equals(RegistryUnit.T.getKey()) + ) { + if (registry.getRegistryDesignation().equals(RegistryDesignation.T.getKey())) { + demandMoney = demandMoney.add(registry.getBalance()); + } else if (registry.getRegistryDesignation().equals(RegistryDesignation.O.getKey())) { + obligMoney = obligMoney.add(registry.getBalance()); + } + } + + currencies.put(currencyRate.getCurrencyId(), currency); + quantities.put(currencyRate.getCurrencyId(), quantity); + demandMoneys.put(currencyRate.getCurrencyId(), demandMoney); + obligMoneys.put(currencyRate.getCurrencyId(), obligMoney); + values.put(currencyRate.getCurrencyId(), value); + + } + + BigDecimal sValue = BigDecimal.ZERO; + BigDecimal m0Value = BigDecimal.ZERO; + Map posMoneys = new HashMap<>(); + Map risk = new HashMap<>(); + for (Rates rate : currencyRates.values()) { + Long currencyId = rate.getCurrencyId(); + BigDecimal posMoney = posMoneys.computeIfAbsent(currencyId, c -> BigDecimal.ZERO); + posMoney = posMoney.add( + quantities.get(currencyId).add( + demandMoneys.get(currencyId)).subtract(obligMoneys.get(currencyId) + ) + ); + posMoneys.put(currencyId, posMoney); + + ImdgPredicateBuilder currencyPairPB = currencyPairDictionaryImdg.predicateBuilder(); + Collection currencyPair = currencyPairDictionaryImdg.getCollectionObjectsByPredicate( + currencyPairPB.equals("baseCurrency", currencies.get(currencyId)) + ); + BigDecimal riskValue = BigDecimal.ONE; + boolean riskFound = false; + if (!currencyPair.isEmpty()) { + Long pairId = currencyPair.iterator().next().getId(); + ImdgPredicateBuilder riskParameterImdgPB = riskParameterImdg.predicateBuilder(); + Collection risks = riskParameterImdg.getCollectionObjectsByPredicate( + riskParameterImdgPB.and( + riskParameterImdgPB.equals("settlementType", "T1"), + riskParameterImdgPB.equals("currencyPairId", pairId) + ) + ); + if (!risks.isEmpty()) { + RiskParameter currRisk = risks.iterator().next(); + risk.put(currencyId, currRisk); + riskValue = currRisk.getValue(); + riskFound = true; + } + } + if (!riskFound) { + RiskParameter riskParameter = new RiskParameter(); + riskParameter.setValue(riskValue); + risk.put(currencyId, riskParameter); + } + + + m0Value = m0Value.add(posMoney.multiply(rate.getValue()).multiply(riskValue)); + sValue = sValue.add(posMoney.multiply(rate.getValue())); + + } + + BigDecimal NPR = sValue.subtract(m0Value); + + + BigDecimal lockValue = BigDecimal.ZERO; + BigDecimal freeValue = BigDecimal.ZERO; + List rowsForAdd = new ArrayList<>(currencyRates.size()); + for (Rates rate : currencyRates.values()) { + try { + KSRepLccValueReport row = new KSRepLccValueReport(); + row.setFirmId(firmId); + row.setReportDate(nowTime); + row.setTkr(tkr); + row.setSumValue(sumValue); + row.setValue(values.get(rate.getCurrencyId())); + row.setSingleLimit(NPR); + row.setCurrency(rate.getCurrency()); + row.setNccRealAccount(""); + + BigDecimal quantity = quantities.get(rate.getCurrencyId()); + BigDecimal freeQuantity; + if (quantity.compareTo(BigDecimal.ZERO) <= 0 || NPR.compareTo(BigDecimal.ZERO) < 0) { + freeQuantity = BigDecimal.ZERO; + } else { + BigDecimal constValue; + BigDecimal sValueExt = BigDecimal.ZERO; + BigDecimal m0ValueExt = BigDecimal.ZERO; + for (Rates currRate : currencyRates.values()) { + if (currRate.getId().equals(rate.getId())) continue; + BigDecimal value = posMoneys.get(currRate.getCurrencyId()).multiply(currRate.getValue()); + sValueExt = sValueExt.add(value); + m0ValueExt = m0ValueExt.add(value.multiply(risk.get(currRate.getCurrencyId()).getValue())); + } + constValue = sValueExt.subtract(m0ValueExt); + BigDecimal posMoney = posMoneys.get(rate.getCurrencyId()); + BigDecimal riskValue = risk.get(rate.getCurrencyId()).getValue(); + BigDecimal NPRExt = posMoney.multiply(rate.getValue()).multiply(BigDecimal.ONE.subtract(riskValue)).add(constValue); + BigDecimal minPos = constValue.negate().divide(BigDecimal.ONE.subtract(riskValue).multiply(rate.getValue()), RoundingMode.HALF_UP); + + BigDecimal delta = posMoney.subtract(minPos); + if (delta.compareTo(BigDecimal.ZERO) >= 0 && delta.compareTo(quantity) <= 0) { + freeQuantity = delta; + } else if (delta.compareTo(BigDecimal.ZERO) < 0 && delta.compareTo(quantity) > 0) { + freeQuantity = quantity; + } else freeQuantity = BigDecimal.ZERO; + } + BigDecimal lockQuantity = quantity.subtract(freeQuantity); + row.setQuantity(quantity); + row.setLockQuantity(lockQuantity); + row.setFreeQuantity(freeQuantity); + + lockValue = lockValue.add(lockQuantity.multiply(rate.getValue())); + freeValue = freeValue.add(freeQuantity.multiply(rate.getValue())); + + rowsForAdd.add(row); + } catch (Exception e) { + log.error("Error with currency (currency_id = %s), skipped".formatted(rate.getCurrencyId()), e); + } + } + + for (KSRepLccValueReport row : rowsForAdd) { + row.setLockValue(lockValue); + row.setFreeValue(freeValue); + } + rows.addAll(rowsForAdd); + + } catch (Exception e) { + log.error("Error with group (tkr = %s), skipped".formatted(entryTKR.getKey()), e); + } + } + + } + + private Rates getRate(String securitySymbol, Map currencyRates) { + Rates currencyRate = currencyRates.get(securitySymbol); + if (currencyRate == null) { + ImdgPredicateBuilder ratesPB = ratesImdg.predicateBuilder(); + Collection rates = ratesImdg.getCollectionObjectsByPredicate( + ratesPB.and( + ratesPB.equals("currency", securitySymbol), + ratesPB.notNull("value"), + ratesPB.equals("valueDate", LocalDate.now()) + ) + ); + if (!rates.isEmpty()) { + currencyRate = rates.iterator().next(); + } else { + currencyRate = new Rates(); + currencyRate.setValue(BigDecimal.ONE); + } + currencyRates.put(securitySymbol, currencyRate); + } + return currencyRate; } } diff --git a/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/config/validation/ValidationConfig.java b/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/config/validation/ValidationConfig.java index 1e42cb2b3..7f7d3981b 100644 --- a/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/config/validation/ValidationConfig.java +++ b/clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/config/validation/ValidationConfig.java @@ -65,6 +65,7 @@ public class ValidationConfig { ReportBuilderType.KS_COMMISSION_TRADES, ReportBuilderType.KS_REP_LCC_TRADES, ReportBuilderType.KS_REP_LCC_NETTO, + ReportBuilderType.KS_REP_LCC_VALUE, }, ReportError.WrongFieldValue, ReportError.RequiredFieldEmpty) diff --git a/clearing-parent/reports-service/src/test/java/ru/spcex/clearing/reports/services/ReportServiceTest_KS.java b/clearing-parent/reports-service/src/test/java/ru/spcex/clearing/reports/services/ReportServiceTest_KS.java index 3910e0984..9664c9462 100644 --- a/clearing-parent/reports-service/src/test/java/ru/spcex/clearing/reports/services/ReportServiceTest_KS.java +++ b/clearing-parent/reports-service/src/test/java/ru/spcex/clearing/reports/services/ReportServiceTest_KS.java @@ -57,6 +57,8 @@ import ru.clearing.classes.statics.data.profile.ProfileDocument; import ru.clearing.classes.statics.data.registry.Registry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.classes.statics.data.security.CurrencyPairSecurity; +import ru.clearing.classes.statics.data.security.Rates; +import ru.clearing.classes.statics.data.security.RiskParameter; import ru.clearing.classes.statics.data.statement.Statement; import ru.clearing.platform.dictionary.CurrencyPairDictionary; import ru.clearing.platform.dictionary.RegistryCodeDictionary; @@ -130,6 +132,8 @@ public class ReportServiceTest_KS { private Imdg clearingMemberCategoryImdg; private Imdg currencyPairSecurityImdg; private Imdg currencyPairDictionaryImdg; + private Imdg riskParameterImdg; + private Imdg ratesImdg; private Long COMPANY_ID; @Autowired @@ -1634,6 +1638,221 @@ public class ReportServiceTest_KS { registryImdg.delete(registry_OMT_2_nextDay); } + @Test + @Order(14) + public void createReportTest_KSRepLccValueReport() throws Exception { + CurrencyPairDictionary currencyPairDictionary_rub = new CurrencyPairDictionary(); + currencyPairDictionary_rub.setBaseCurrency("RUB"); + Long currPairRubId = currencyPairDictionaryImdg.insert(currencyPairDictionary_rub); + Long currRubId = 1L; + + RiskParameter riskParameter_rub = new RiskParameter(); + riskParameter_rub.setValue(BigDecimal.valueOf(0.8)); + riskParameter_rub.setCurrencyPairId(currPairRubId); + riskParameter_rub.setSettlementType("T1"); + riskParameterImdg.insert(riskParameter_rub); + + Rates rates_rub = new Rates(); + rates_rub.setCurrency("RUB"); + rates_rub.setValue(BigDecimal.ONE); + rates_rub.setCurrencyId(currRubId); + rates_rub.setValueDate(LocalDate.now()); + ratesImdg.insert(rates_rub); + + Registry amf_1_rub = new Registry(); + amf_1_rub.setTradingClearingRegistry("tkr"); + amf_1_rub.setTradingClearingRegistryId(7L); + amf_1_rub.setSecuritySymbol("RUB"); + amf_1_rub.setSecurityId(currRubId); + amf_1_rub.setRegistryDesignation(RegistryDesignation.A.getKey()); + amf_1_rub.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + amf_1_rub.setRegistryUnit(RegistryUnit.F.getKey()); + amf_1_rub.setRegistryStatus(RegistryStatus.OK.getKey()); + amf_1_rub.setBalance(BigDecimal.valueOf(100)); + registryImdg.insert(amf_1_rub); + + Registry tmt_1_rub = new Registry(); + tmt_1_rub.setTradingClearingRegistry("tkr"); + tmt_1_rub.setTradingClearingRegistryId(7L); + tmt_1_rub.setSecuritySymbol("RUB"); + tmt_1_rub.setSecurityId(currRubId); + tmt_1_rub.setRegistryDesignation(RegistryDesignation.T.getKey()); + tmt_1_rub.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + tmt_1_rub.setRegistryUnit(RegistryUnit.T.getKey()); + tmt_1_rub.setRegistryStatus(RegistryStatus.MNG.getKey()); + tmt_1_rub.setBalance(BigDecimal.valueOf(10000)); + registryImdg.insert(tmt_1_rub); + + Registry omt_1_rub = new Registry(); + omt_1_rub.setTradingClearingRegistry("tkr"); + omt_1_rub.setTradingClearingRegistryId(7L); + omt_1_rub.setSecuritySymbol("RUB"); + omt_1_rub.setSecurityId(currRubId); + omt_1_rub.setRegistryDesignation(RegistryDesignation.O.getKey()); + omt_1_rub.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + omt_1_rub.setRegistryUnit(RegistryUnit.T.getKey()); + omt_1_rub.setRegistryStatus(RegistryStatus.PROC.getKey()); + omt_1_rub.setBalance(BigDecimal.valueOf(1000)); + registryImdg.insert(omt_1_rub); + + Registry amf_2_rub = new Registry(); + amf_2_rub.setTradingClearingRegistry("tkr"); + amf_2_rub.setTradingClearingRegistryId(7L); + amf_2_rub.setSecuritySymbol("RUB"); + amf_2_rub.setSecurityId(currRubId); + amf_2_rub.setRegistryDesignation(RegistryDesignation.A.getKey()); + amf_2_rub.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + amf_2_rub.setRegistryUnit(RegistryUnit.F.getKey()); + amf_2_rub.setRegistryStatus(RegistryStatus.OK.getKey()); + amf_2_rub.setBalance(BigDecimal.valueOf(200)); + registryImdg.insert(amf_2_rub); + + Registry tmt_2_rub = new Registry(); + tmt_2_rub.setTradingClearingRegistry("tkr"); + tmt_2_rub.setTradingClearingRegistryId(7L); + tmt_2_rub.setSecuritySymbol("RUB"); + tmt_2_rub.setSecurityId(currRubId); + tmt_2_rub.setRegistryDesignation(RegistryDesignation.T.getKey()); + tmt_2_rub.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + tmt_2_rub.setRegistryUnit(RegistryUnit.T.getKey()); + tmt_2_rub.setRegistryStatus(RegistryStatus.MNG.getKey()); + tmt_2_rub.setBalance(BigDecimal.valueOf(20000)); + registryImdg.insert(tmt_2_rub); + + Registry omt_2_rub = new Registry(); + omt_2_rub.setTradingClearingRegistry("tkr"); + omt_2_rub.setTradingClearingRegistryId(7L); + omt_2_rub.setSecuritySymbol("RUB"); + omt_2_rub.setSecurityId(currRubId); + omt_2_rub.setRegistryDesignation(RegistryDesignation.O.getKey()); + omt_2_rub.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + omt_2_rub.setRegistryUnit(RegistryUnit.T.getKey()); + omt_2_rub.setRegistryStatus(RegistryStatus.PROC.getKey()); + omt_2_rub.setBalance(BigDecimal.valueOf(2000)); + registryImdg.insert(omt_2_rub); + + + CurrencyPairDictionary currencyPairDictionary_eur = new CurrencyPairDictionary(); + currencyPairDictionary_eur.setBaseCurrency("EUR"); + Long currPairEurId = currencyPairDictionaryImdg.insert(currencyPairDictionary_eur); + Long currEurId = 2L; + + RiskParameter riskParameter_eur = new RiskParameter(); + riskParameter_eur.setValue(BigDecimal.valueOf(0.9)); + riskParameter_eur.setCurrencyPairId(currPairEurId); + riskParameter_eur.setSettlementType("T1"); + riskParameterImdg.insert(riskParameter_eur); + + Rates rates_eur = new Rates(); + rates_eur.setCurrency("EUR"); + rates_eur.setValue(BigDecimal.valueOf(100)); + rates_eur.setCurrencyId(currEurId); + rates_eur.setValueDate(LocalDate.now()); + ratesImdg.insert(rates_eur); + + Registry amf_1_eur = new Registry(); + amf_1_eur.setTradingClearingRegistry("tkr"); + amf_1_eur.setTradingClearingRegistryId(7L); + amf_1_eur.setSecuritySymbol("EUR"); + amf_1_eur.setSecurityId(currEurId); + amf_1_eur.setRegistryDesignation(RegistryDesignation.A.getKey()); + amf_1_eur.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + amf_1_eur.setRegistryUnit(RegistryUnit.F.getKey()); + amf_1_eur.setRegistryStatus(RegistryStatus.OK.getKey()); + amf_1_eur.setBalance(BigDecimal.valueOf(100)); + registryImdg.insert(amf_1_eur); + + Registry tmt_1_eur = new Registry(); + tmt_1_eur.setTradingClearingRegistry("tkr"); + tmt_1_eur.setTradingClearingRegistryId(7L); + tmt_1_eur.setSecuritySymbol("EUR"); + tmt_1_eur.setSecurityId(currEurId); + tmt_1_eur.setRegistryDesignation(RegistryDesignation.T.getKey()); + tmt_1_eur.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + tmt_1_eur.setRegistryUnit(RegistryUnit.T.getKey()); + tmt_1_eur.setRegistryStatus(RegistryStatus.MNG.getKey()); + tmt_1_eur.setBalance(BigDecimal.valueOf(10000)); + registryImdg.insert(tmt_1_eur); + + Registry omt_1_eur = new Registry(); + omt_1_eur.setTradingClearingRegistry("tkr"); + omt_1_eur.setTradingClearingRegistryId(7L); + omt_1_eur.setSecuritySymbol("EUR"); + omt_1_eur.setSecurityId(currEurId); + omt_1_eur.setRegistryDesignation(RegistryDesignation.O.getKey()); + omt_1_eur.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + omt_1_eur.setRegistryUnit(RegistryUnit.T.getKey()); + omt_1_eur.setRegistryStatus(RegistryStatus.PROC.getKey()); + omt_1_eur.setBalance(BigDecimal.valueOf(1000)); + registryImdg.insert(omt_1_eur); + + Registry amf_2_eur = new Registry(); + amf_2_eur.setTradingClearingRegistry("tkr"); + amf_2_eur.setTradingClearingRegistryId(7L); + amf_2_eur.setSecuritySymbol("EUR"); + amf_2_eur.setSecurityId(currEurId); + amf_2_eur.setRegistryDesignation(RegistryDesignation.A.getKey()); + amf_2_eur.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + amf_2_eur.setRegistryUnit(RegistryUnit.F.getKey()); + amf_2_eur.setRegistryStatus(RegistryStatus.OK.getKey()); + amf_2_eur.setBalance(BigDecimal.valueOf(200)); + registryImdg.insert(amf_2_eur); + + Registry tmt_2_eur = new Registry(); + tmt_2_eur.setTradingClearingRegistry("tkr"); + tmt_2_eur.setTradingClearingRegistryId(7L); + tmt_2_eur.setSecuritySymbol("EUR"); + tmt_2_eur.setSecurityId(currEurId); + tmt_2_eur.setRegistryDesignation(RegistryDesignation.T.getKey()); + tmt_2_eur.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + tmt_2_eur.setRegistryUnit(RegistryUnit.T.getKey()); + tmt_2_eur.setRegistryStatus(RegistryStatus.MNG.getKey()); + tmt_2_eur.setBalance(BigDecimal.valueOf(20000)); + registryImdg.insert(tmt_2_eur); + + Registry omt_2_eur = new Registry(); + omt_2_eur.setTradingClearingRegistry("tkr"); + omt_2_eur.setTradingClearingRegistryId(7L); + omt_2_eur.setSecuritySymbol("EUR"); + omt_2_eur.setSecurityId(currEurId); + omt_2_eur.setRegistryDesignation(RegistryDesignation.O.getKey()); + omt_2_eur.setRegistryInstrumentType(RegistryInstrumentType.M.getKey()); + omt_2_eur.setRegistryUnit(RegistryUnit.T.getKey()); + omt_2_eur.setRegistryStatus(RegistryStatus.PROC.getKey()); + omt_2_eur.setBalance(BigDecimal.valueOf(2000)); + registryImdg.insert(omt_2_eur); + + + ReportRequest reportRequest = new ReportRequest(); + reportRequest.setReportId(ReportBuilderType.KS_REP_LCC_VALUE.getKey()); + String jsonString = TestUtils.getJsonStringForSystem(reportRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) reportService.getConsumer(), + Consts.CREATE_REPORT, + reportRequestCnt++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + File outFile = outFolder.listFiles()[0]; + File expectedFile = new File(getClass().getClassLoader().getResource("expected_reports_csv/ks/KS_REP_LCC_VALUE_REPORT_expected.csv").getFile()); + compareCSVFiles(expectedFile, outFile, Arrays.asList("REPORT_DATE")); + + registryImdg.delete(amf_1_rub); + registryImdg.delete(amf_2_rub); + registryImdg.delete(amf_1_eur); + registryImdg.delete(amf_2_eur); + registryImdg.delete(tmt_1_rub); + registryImdg.delete(tmt_2_rub); + registryImdg.delete(tmt_1_eur); + registryImdg.delete(tmt_2_eur); + registryImdg.delete(omt_1_rub); + registryImdg.delete(omt_2_rub); + registryImdg.delete(omt_1_eur); + registryImdg.delete(omt_2_eur); + } + private void compareCSVFiles(File expectedFile, File actualFile, List columnsForSkip) throws IOException, CsvValidationException { if (columnsForSkip == null) columnsForSkip = Collections.emptyList(); @@ -1746,6 +1965,8 @@ public class ReportServiceTest_KS { clearingMemberCategoryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class); currencyPairSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class); currencyPairDictionaryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class); + riskParameterImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_RiskParameter, RiskParameter.class); + ratesImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Rates, Rates.class); } private void clearTestDir() throws IOException { diff --git a/clearing-parent/reports-service/src/test/resources/expected_reports_csv/ks/KS_REP_LCC_VALUE_REPORT_expected.csv b/clearing-parent/reports-service/src/test/resources/expected_reports_csv/ks/KS_REP_LCC_VALUE_REPORT_expected.csv new file mode 100644 index 000000000..fa8628741 --- /dev/null +++ b/clearing-parent/reports-service/src/test/resources/expected_reports_csv/ks/KS_REP_LCC_VALUE_REPORT_expected.csv @@ -0,0 +1,3 @@ +"FIRM_ID","REPORT_DATE","TKR","SUM_VALUE","LOCK_VALUE","FREE_VALUE","SINGLE_LIMIT","CURRENCY","NCC_REAL_ACCOUNT","QUANTITY","LOCK_QUANTITY","FREE_QUANTITY","VALUE" +,"03.12.2024T13:28:26","tkr","30300.00","30300.00","0.00","278460.00","EUR",,"300.00","300.00","0.00","30000" +,"03.12.2024T13:28:26","tkr","30300.00","30300.00","0.00","278460.00","RUB",,"300.00","300.00","0.00","300"