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

SDF08/SDF21

Browse source
This commit is contained in:
ialbert 2023-08-03 19:14:41 +03:00
parent b1db92425e
commit 050c742313
10 changed files with 322 additions and 31 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/SdfExecutorsConfig.java
View file

@ -16,13 +16,15 @@ public class SdfExecutorsConfig {
Sdf57Executor sdf57Executor,
Sdf04Executor sdf04Executor,
Sdf13Executor sdf13Executor,
Sdf08Executor sdf08Executor) {
Sdf08Executor sdf08Executor,
Sdf21Executor sdf21Executor) {
Map<SdfTable, AbstractExecutor<?>> executors = new HashMap<>();
executors.put(SdfTable.SDF_01, sdf01Executor);
executors.put(SdfTable.SDF_57, sdf57Executor);
executors.put(SdfTable.SDF_04, sdf04Executor);
executors.put(SdfTable.SDF_13, sdf13Executor);
executors.put(SdfTable.SDF_08, sdf08Executor);
executors.put(SdfTable.SDF_21, sdf21Executor);
return executors;
}
}

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

@ -14,10 +14,7 @@ import ru.clearing.classes.statics.data.misc.STrades;
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.SDf01;
import ru.clearing.classes.statics.data.sdf.SDf06;
import ru.clearing.classes.statics.data.sdf.SDf08;
import ru.clearing.classes.statics.data.sdf.SDf57;
import ru.clearing.classes.statics.data.sdf.*;
import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
import ru.clearing.classes.statics.data.security.Security;
import ru.clearing.platform.dictionary.SectionDictionary;
@ -190,6 +187,21 @@ public class ValidationConfig {
};
}
@Bean("sdf21Validator")
public Function<SDf21, IValidator> sdf21Validator() {
return sDf21 -> {
ImdgValidationContext<SDf21> context = new ImdgValidationContext<>();
context.setValidatedObject(sDf21);
context.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
context.setLogPrefix(LogPrefixId.INSTANCE);
return new ValidatorImpl<>(context,
Sdf21ValidationRule.CompanyPresent,
Sdf21ValidationRule.AccountPresent
);
};
}
@Bean("sdf01ValidatorNew")
public Function<SDf01, IValidator> sdf01ValidatorNew() {
return sDf01 -> {

78
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/StatementService.java
View file

@ -60,6 +60,7 @@ public class StatementService extends QueueConsumer implements InitializingBean
this.sdfImdgs.put(SdfTable.SDF_04, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf04, SDf04.class));
this.sdfImdgs.put(SdfTable.SDF_13, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf13, SDf13.class));
this.sdfImdgs.put(SdfTable.SDF_08, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf08, SDf08.class));
this.sdfImdgs.put(SdfTable.SDF_21, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf21, SDf21.class));
}
@Override
@ -100,26 +101,51 @@ public class StatementService extends QueueConsumer implements InitializingBean
}
/**
* fromAccService передается когда пришел ответ от account-service
* в этом случае: по key находим пару в которой сохранен sdf57 запрос и частично выполненный sdf01
* вместо старого sdf01 запроса выполняем новый пришедший от account-service
*/
private void processSdf08And21(Long key, StatementRequest fromAccService) {
Pair<StatementRequest, StatementRequest> pair = pairOfSdfRequest.get(key);
Result sdf08Res = processSdf08(fromAccService == null ? pair.getFirst() : fromAccService);
if (sdf08Res.getAccountRequests().size() > 0) {
log.info("sdf08 execution wasn't complete, waiting for an answer from account-service");
return;
}
//затем sdf21
processSdf21(pair.getSecond());
//fixme ревизия для бумаг reviser.doRevise(pair.getFirst().getGroupId());
//теперь можем продолжить сессию с шага 1
// ContinueSessionBnRequest continueSessionBn = new ContinueSessionBnRequest();
// kafkaSender.sendRequestToQueue(Consts.CONTINUE_SESSION_BN_FIRST_PART, continueSessionBn);
pairOfSdfRequest.remove(key);
log.info("pair sdf08/sdf21 processed successfully");
}
private void processAccountAnswer(BaseRequest<StatementRequest> systemRequest) {
StatementRequest payload = systemRequest.getRequestPayload();
Optional<Long> key = findCompleteKey(payload.getTable());
if (key.isEmpty()) {
log.error("FATAL: response from account-service received id={} table {} sdf ids={}", systemRequest.getId(),
payload.getTable(),
payload
.getAccountCreationResults()
.stream()
.map(res -> String.valueOf(res.getSdfId()))
.collect(Collectors.joining(",", "[", "]"))
);
return;
}
switch (payload.getTable()) {
case SDF_01 -> {
//там нужно переиспользовать SDF57 запрос приходивший ранее и сохраненный в pairOfSdfRequest
Optional<Long> key = findCompleteKey(payload.getTable());
if (key.isEmpty()) {
log.error("FATAL: response from account-service received id={} table {} sdf ids={}", systemRequest.getId(),
payload.getTable(),
payload
.getAccountCreationResults()
.stream()
.map(res -> String.valueOf(res.getSdfId()))
.collect(Collectors.joining(",", "[", "]"))
);
return;
}
processSdf01And57(key.get(), payload);
}
case SDF_08 -> processSdf08(payload);
case SDF_08 -> {
processSdf08(payload);
}
}
log.info("{} processed successfully after account-service command.", payload.getTable());
@ -184,6 +210,15 @@ public class StatementService extends QueueConsumer implements InitializingBean
// finishSendCommand(res, service, statementRequest);
}
private void processSdf21(StatementRequest statementRequest) {
Imdg<SDf21> sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf21, SDf21.class);
Collection<? extends SpcexObjectBase> sdfGroup = sdfImdg.getCollectionObjectsByFieldValues(Map.of(
"generationId", statementRequest.getGroupId()));
AbstractExecutor service = executorsMap.get(SdfTable.SDF_21);
Result res = service.execute(sdfGroup, statementRequest);
// finishSendCommand(res, service, statementRequest);
}
private void processSdf04(StatementRequest statementRequest) {
Imdg<SDf04> sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf04, SDf04.class);
Collection<? extends SpcexObjectBase> sdfGroup = sdfImdg.getCollectionObjectsByFieldValues(Map.of(
@ -197,7 +232,7 @@ public class StatementService extends QueueConsumer implements InitializingBean
}
}
private void processSdf08(StatementRequest statementRequest) {
private Result processSdf08(StatementRequest statementRequest) {
Imdg<SDf08> sdfImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf08, SDf08.class);
Collection<? extends SpcexObjectBase> sdfGroup;
if (statementRequest.getAccountCreationResults().size() == 0) {
@ -211,16 +246,13 @@ public class StatementService extends QueueConsumer implements InitializingBean
.collect(Collectors.toList());
}
AbstractExecutor service = executorsMap.get(SdfTable.SDF_08);
if (service != null) {
Result res = service.execute(sdfGroup, statementRequest);
if (res.getAccountRequests().size() != 0) {
kafkaSender.sendRequestToQueue(Consts.ACCOUNT_NEW_SDF08, createAccountsRequest(statementRequest.getGroupId(), res.getAccountRequests()));
} else if (service.isNeedToSendCommand()) {
service.sendCommand(kafkaSender, res);
}
} else {
log.warn("Executor for SDF_08 not set");
Result res = service.execute(sdfGroup, statementRequest);
if (res.getAccountRequests().size() != 0) {
kafkaSender.sendRequestToQueue(Consts.ACCOUNT_NEW_SDF08, createAccountsRequest(statementRequest.getGroupId(), res.getAccountRequests()));
} else if (service.isNeedToSendCommand()) {
service.sendCommand(kafkaSender, res);
}
return res;
}
private void processSdf13(StatementRequest statementRequest) {

150
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java Normal file
View file

@ -0,0 +1,150 @@
package ru.spcex.clearing.service.builder;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.account.ClearingAccount;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
import ru.clearing.classes.statics.data.misc.Currency;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
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.session.stage.util.RegistryUtil;
import ru.spcex.platform.enumeration.*;
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 RegistrySecurityBuilder {
private Statement statement;
private Company company;
private Account account;
private RegistryDesignation designation;
private final ImdgProvider imdgProvider;
private final Imdg<ClearingAccount> clearingAccountImdg;
private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
private final Imdg<Security> securityImdg;
private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
private final Imdg<MoneyMarketSecurity> moneyMarketSecurityImdg;
private final Imdg<EquitySecurity> equitySecurityImdg;
private final Imdg<Currency> currencyImdg;
public static RegistrySecurityBuilder builder(ImdgProvider imdgProvider) {
return new RegistrySecurityBuilder(imdgProvider);
}
private RegistrySecurityBuilder(ImdgProvider imdgProvider) {
this.imdgProvider = imdgProvider;
this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
this.moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
}
public RegistrySecurityBuilder statement(Statement statement) {
this.statement = statement;
return this;
}
public RegistrySecurityBuilder company(Company company) {
this.company = company;
return this;
}
public RegistrySecurityBuilder account(Account account) {
this.account = account;
return this;
}
public RegistrySecurityBuilder designation(RegistryDesignation designation) {
this.designation = designation;
return this;
}
public Registry build() {
Registry rgs = new Registry();
rgs.setCompanyId(company.getId());
rgs.setTradingCode(company.getTradingCode());
rgs.setClearingCode(company.getClearingCode());
rgs.setShortName(company.getShortName());
rgs.setFullName(company.getFullName());
rgs.setAccountId(account.getId());
rgs.setAccountType(account.getAccountType());
rgs.setAccount(account.getAccount());
rgs.setRegistryDesignation(designation.getKey());
rgs.setRegistryInstrumentType(RegistryInstrumentType.S.getKey());
AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType());
if (AccountType.Clrn.equals(accType)) {
ClearingAccount accountForStatement = clearingAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", statement.getAccountId()));
if (accountForStatement != null) {
rgs.setRegistryCapacity(accountForStatement.getClearingAccountType());
}
} else if (AccountType.Info.equals(accType) || AccountType.Anlt.equals(accType)) {
rgs.setRegistryCapacity(RegistryCapacity.A.getKey());
}
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());
}
rgs.setRegistryStatus(RegistryStatus.PROC.getKey());
rgs.setSecurityId(statement.getSecurityId());
if (statement.getSecurityId() != null) {
String securitySymbol = obtainSecuritySymbol(statement.getSecurityId());
rgs.setSecuritySymbol(securitySymbol);
}
//fixme !rgs.setSettlementCode();
rgs.setTradingDate(statement.getSettlementDate()); //fixme ! today ?
rgs.setClearingDate(LocalDate.now());
//fixme rgs.setRefundDate();
//fixme rgs.setValueDate();
rgs.setContract(statement.getContract());
//создается на базе stmt, companyCred, accountDeb
rgs.setCounterPartyId(statement.getAddresseeId());
rgs.setCreated(Instant.now());
//по дефолту создаем с балансом 0, а потом пересчитываем по необходимости
rgs.setBalance(BigDecimal.ZERO);
rgs.setDebit(BigDecimal.ZERO);
rgs.setCredit(BigDecimal.ZERO);
rgs.setDiffBalance(BigDecimal.ZERO);
rgs.setCheckBalance(BigDecimal.ZERO);
return rgs;
}
private String obtainSecuritySymbol(Long securityId) {
Security security = fixedIncomeSecurityImdg.getSingleObjectByID(securityId);
if (security != null) return security.getSecuritySymbol();
security = moneyMarketSecurityImdg.getSingleObjectByID(securityId);
if (security != null) return security.getSecuritySymbol();
security = equitySecurityImdg.getSingleObjectByID(securityId);
if (security != null) return security.getSecuritySymbol();
Currency currency = currencyImdg.getSingleObjectByID(securityId);
if (currency != null) return currency.getCurrencyCode();
return null;
}
}

15
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf08Executor.java
View file

@ -34,6 +34,7 @@ import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.log.ExceptionUtils;
import ru.spcex.platform.utils.number.BigDecimalUtil;
import ru.spcex.platform.utils.text.TextUtil;
import ru.spcex.platform.utils.validation.IValidator;
@ -179,6 +180,7 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
registryImdg.update(rgs);
} else {
rgs = createRegistryByStatement(stmt, company, account);
calcBalance(rgs, stmt);
Registry registryB = copyRegB(rgs);
Registry registryF = copyRegF(rgs, registryB.getBalance());
registryImdg.insert(rgs);
@ -334,9 +336,11 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
rgs.setSecuritySymbol(security.getSecuritySymbol());
}
}
rgs.setCheckBalance(safeBD(statement.getAmount()));
rgs.setBalance(safeBD(statement.getAmount()));
rgs.setDiffBalance(rgs.getBalance().subtract(rgs.getCheckBalance()));
rgs.setBalance(BigDecimal.ZERO);
rgs.setDebit(BigDecimal.ZERO);
rgs.setCredit(BigDecimal.ZERO);
rgs.setDiffBalance(BigDecimal.ZERO);
rgs.setCheckBalance(BigDecimal.ZERO);
rgs.setBalanceDimension(BalanceDimension.MONY.getKey());
rgs.setTradingDate(statement.getSettlementDate());
rgs.setClearingDate(LocalDate.now());
@ -411,4 +415,9 @@ public class Sdf08Executor extends AbstractExecutor<SDf08> {
);
return Optional.ofNullable(registryImdg.getSingleObjectByPredicate(rgstrPredicate));
}
private void calcBalance(Registry rgs, Statement statement) {
rgs.setCheckBalance(BigDecimalUtil.safeBD(statement.getAmount()));
rgs.setDiffBalance(BigDecimalUtil.safeBD(rgs.getCheckBalance()).negate());
}
}

64
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf21ValidationRule.java Normal file
View file

@ -0,0 +1,64 @@
package ru.spcex.clearing.service.validation;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.sdf.SDf21;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.text.TextUtil;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.util.Collection;
import java.util.Optional;
public enum Sdf21ValidationRule implements IValidationRule<ImdgValidationContext<SDf21>> {
CompanyPresent() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf21> context) {
SDf21 sdf21 = context.getValidatedObject();
Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
String depoCodeCl = sdf21.getDepoCodeCl();
//ClearingError.CompanyNotFoundB
if (TextUtil.isEmpty(depoCodeCl) || depoCodeCl.length() < 4) {
return of(ClearingError.CompanyNotFoundB, depoCodeCl);
}
String tradingCode = depoCodeCl.substring(1, 4);
Collection<Company> companies = companyImdg.getCollectionObjectsBySQL("tradingCode = '%s'".formatted(tradingCode));
if (companies.size() != 1) {
return of(ClearingError.CompanyNotFoundB, depoCodeCl);
}
context.storeObject(ValidationStored.Sdf21Company, companies.iterator().next());
return empty();
}
},
AccountPresent() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf21> context) {
SDf21 sdf21 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf21.getDepoCodeCl())) {
return of(ClearingError.AccountNotPresent, sdf21.getDepoCodeCl());
}
Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
Collection<Account> account = accountImdg.getCollectionObjectsBySQL(
"account = '%s' and accountType = '%s'".formatted(sdf21.getDepoCodeCl(), AccountType.Depo.getKey())
);
if (account.size() != 1) {
return of(ClearingError.AccountNotPresent, sdf21.getDepoCodeCl());
}
context.storeObject(ValidationStored.Sdf21Account, account.iterator().next());
return empty();
}
}
;
@Override
public String ruleName() {
return "Sdf21ValidationRule." + name();
}
}

2
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/ValidationStored.java
View file

@ -10,6 +10,8 @@ public enum ValidationStored {
Sdf08Company, Sdf08Account,
Sdf21Company, Sdf21Account,
Sdf06Company, Sdf06Account,
ReturnDepositDmx

1
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/InOutSDfType.java
View file

@ -10,6 +10,7 @@ public enum InOutSDfType implements IEnumKey {
type57("57"),
type08("0809"),
type10("1011"),
type21("21"),
;
private final String key;

18
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/OperationCode.java Normal file
View file

@ -0,0 +1,18 @@
package ru.spcex.platform.enumeration;
import ru.spcex.platform.utils.enumeration.IEnumKey;
public enum OperationCode implements IEnumKey {
RECFREE("RECFREE"), DELFREE("DELFREE");
private final String key;
OperationCode(String key) {
this.key = key;
}
@Override
public String getKey() {
return key;
}
}

1
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/SdfTable.java
View file

@ -11,6 +11,7 @@ public enum SdfTable implements IEnumKey {
SDF_10("SDF_10"),
SDF_13("SDF_13"),
SDF_16("SDF_16"),
SDF_21("SDF_21"),
SDF_57("SDF_57");
SdfTable(String key) {