treshenkov/clearing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ANLT & TCR search

Browse source
This commit is contained in:
ialbert 2024-04-22 17:10:41 +03:00
parent e58a19a511
commit e8fda5a8f8
8 changed files with 252 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/ValidationConfig.java
View file

@ -21,6 +21,7 @@ import ru.clearing.classes.statics.data.misc.Session;
import ru.clearing.classes.statics.data.payment.PaymentInstruction;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
import ru.clearing.classes.statics.data.sdf.SDf01;
import ru.clearing.classes.statics.data.sdf.SDf06;
import ru.clearing.classes.statics.data.sdf.SDf08;
@ -103,6 +104,7 @@ public class ValidationConfig {
Imdg<Security> imdgSecurity;
Imdg<MoneyMarketSecurity> imdgMoneyMarketSecurity;
Imdg<TradingClearingRegistry> imdgTradingClearingRegistry;
Imdg<TradingClearingRegistryList> imdgTradingClearingRegistryList;
Imdg<Session> imdgSession;
Imdg<SectionDictionary> imdgSectionDictionary;
Imdg<Statement> imdgStatement;
@ -124,6 +126,8 @@ public class ValidationConfig {
this.imdgAccountBalance = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
this.imdgSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
this.imdgTradingClearingRegistry = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
this.imdgTradingClearingRegistryList
= imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
this.imdgSession = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
this.imdgSectionDictionary = imdgProvider.getImdg(IMDGDistributedNames.Map_SectionDictionary, SectionDictionary.class);
this.imdgMoneyMarketSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
@ -350,6 +354,7 @@ public class ValidationConfig {
context.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
context.addImdg(IMDGDistributedNames.Map_Session, imdgSession);
context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, imdgTradingClearingRegistryList);
context.addImdg(IMDGDistributedNames.Map_Currency, imdgCurrency);
context.setLogPrefix(LogPrefixId.INSTANCE);
return new ValidatorImpl<>(context,

95
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/AnltSearcher.java
View file

@ -1,5 +1,7 @@
package ru.spcex.clearing.service;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@ -7,9 +9,11 @@ import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.CurrencyCode;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
@ -19,25 +23,25 @@ import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IEnumId;
import ru.spcex.platform.utils.text.TextUtil;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@Component
public class AnltSearcher {
private Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
private final Imdg<Company> companyImdg;
private final Imdg<Account> accountImdg;
private Imdg<TradingClearingRegistryList> tcrListImdg;
@Autowired
public AnltSearcher(ImdgProvider imdgProvider) {
this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
this.tcrListImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
}
public AnltSearcher(Imdg<TradingClearingRegistry> tcrImdg, Imdg<Company> companyImdg, Imdg<Account> accountImdg) {
public AnltSearcher(Imdg<TradingClearingRegistry> tcrImdg, Imdg<TradingClearingRegistryList> tcrListImdg, Imdg<Company> companyImdg, Imdg<Account> accountImdg) {
this.tradingClearingRegistryImdg = tcrImdg;
this.tcrListImdg = tcrListImdg;
this.companyImdg = companyImdg;
this.accountImdg = accountImdg;
}
@ -47,33 +51,58 @@ public class AnltSearcher {
void log(IEnumId subject, Object... args);
}
public AnltSearch loadByAnlt(String comment) {
return loadByAnlt(comment, CurrencyCode.RUB.getKey());
}
public AnltSearch loadByAnlt(String comment, String currencyCode) {
String commentTcrStripped = getTkrCodeFromComment(comment);
// AnltLogger localLogger = (subject, args) -> log.debug("stmt.id={} comment='{}' error: {}", statementId, commentTcrStripped, messageResolver.resolve(new EnumMessage(subject, args)));
if (commentTcrStripped == null) {
return new AnltSearch(ClearingError.AccountNotFound, "comment not contain TCR");
}
ImdgPredicateBuilder pb = tradingClearingRegistryImdg.predicateBuilder();
ImdgPredicate tcrPredicate = pb.and(
pb.equals("code", commentTcrStripped),
pb.or(
pb.equals("status", ServiceStatus.Active.getKey()),
pb.equals("status", ServiceStatus.Reopened.getKey())
)
ImdgPredicate statusPrdct = pb.or(
pb.equals("status", ServiceStatus.Active.getKey()),
pb.equals("status", ServiceStatus.Reopened.getKey())
);
ImdgPredicate tcrPredicate = pb.and(
pb.equals("code", commentTcrStripped),
statusPrdct
);
TradingClearingRegistryList tcrList = null;
TradingClearingRegistry tcr = tradingClearingRegistryImdg.getSingleObjectByPredicate(tcrPredicate);
if (tcr == null) {
return new AnltSearch(ClearingError.TCRegistryNotFound, commentTcrStripped);
}
if (tcr.getMoneyAccountId() == null) {
return new AnltSearch(ClearingError.WrongField, "moneyAccountId");
Account infoAcc = null;
if (CurrencyCode.isRub(currencyCode)) {
if (tcr.getMoneyAccountId() == null) {
return new AnltSearch(ClearingError.WrongField, "moneyAccountId");
}
infoAcc = accountImdg.getSingleObjectByID(tcr.getMoneyAccountId());
} else {
tcrList = tcrListImdg.getSingleObjectByPredicate(
pb.and(
pb.equals("currency", currencyCode),
pb.equals("tradingClearingRegistryId", tcr.getId()),
statusPrdct
)
);
if (tcrList == null) {
return new AnltSearch(ClearingError.TCRegistryNotFound, "<by commend=%s and currency=%s>"
.formatted(comment, currencyCode));
}
infoAcc = accountImdg.getSingleObjectByID(tcrList.getAccountId());
}
Account infoAcc = accountImdg.getSingleObjectByID(tcr.getMoneyAccountId());
if (infoAcc == null) {
return new AnltSearch(ClearingError.AccountNotFound, "moneyAccountId");
return new AnltSearch(ClearingError.AccountNotFoundB,
"<for tcr.id=%d/moneyAccountId=%d> currency %s".formatted(
tcr.getId(), tcr.getMoneyAccountId(), currencyCode
));
}
if (!infoAcc.getAccountType().equals(AccountType.Info.getKey())) {
@ -84,7 +113,7 @@ public class AnltSearcher {
if (company == null) {
return new AnltSearch(ClearingError.CompanyNotFoundB, tcr.getCompanyId());
}
return new AnltSearch(infoAcc, company, tcr);
return new AnltSearch(infoAcc, company, tcr, tcrList, currencyCode);
}
private static final Pattern tcrPattern = Pattern.compile("ТКР.*?([0-9A-Z-]{12})");
@ -107,15 +136,33 @@ public class AnltSearcher {
private Account account;
private Company company;
private TradingClearingRegistry tcr;
private TradingClearingRegistryList tcrList;
private String currency;
public AnltSearch(IEnumId errSubject, Object... args) {
this.error = new EnumMessage(errSubject, args);
}
public AnltSearch() {
}
public AnltSearch(Account account, Company company, TradingClearingRegistry tcr) {
this.account = account;
this.company = company;
this.tcr = tcr;
this.currency = CurrencyCode.RUB.getKey();
}
public AnltSearch(Account account,
Company company,
TradingClearingRegistry tcr,
TradingClearingRegistryList tcrList,
String currency) {
this.account = account;
this.company = company;
this.tcr = tcr;
this.tcrList = tcrList;
this.currency = CurrencyCode.RUB.getKey();
}
public boolean isFound() {
@ -153,5 +200,21 @@ public class AnltSearcher {
public void setTcr(TradingClearingRegistry tcr) {
this.tcr = tcr;
}
public TradingClearingRegistryList getTcrList() {
return tcrList;
}
public void setTcrList(TradingClearingRegistryList tcrList) {
this.tcrList = tcrList;
}
public String getCurrency() {
return currency;
}
public void setCurrency(String currency) {
this.currency = currency;
}
}
}

99
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/TcrSearcher.java Normal file
View file

@ -0,0 +1,99 @@
package ru.spcex.clearing.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.CurrencyCode;
import ru.spcex.platform.enumeration.ServiceStatus;
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;
@Component
public class TcrSearcher {
private Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<TradingClearingRegistry> tcrImdg;
private final Imdg<TradingClearingRegistryList> tcrListImdg;
private final Imdg<Company> companyImdg;
private final Imdg<Account> accountImdg;
@Autowired
public TcrSearcher(ImdgProvider imdgProvider) {
this.tcrImdg = imdgProvider.getImdg(
IMDGDistributedNames.Map_TradingClearingRegistry,
TradingClearingRegistry.class);
this.tcrListImdg = imdgProvider.getImdg(
IMDGDistributedNames.Map_TradingClearingRegistryList,
TradingClearingRegistryList.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
}
public TcrSearcher(Imdg<TradingClearingRegistry> tcrImdg,
Imdg<TradingClearingRegistryList> tcrListImdg,
Imdg<Company> companyImdg,
Imdg<Account> accountImdg) {
this.tcrImdg = tcrImdg;
this.tcrListImdg = tcrListImdg;
this.companyImdg = companyImdg;
this.accountImdg = accountImdg;
}
public AnltSearcher.AnltSearch loadByCurrencyAccountId(Long accountId, String currency) {
AnltSearcher.AnltSearch srchRes = new AnltSearcher.AnltSearch();
ImdgPredicateBuilder pb = tcrImdg.predicateBuilder();
ImdgPredicate sttsPrdct = pb.or(
pb.equals("status", ServiceStatus.Active.getKey()),
pb.equals("status", ServiceStatus.Reopened.getKey())
);
//fixme BASED ON CURRENCY
TradingClearingRegistry tcr = tcrImdg.getSingleObjectByPredicate(
pb.and(
pb.equals("moneyAccountId", accountId),
sttsPrdct
)
);
if (tcr != null) {
srchRes.setCurrency(CurrencyCode.RUB.getKey());
} else {
TradingClearingRegistryList tcrList = tcrListImdg.getSingleObjectByPredicate(
pb.and(
pb.equals("accountId", accountId),
sttsPrdct
)
);
if (tcrList == null) {
return new AnltSearcher.AnltSearch(ClearingError.TCRegistryNotFound, "<by accountId=%s".formatted(accountId));
}
tcr = tcrImdg.getSingleObjectByID(tcrList.getTradingClearingRegistryId());
if (tcr == null) {
return new AnltSearcher.AnltSearch(ClearingError.TCRegistryNotFound, "<by accountId=%s".formatted(accountId));
}
srchRes.setCurrency(tcrList.getCurrency());
srchRes.setTcrList(tcrList);
}
srchRes.setTcr(tcr);
Account acc = accountImdg.getSingleObjectByID(accountId);
if (acc == null) {
return new AnltSearcher.AnltSearch(ClearingError.AccountNotFoundB, accountId);
}
Company cmp = companyImdg.getSingleObjectByID(acc.getCompanyId());
if (cmp == null) {
return new AnltSearcher.AnltSearch(ClearingError.CompanyNotFoundB, acc.getCompanyId());
}
srchRes.setAccount(acc);
srchRes.setCompany(cmp);
return srchRes;
}
}

43
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistryBuilder.java
View file

@ -1,5 +1,9 @@
package ru.spcex.clearing.service.builder;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Map;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.account.ClearingAccount;
import ru.clearing.classes.statics.data.company.Company;
@ -13,18 +17,19 @@ import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
import ru.clearing.classes.statics.data.security.Security;
import ru.clearing.classes.statics.data.statement.Statement;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.service.AnltSearcher;
import ru.spcex.clearing.service.TcrSearcher;
import ru.spcex.clearing.session.stage.util.RegistryUtil;
import ru.spcex.platform.enumeration.*;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.RegistryCapacity;
import ru.spcex.platform.enumeration.RegistryDesignation;
import ru.spcex.platform.enumeration.RegistryInstrumentType;
import ru.spcex.platform.enumeration.RegistryStatus;
import ru.spcex.platform.enumeration.RegistryUnit;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Collection;
import java.util.Map;
public class RegistryBuilder {
private Statement statement;
private Company company;
@ -40,6 +45,8 @@ public class RegistryBuilder {
private final Imdg<EquitySecurity> equitySecurityImdg;
private final Imdg<CurrencyPairSecurity> currencyPairSecurityImdg;
private final Imdg<Currency> currencyImdg;
private final TcrSearcher tcrSrcher;
private String currency;
public static RegistryBuilder builder(ImdgProvider imdgProvider) {
@ -56,6 +63,7 @@ public class RegistryBuilder {
this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
this.currencyPairSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class);
this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
this.tcrSrcher = new TcrSearcher(imdgProvider);
}
public RegistryBuilder statement(Statement statement) {
@ -73,6 +81,11 @@ public class RegistryBuilder {
return this;
}
public RegistryBuilder loadTcrForCurrency(String currency) {
this.currency = currency;
return this;
}
public RegistryBuilder designation(RegistryDesignation designation) {
this.designation = designation;
return this;
@ -103,15 +116,13 @@ public class RegistryBuilder {
rgs.setRegistryUnit(RegistryUnit.T.getKey());
rgs.setRegistryCode(RegistryUtil.clearingCode(rgs));
Collection<TradingClearingRegistry> tcrsByAccount = tradingClearingRegistryImdg.getCollectionObjectsByFieldValues(Map.of(
"moneyAccountId", account.getId(),
"companyId", company.getId(),
"status", ServiceStatus.Active.getKey()
));
if (!tcrsByAccount.isEmpty()) {
TradingClearingRegistry tcr = tcrsByAccount.iterator().next();
rgs.setTradingClearingRegistryId(tcr.getId());
rgs.setTradingClearingRegistry(tcr.getCode());
if (currency != null) {
AnltSearcher.AnltSearch anltSearch = tcrSrcher.loadByCurrencyAccountId(account.getId(), currency);
if (anltSearch.isFound()) {
TradingClearingRegistry tcr = anltSearch.getTcr();
rgs.setTradingClearingRegistryId(tcr.getId());
rgs.setTradingClearingRegistry(tcr.getCode());
}
}
rgs.setRegistryStatus(RegistryStatus.PROC.getKey());

1
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf01Executor.java
View file

@ -180,6 +180,7 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
.company(company)
.account(account)
.designation(RegistryDesignation.A)
.loadTcrForCurrency(sdf01.getCurr_code())
.build();
calcBalance(rgs, stmt);
Registry registryB = copyRegB(rgs);

5
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf06Executor.java
View file

@ -40,7 +40,6 @@ import ru.spcex.clearing.service.schedule.TradingTimeService;
import ru.spcex.clearing.service.validation.Sdf06NewValidationRule;
import ru.spcex.clearing.service.validation.ValidationStored;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.CurrencyCode;
import ru.spcex.platform.enumeration.InOutDirection;
import ru.spcex.platform.enumeration.InOutSDfType;
import ru.spcex.platform.enumeration.OperationStatus;
@ -173,7 +172,7 @@ public class Sdf06Executor {
processedApproved(stmt, sDf06, now, sdf07GroupId);
if (tcr != null) {
dmiService.setProcContract(tcr.getId(),
CurrencyCode.RUB.getKey(), //fixme???
sDf06.getPay_val(),
safeBD(sDf06.getSum()),
sDf06.getNumber().toString());
Optional<AssetTrio> asts = assets.searchMoneyByAccAndCompany(company.getId(), tcr.getMoneyAccountId());
@ -286,7 +285,7 @@ public class Sdf06Executor {
processedApproved(stmt, sdf06, updatedTime);
Optional<TradingClearingRegistry> tcr = searchTcrOnGatewayResponse(sdf06);
dmiService.setProcContract(tcr.map(SpcexObjectBase::getId).orElse(null),
CurrencyCode.RUB.getKey(), //fixme???
sdf06.getPay_val(),
safeBD(sdf06.getSum()),
sdf06.getNumber().toString()
);

3
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java
View file

@ -278,6 +278,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
.statement(stmt)
.company(company)
.account(account)
.loadTcrForCurrency(sdf57.getPay_val())
.designation(RegistryDesignation.A)
.build();
calcBalance(registry, stmt, sdf57);
@ -418,7 +419,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
Account acc = stmtCmpAcc.account();
Optional<AssetTrio> asts = createRegistryIfNeeded.apply(stmtCmpAcc);
if (accountIsAnlt(acc)) {
AnltSearcher.AnltSearch searchResult = anltSearcher.loadByAnlt(stmt.getComment());
AnltSearcher.AnltSearch searchResult = anltSearcher.loadByAnlt(stmt.getComment(), sdf57.getPay_val());
if (searchResult.isFound()) {
log.debug("stmt.id={} comment={} is anlt, loaded account.id={}/companyId={}",
stmt.getId(),

69
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf06NewValidationRule.java
View file

@ -1,35 +1,39 @@
package ru.spcex.clearing.service.validation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.misc.Session;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.classes.statics.data.sdf.SDf06;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.service.AnltSearcher;
import ru.spcex.platform.enumeration.*;
import ru.spcex.platform.imdg.api.Imdg;
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.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.number.BigDecimalUtil;
import ru.spcex.platform.utils.text.TextUtil;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.misc.Session;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
import ru.clearing.classes.statics.data.sdf.SDf06;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.service.AnltSearcher;
import ru.spcex.clearing.service.TcrSearcher;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.InOutDirection;
import ru.spcex.platform.enumeration.RegistryStatus;
import ru.spcex.platform.enumeration.RegistryTradingParams;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
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.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.number.BigDecimalUtil;
import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
import ru.spcex.platform.utils.text.TextUtil;
import ru.spcex.platform.utils.validation.IValidationRule;
public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationContext<SDf06>> {
Fields() {
@ -165,7 +169,9 @@ public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationCont
dir = (InOutDirection.out);
}
Imdg<TradingClearingRegistry> tcrImdg;
Imdg<TradingClearingRegistryList> tcrListImdg;
tcrImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
tcrListImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
//если направление in то ТКР необязателен
Function<Optional<EnumMessage>, Optional<EnumMessage>> err = msg -> {
if (dir.equals(InOutDirection.in)) {
@ -177,16 +183,16 @@ public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationCont
}
};
AnltSearcher.AnltSearch anltSrch;
Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
if (AccountType.Anlt.getKey().equals(account.getAccountType())) {
log.debug("account.id={} is ANLT", account.getId());
if (TextUtil.isEmpty(sdf06.getSpec())) {
log.debug("ANLT couldn't find by account.id={} spec empty", account.getId());
return err.apply(of(ClearingError.TCRegistryNotFound, "<spec empty>"));
}
Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
AnltSearcher anltSearcher = new AnltSearcher(tcrImdg, companyImdg, accountImdg);
anltSrch = anltSearcher.loadByAnlt(sdf06.getSpec());
AnltSearcher anltSearcher = new AnltSearcher(tcrImdg, tcrListImdg, companyImdg, accountImdg);
anltSrch = anltSearcher.loadByAnlt(sdf06.getSpec(), sdf06.getPay_val());
if (!anltSrch.isFound()) {
log.debug("ANLT couldn't find by account.id={} by spec {}", account.getId(), sdf06.getSpec());
return err.apply(of(ClearingError.TCRegistryNotFound, sdf06.getSpec()));
@ -200,11 +206,10 @@ public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationCont
return empty();
}
} else {
TradingClearingRegistry tcr = tcrImdg.getFirstObjectByFieldValues(
Map.of("moneyAccountId", account.getId())
);
if (tcr != null) {
context.storeObject(ValidationStored.Sdf06Tcr, tcr);
TcrSearcher tcrSearcher = new TcrSearcher(tcrImdg, tcrListImdg, companyImdg, accountImdg);
AnltSearcher.AnltSearch anltSearch = tcrSearcher.loadByCurrencyAccountId(account.getId(), sdf06.getPay_val());
if (anltSearch.isFound()) {
context.storeObject(ValidationStored.Sdf06Tcr, anltSearch.getTcr());
return empty();
} else {
log.debug("couldn't find TCR by account.id={} accountType {}",