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

currency: sdf06/sdf55/sdf57/identification funds/outbound payment

Browse source
This commit is contained in:
ialbert 2024-05-06 14:54:41 +03:00
parent 662d083b9c
commit d636a6b0ce
12 changed files with 120 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -46,6 +46,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistryChangeRe
import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistryChangeStatusExtractRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistryReturnDepositRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistrySplitDepositActionRequest;
import ru.spcex.clearing.service.validation.AnltAccLoad;
import ru.spcex.clearing.service.validation.ClrngValidationStored;
import ru.spcex.clearing.service.validation.CompanyByTradingCodeValidationRule;
import ru.spcex.clearing.service.validation.CurrencyCodeValidationRule;
@ -79,7 +80,6 @@ import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.imdg.validation.LogPrefixId;
import ru.spcex.platform.imdg.validation.rule.AnltAccLoad;
import ru.spcex.platform.imdg.validation.rule.PresentById;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.validation.IValidator;
@ -458,6 +458,7 @@ public class ValidationConfig {
context.setValidatedObject(identificationFundsRequest);
context.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, imdgTradingClearingRegistryList);
context.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
context.setLogPrefix(LogPrefixId.INSTANCE);
@ -556,6 +557,7 @@ public class ValidationConfig {
ImdgValidationContext<StatementRequest> ctx = new ImdgValidationContext<>();
ctx.setValidatedObject(req);
ctx.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
ctx.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
ctx.addImdg(IMDGDistributedNames.Map_SDf55, sDf55Imdg);
ctx.addImdg(IMDGDistributedNames.Map_SDf54, sDf54Imdg);
ctx.addImdg(IMDGDistributedNames.Map_PaymentInstruction, pmtImdg);

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

@ -685,6 +685,7 @@ public class RegistryService {
AssetOperationListRequest gatewayRequest = new AssetOperationListRequest();
AssetOperationRequest req = GatewayRequestCreator.from(
dmau.getId(),
dmau.getSecuritySymbol(),
null,
balance,
InOutDirection.in,

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

@ -53,9 +53,19 @@ public class TcrSearcher {
public Optional<Account> searchByTcr(Long tcrId, String currency) {
TradingClearingRegistry tcr = tcrImdg.getSingleObjectByID(tcrId);
if (tcr == null || (CurrencyCode.RUB.equalsByKey(currency) && tcr.getMoneyAccountId() == null)) {
if (tcr == null) {
log.warn("couldn't find account by tcr#id={}; currency {}. TCR {}",
tcrId, currency, tcr != null ? "found" : "not found");
tcrId, currency, "not found");
return Optional.empty();
}
return searchByTcr(tcr, currency);
}
public Optional<Account> searchByTcr(TradingClearingRegistry tcr, String currency) {
Long tcrId = tcr.getId();
if ((CurrencyCode.RUB.equalsByKey(currency) && tcr.getMoneyAccountId() == null)) {
log.warn("couldn't find account by tcr#id={}; currency {}. TCR#id={}",
tcrId, currency, tcr.getId());
return Optional.empty();
}
if (CurrencyCode.RUB.equalsByKey(currency)) {

9
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/PaymentInstructionBuilderV2.java
View file

@ -34,6 +34,7 @@ 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;
import ru.spcex.platform.utils.text.TextUtil;
import ru.spcex.platform.utils.time.TimeUtil;
public class PaymentInstructionBuilderV2 {
@ -189,12 +190,12 @@ public class PaymentInstructionBuilderV2 {
}
payment.setDebit_csAccount(null);
if (currency != null) {
payment.setCreditLeg_currencyCode(currency);
payment.setDebitLeg_currencyCode(currency);
} else {
if (TextUtil.isEmpty(currency)) {
payment.setCreditLeg_currencyCode(CurrencyCode.RUB.getKey());
payment.setDebitLeg_currencyCode(CurrencyCode.RUB.getKey());
} else {
payment.setCreditLeg_currencyCode(currency);
payment.setDebitLeg_currencyCode(currency);
}
payment.setTransactionStatus(TransactionStatus.stld.getKey());
payment.setDocumentNumber(nextDocumentNumber(registry, payment));

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

@ -138,6 +138,7 @@ public class Sdf06Executor {
for (SDf06 sDf06 : sdfs) {
IValidator validator = sDf06Validator.apply(sDf06);
Optional<EnumMessage> err = validator.tillFirstError();
Account account = validator.getStored(ValidationStored.Sdf06Account);
if (err.isPresent()) {
log.debug("sdf06.id={} validation error: {}", sDf06.getId(), messageResolver.resolve(err.get()));
SDf07 errorSdf07;
@ -146,7 +147,7 @@ public class Sdf06Executor {
if (needToCreateStatement(err.get())) {
stmt = createStatementBySdf06(sDf06,
((Company) validator.getStored(ValidationStored.Sdf06Company)).getId(),
validator.getStored(ValidationStored.Sdf06Account), null);
account, null);
}
errorSdf07 = createSdf07(sDf06, now, errorResult);
errorSdf07.setGenerationId(sdf07GroupId);
@ -165,7 +166,7 @@ public class Sdf06Executor {
//проверка существует ли statement пока убрал
Statement stmt = createStatementBySdf06(sDf06,
company.getId(),
validator.getStored(ValidationStored.Sdf06Account),
account,
currency.getId());
statementImdg.insert(stmt);
log.debug("Statement created: {}", stmt.getId());
@ -179,7 +180,7 @@ public class Sdf06Executor {
sDf06.getPay_val(),
safeBD(sDf06.getSum()),
sDf06.getNumber().toString());
Optional<AssetTrio> asts = assets.searchMoneyByAccAndCompany(company.getId(), tcr.getMoneyAccountId());
Optional<AssetTrio> asts = assets.searchMoneyByAccAndCompany(company.getId(), account.getId());
asts.ifPresent(ast -> assets.process(ast.a__b(), ast.a__t(), ast.a__f(), BigDecimal.ZERO));
}
sdf07WasCreated = true;

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

@ -413,6 +413,14 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
return Optional.empty();
}
};
Function<Statement, String> findCurr = (stmt) -> {
Currency currency = currencyImdg.getSingleObjectByID(stmt.getSecurityId());
if (currency == null) {
log.warn("failed to find currency for statement.id={} securityId={}", stmt.getId(), stmt.getSecurityId());
return CurrencyCode.RUB.getKey();
}
return currency.getCurrencyCode();
};
Consumer<StmtCmpAcc> registersUpdate = stmtCmpAcc -> {
Statement stmt = stmtCmpAcc.statement();
Company cmp = stmtCmpAcc.company();
@ -429,7 +437,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
asts = createRegistryIfNeeded.apply(new StmtCmpAcc(stmt, searchResult.getCompany(), searchResult.getAccount()));
if (OperationStatus.Executed.equalsByKey(stmt.getOperationStatus())) {
Optional<BigDecimal> dmiBalance = dmiService.setOk(searchResult.getTcr().getId(),
CurrencyCode.RUB.getKey(),
findCurr.apply(stmt),
sdf57.getDbfId().toString());
asts.ifPresent(trio -> {
if (dmiBalance.isPresent() && sessionIsPresent) {
@ -473,7 +481,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
} else if (OperationStatus.Executed.equalsByKey(stmt.getOperationStatus())) {
if (asts.isPresent()) {
Optional<BigDecimal> dmiBalance = dmiService.setOk(asts.get().a__t().getTradingClearingRegistryId(),
CurrencyCode.RUB.getKey(),
findCurr.apply(stmt),
sdf57.getDbfId().toString());
asts.ifPresent(trio -> {
if (dmiBalance.isPresent() && sessionIsPresent) {

16
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/integration/GatewayRequestCreator.java
View file

@ -8,6 +8,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.clearing.AssetOperationRe
import ru.spcex.platform.enumeration.CurrencyCode;
import ru.spcex.platform.enumeration.InOutDirection;
import ru.spcex.platform.utils.number.BigDecimalUtil;
import ru.spcex.platform.utils.text.TextUtil;
public class GatewayRequestCreator {
public static AssetOperationRequest from(Statement stmt,
@ -30,6 +31,7 @@ public class GatewayRequestCreator {
public static AssetOperationRequest from(Registry rgs, InOutDirection dir) {
return from(rgs.getId(),
rgs.getSecuritySymbol(),
null,
BigDecimalUtil.safeBD(rgs.getBalance()).abs(),
dir,
@ -39,6 +41,7 @@ public class GatewayRequestCreator {
public static AssetOperationRequest from(PaymentInstruction pmt, String tradingCode, String tcr) {
return from(pmt.getId(),
pmt.getCreditLeg_currencyCode(),
null,
pmt.getCreditLeg_amount(),
InOutDirection.out,
@ -52,11 +55,22 @@ public class GatewayRequestCreator {
InOutDirection direction,
String tradingCode,
String tcrCode) {
return from(entityId, (String) null, sessionId, amount, direction, tradingCode, tcrCode);
}
public static AssetOperationRequest from(Long entityId,
String currency,
Long sessionId,
BigDecimal amount,
InOutDirection direction,
String tradingCode,
String tcrCode) {
if (TextUtil.isEmpty(currency)) currency = CurrencyCode.RUB.getKey();
AssetOperationRequest req = new AssetOperationRequest();
req.setSessionId(sessionId);
req.setEntityId(entityId);
req.setAmount(amount);
req.setSecuritySymbol(CurrencyCode.RUB.getKey()); //fixme retrieve security symbol from validator
req.setSecuritySymbol(currency);
req.setTradingCode(tradingCode);
req.setCode(tcrCode);
req.setDirection(direction.getKey());

23
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/payment/PaymentInstructionOutboundService.java
View file

@ -1,5 +1,10 @@
package ru.spcex.clearing.service.payment;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Supplier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@ -33,24 +38,21 @@ import ru.spcex.clearing.service.registry.RegistryManager;
import ru.spcex.clearing.service.schedule.TradingTimeService;
import ru.spcex.clearing.service.validation.ValidationStored;
import ru.spcex.clearing.session.stage.impl.GatewayRequester;
import static ru.spcex.clearing.session.stage.impl.GatewayRequester.mapError;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.platform.enumeration.*;
import ru.spcex.platform.enumeration.CurrencyCode;
import ru.spcex.platform.enumeration.ObjectType;
import ru.spcex.platform.enumeration.Priority;
import ru.spcex.platform.enumeration.TransactionStatus;
import ru.spcex.platform.enumeration.UserRole;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IEnumId;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.validation.IValidator;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Supplier;
import static ru.spcex.clearing.session.stage.impl.GatewayRequester.mapError;
import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
import ru.spcex.platform.utils.validation.IValidator;
@Service
public class PaymentInstructionOutboundService {
@ -142,6 +144,7 @@ public class PaymentInstructionOutboundService {
.amount(amount)
.sessionId(null)
.purpose(purpose)
.currency(accCred.getCurrency())
.build();
BankAccount bnkAcc = bnkAccImdg.getFirstObjectBySQL("accountId = %d".formatted(accDeb.getId()));
if (bnkAcc != null) {

37
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/AssetTBFProcessing.java
View file

@ -1,5 +1,12 @@
package ru.spcex.clearing.service.registry;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.Collection;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@ -10,38 +17,37 @@ import ru.clearing.classes.statics.data.registry.Registry;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.service.AssetTrio;
import ru.spcex.clearing.session.stage.util.RegistryUtil;
import ru.spcex.platform.enumeration.*;
import ru.spcex.platform.enumeration.BalanceDimension;
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 static ru.spcex.platform.enumeration.RegistryTradingParams.*;
import ru.spcex.platform.enumeration.RegistryUnit;
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 java.math.BigDecimal;
import java.time.Instant;
import java.util.Collection;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import static ru.spcex.platform.enumeration.RegistryTradingParams.*;
import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
@Service
public class AssetTBFProcessing {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<Registry> rgsImdg;
private final Imdg<Account> accImdg;
private final RegistryManager rgsMng;
@Autowired
public AssetTBFProcessing(ImdgProvider imdgProvider, RegistryManager rgsMng) {
this.rgsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.accImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
this.rgsMng = rgsMng;
}
public AssetTBFProcessing(Imdg<Registry> rgsImdg) {
public AssetTBFProcessing(Imdg<Registry> rgsImdg, Imdg<Account> accImdg) {
this.rgsImdg = rgsImdg;
this.accImdg = accImdg;
this.rgsMng = new RegistryManager(rgsImdg);
}
@ -271,12 +277,17 @@ public class AssetTBFProcessing {
}
public Optional<AssetTrio> searchMoneyByAccAndCompany(Long companyId, Long accountId) {
Account account = accImdg.getSingleObjectByID(accountId);
if (account == null) {
log.error("company.id={}, account.id={} - account not found", companyId, accountId);
return Optional.empty();
}
ImdgPredicateBuilder pb = rgsImdg.predicateBuilder();
Function<RegistryTradingParams, ImdgPredicate> prdct = rgsCode -> pb.and(
pb.sql(RegistryCodeSqlBuilder.getInstance(rgsCode).build()),
pb.equals("companyId", companyId),
pb.equals("accountId", accountId),
pb.equals("securitySymbol", CurrencyCode.RUB.getKey())
pb.equals("securitySymbol", account.getCurrency())
);
Registry amf = rgsImdg.getFirstObjectByPredicate(prdct.apply(AM_F));
Registry amb = rgsImdg.getFirstObjectByPredicate(prdct.apply(AM_B));

11
platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/validation/rule/AnltAccLoad.java → clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/AnltAccLoad.java
View file

@ -1,5 +1,7 @@
package ru.spcex.platform.imdg.validation.rule;
package ru.spcex.clearing.service.validation;
import java.util.Optional;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.AccountType;
@ -13,8 +15,6 @@ import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IErrorEnumId;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.util.Optional;
/**
* В рексевте необходим интерфейс WithId
*/
@ -27,11 +27,14 @@ public class AnltAccLoad implements IValidationRule<ImdgValidationContext<Object
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<Object> context) {
//если захотим где-то еще использовать, нужно сделать Registry implements WithCurrency
Registry rgs = context.getStoredObject(Stored.PresentById);
Imdg<SpcexObjectBase> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, SpcexObjectBase.class);
ImdgPredicateBuilder pb = accImdg.predicateBuilder();
ImdgPredicate prdct = pb.and(
pb.equals("companyId", Sender.One.getId()),
pb.equals("accountType", AccountType.Anlt.getKey())
pb.equals("accountType", AccountType.Anlt.getKey()),
pb.equals("currency", rgs.getSecuritySymbol())
);
Object anltAcc = accImdg.getSingleObjectByPredicate(prdct);
if (anltAcc == null) {

34
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/IdentificationFundsValidationRule.java
View file

@ -1,17 +1,22 @@
package ru.spcex.clearing.service.validation;
import java.math.BigDecimal;
import java.util.Optional;
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.registry.Registry;
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.clearing.platform.messaging.domain.cud.registry.IdentificationFundsRequest;
import ru.spcex.clearing.service.AnltSearcher;
import ru.spcex.clearing.service.AssetTrio;
import ru.spcex.clearing.service.TcrSearcher;
import ru.spcex.clearing.service.registry.AssetTBFProcessing;
import static ru.spcex.clearing.service.registry.RegistryManager.equalsByCode;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.RegistryTradingParams;
import ru.spcex.platform.enumeration.ServiceStatus;
@ -21,13 +26,8 @@ import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.imdg.validation.Stored;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.math.BigDecimal;
import java.util.Optional;
import static ru.spcex.clearing.service.registry.RegistryManager.equalsByCode;
import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
import ru.spcex.platform.utils.validation.IValidationRule;
public enum IdentificationFundsValidationRule implements IValidationRule<ImdgValidationContext<IdentificationFundsRequest>> {
Fields() {
@ -77,9 +77,14 @@ public enum IdentificationFundsValidationRule implements IValidationRule<ImdgVal
TcrCheck() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<IdentificationFundsRequest> context) {
Registry rgs = context.getStoredObject(Stored.PresentById);
IdentificationFundsRequest validatedObject = context.getValidatedObject();
Imdg<TradingClearingRegistry> tcrImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
Imdg<TradingClearingRegistryList> tcrListImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
Imdg<Account> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
Imdg<Company> cmpImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
TradingClearingRegistry tcr = tcrImdg.getSingleObjectByID(validatedObject.getTradingClearingRegistryId());
if (tcr == null) {
return of(ClearingError.TCRegistryNotFound, validatedObject.getTradingClearingRegistryId());
@ -92,16 +97,20 @@ public enum IdentificationFundsValidationRule implements IValidationRule<ImdgVal
return of(ClearingError.AccountNotFoundB, "null"); //mb other error
}
Imdg<Account> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
Account acc = accImdg.getSingleObjectByID(tcr.getMoneyAccountId());
if (acc == null) {
return of(ClearingError.AccountNotFoundB, tcr.getMoneyAccountId());
TcrSearcher tcrSearcher = new TcrSearcher(tcrImdg,
tcrListImdg,
cmpImdg,
accImdg);
Optional<Account> accF = tcrSearcher.searchByTcr(tcr.getId(), rgs.getSecuritySymbol());
if (accF.isEmpty()) {
return of(ClearingError.AccountNotFoundB, "<by TCR.id=%d for currency %s>"
.formatted(tcr.getId(), rgs.getSecuritySymbol()));
}
Account acc = accF.get();
if (!AccountType.Info.equalsByKey(acc.getAccountType())) {
return of(ClearingError.AccountWrongType, acc.getAccountType());
}
Imdg<Company> cmpImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
Company company = cmpImdg.getSingleObjectByID(tcr.getCompanyId());
if (company == null) {
return of(ClearingError.CompanyNotFoundB, tcr.getCompanyId());
@ -120,7 +129,8 @@ public enum IdentificationFundsValidationRule implements IValidationRule<ImdgVal
return of(ClearingError.RecordNotFound, "AM*T");
}
Imdg<Registry> rgsImdg = context.obtainMap(IMDGDistributedNames.Map_Registry, Registry.class);
AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg);
Imdg<Account> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg, accImdg);
Optional<AssetTrio> assetTrio = assets.searchMoneyByAccAndCompany(tcrSearch.getCompany().getId(), tcrSearch.getAccount().getId());
if (assetTrio.isEmpty()) {
return of(ClearingError.RecordNotFound, "AM*T");

7
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf55ValidationRule.java
View file

@ -1,7 +1,9 @@
package ru.spcex.clearing.service.validation;
import java.util.Optional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.payment.PaymentInstruction;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
@ -17,8 +19,6 @@ import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.util.Optional;
public enum Sdf55ValidationRule implements IValidationRule<ImdgValidationContext<StatementRequest>> {
Fields() {
@Override
@ -96,11 +96,12 @@ public enum Sdf55ValidationRule implements IValidationRule<ImdgValidationContext
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<StatementRequest> context) {
Imdg<Registry> rgsImdg = context.obtainMap(IMDGDistributedNames.Map_Registry, Registry.class);
Imdg<Account> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
PaymentInstruction pmt = context.getStoredObject(ValidationStored.Sdf55PaymentInstruction);
Long accCredId = pmt.getCreditLeg_accountId();
Long addresseeId = pmt.getSenderId();
AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg);
AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg, accImdg);
Optional<AssetTrio> assetTrio = assets.searchMoneyByAccAndCompany(addresseeId, accCredId);
if (assetTrio.isEmpty()) {
return of(ClearingError.RecordNotFound, "AM*F/AM*B/AM*T");