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

http://jira.mfd.msk:8088/browse/CLS-189

Browse source
This commit is contained in:
ialbert 2023-02-07 16:41:55 +03:00
parent 722b6ff385
commit dc0a214306
2 changed files with 198 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

119
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/Clearing.java
View file

@ -8,7 +8,6 @@ import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
import ru.clearing.classes.statics.data.generated.ClearingMemberCategory;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney;
import ru.clearing.classes.statics.data.payment.PaymentInstruction;
import ru.spcex.clearing.error.ClearingErrorInternal;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.Consts;
@ -32,6 +31,8 @@ import ru.spcex.platform.utils.validation.IValidator;
import java.time.Instant;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Supplier;
@Service
public class Clearing {
@ -192,49 +193,73 @@ public class Clearing {
continue;
}
}
LiabilitiesClaimsAssets lca = lbltsClmsAssetsCreator.createLiabilitiesClaimsAssets(category, execDeposit);
liabilitiesClaimsAssetsImdg.insert(lca);
log.trace("LiabilitiesClaimsAssets {} was created", lca.getId());
Optional<LiabilitiesClaimsMoney> lcmFirstLegFound = lbltsClmsMoneyCreator.searchLcmBySettlementDate(lca.getAccountId(), lca.getCompanyId(), lca.getSettlementDate());
var wrapperFirstLegCreated = new Object() {LiabilitiesClaimsMoney firstLegCreated;};
lcmFirstLegFound.ifPresentOrElse(lcm -> {
Optional<LiabilitiesClaimsAssets> lcaFirstLegFound = lbltsClmsAssetsCreator.searchLCA(
execDeposit.getAccountId(), execDeposit.getCompanyId(),
execDeposit.getSecurityId(), execDeposit.getFirstLegSettlementDate());
LiabilitiesClaimsAssets lcaFirstLeg = orElse(lcaFirstLegFound).ifPresentOrElse(lca -> {
log.trace("LiabilitiesClaimsAssets first leg {} was found", lca.getId());
lbltsClmsAssetsCreator.updateFirstLegLca(lca, execDeposit, category);
liabilitiesClaimsAssetsImdg.update(lca);
}, () -> {
log.trace("LiabilitiesClaimsAssets first leg was not found");
LiabilitiesClaimsAssets lca = lbltsClmsAssetsCreator.createFirstLegLCA(category, execDeposit);
liabilitiesClaimsAssetsImdg.insert(lca);
log.trace("LiabilitiesClaimsAssets {} first leg was created", lca.getId());
return lca;
});
Optional<LiabilitiesClaimsAssets> lcaSecondLegFound = lbltsClmsAssetsCreator.searchLCA(
execDeposit.getAccountId(), execDeposit.getCompanyId(),
execDeposit.getSecurityId(), execDeposit.getSecondLegSettlementDate());
LiabilitiesClaimsAssets lcaSecondLeg = orElse(lcaSecondLegFound).ifPresentOrElse(lca -> {
log.trace("LiabilitiesClaimsAssets second leg {} was found", lca.getId());
lbltsClmsAssetsCreator.updateSecondLegLca(lca, execDeposit, category);
liabilitiesClaimsAssetsImdg.update(lca);
}, () -> {
log.trace("LiabilitiesClaimsAssets second leg was not found");
LiabilitiesClaimsAssets lca = lbltsClmsAssetsCreator.createSecondLegLCA(category, execDeposit);
liabilitiesClaimsAssetsImdg.insert(lca);
log.trace("LiabilitiesClaimsAssets {} second leg was created", lca.getId());
return lca;
});
Optional<LiabilitiesClaimsMoney> lcmFirstLegFound = lbltsClmsMoneyCreator.searchLcmBySettlementDate(lcaFirstLeg.getAccountId(), lcaFirstLeg.getCompanyId(), lcaFirstLeg.getSettlementDate());
LiabilitiesClaimsMoney lcmFirstLeg = orElse(lcmFirstLegFound).ifPresentOrElse(lcm -> {
log.trace("LiabilitiesClaimsMoney first leg {} was found", lcm.getId());
lbltsClmsMoneyCreator.updateFirstLegLcm(lcm, lca, category);
lbltsClmsMoneyCreator.updateFirstLegLcm(lcm, lcaFirstLeg, category);
liabilitiesClaimsMoneyImdg.update(lcm);
}, () -> {
LiabilitiesClaimsMoney lcmFirstLeg = lbltsClmsMoneyCreator.createFirstLegLcm(lca, category);
liabilitiesClaimsMoneyImdg.insert(lcmFirstLeg);
log.trace("LiabilitiesClaimsMoney first leg {} was created", lcmFirstLeg.getId());
wrapperFirstLegCreated.firstLegCreated = lcmFirstLeg;
LiabilitiesClaimsMoney lcm = lbltsClmsMoneyCreator.createFirstLegLcm(lcaFirstLeg, category);
liabilitiesClaimsMoneyImdg.insert(lcm);
log.trace("LiabilitiesClaimsMoney first leg {} was created", lcm.getId());
return lcm;
});
Optional<LiabilitiesClaimsMoney> lcmSecondLegFound = lbltsClmsMoneyCreator.searchLcmByRefundDate(lca.getAccountId(), lca.getCompanyId(), lca.getRefundDate());
var wrapperSecondLegCreated = new Object() {LiabilitiesClaimsMoney secondLegCreated;};
lcmSecondLegFound.ifPresentOrElse(lcm -> {
Optional<LiabilitiesClaimsMoney> lcmSecondLegFound = lbltsClmsMoneyCreator.searchLcmBySettlementDate(lcaSecondLeg.getAccountId(), lcaSecondLeg.getCompanyId(), lcaSecondLeg.getSettlementDate());
LiabilitiesClaimsMoney lcmSecondLeg = orElse(lcmSecondLegFound).ifPresentOrElse(lcm -> {
log.trace("LiabilitiesClaimsMoney second leg {} was found", lcm.getId());
lbltsClmsMoneyCreator.updateSecondLegLcm(lcm, lca, category);
lbltsClmsMoneyCreator.updateSecondLegLcm(lcm, lcaSecondLeg, category);
liabilitiesClaimsMoneyImdg.update(lcm);
}, () -> {
LiabilitiesClaimsMoney lcmSecondLeg = lbltsClmsMoneyCreator.createSecondLegLcm(lca, category);
liabilitiesClaimsMoneyImdg.insert(lcmSecondLeg);
log.trace("LiabilitiesClaimsMoney second leg {} was created", lcmSecondLeg.getId());
wrapperSecondLegCreated.secondLegCreated = lcmSecondLeg;
LiabilitiesClaimsMoney lcm = lbltsClmsMoneyCreator.createSecondLegLcm(lcaSecondLeg, category);
liabilitiesClaimsMoneyImdg.insert(lcm);
log.trace("LiabilitiesClaimsMoney second leg {} was created", lcm.getId());
return lcm;
});
lbltsClmsAssetsCreator.updateLca(lca, lcmFirstLegFound.orElse(wrapperFirstLegCreated.firstLegCreated));
liabilitiesClaimsAssetsImdg.update(lca);
lbltsClmsAssetsCreator.setLcaLcmId(lcaFirstLeg, lcmFirstLeg);
liabilitiesClaimsAssetsImdg.update(lcaFirstLeg);
lbltsClmsAssetsCreator.setLcaLcmId(lcaSecondLeg, lcmSecondLeg);
liabilitiesClaimsAssetsImdg.update(lcaSecondLeg);
log.trace("creating paymentInstructions");
List<PaymentInstruction> paymentInstructions = paymentInstructionCreator.createAndSavePaymentInstructions(lca, Collections.singleton(category));
paymentInstructionCreator.updateFieldLiabilitiesClaimsAssetsByPayment(lca, paymentInstructions, Collections.singleton(category));
liabilitiesClaimsAssetsImdg.update(lca);
var firstLegLiabilitiesClaimsMoney = lcmFirstLegFound.orElseGet(() -> wrapperFirstLegCreated.firstLegCreated);
var secondLegLiabilitiesClaimsMoney = lcmSecondLegFound.orElseGet(() -> wrapperSecondLegCreated.secondLegCreated);
log.trace("updating LiabilitiesClaimsMoney by payment");
log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", firstLegLiabilitiesClaimsMoney, secondLegLiabilitiesClaimsMoney);
if (paymentInstructionCreator.updateFieldLiabilitiesClaimsMoneyByPayment(firstLegLiabilitiesClaimsMoney, true, paymentInstructions, Collections.singleton(category)) ) {
liabilitiesClaimsMoneyImdg.update(firstLegLiabilitiesClaimsMoney);
log.trace("LiabilitiesClaimsMoney first leg {} was updated", firstLegLiabilitiesClaimsMoney.getId(), secondLegLiabilitiesClaimsMoney.getId());
}
log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", firstLegLiabilitiesClaimsMoney, secondLegLiabilitiesClaimsMoney);
// List<PaymentInstruction> paymentInstructions = paymentInstructionCreator.createAndSavePaymentInstructions(lca, Collections.singleton(category));
// paymentInstructionCreator.updateFieldLiabilitiesClaimsAssetsByPayment(lca, paymentInstructions, Collections.singleton(category));
// liabilitiesClaimsAssetsImdg.update(lca);
// log.trace("updating LiabilitiesClaimsMoney by payment");
// log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", lcmFirstLeg, lcmSecondLeg);
// if (paymentInstructionCreator.updateFieldLiabilitiesClaimsMoneyByPayment(lcmFirstLeg, true, paymentInstructions, Collections.singleton(category)) ) {
// liabilitiesClaimsMoneyImdg.update(lcmFirstLeg);
// log.trace("LiabilitiesClaimsMoney first leg {} was updated", lcmFirstLeg.getId());
// }
log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", lcmFirstLeg.getId(), lcmSecondLeg.getId());
execDeposit.setSessionId(clearingSessionId);
execDeposit.setUpdated(Instant.now());
executionDepositImdg.update(execDeposit);
@ -244,4 +269,30 @@ public class Clearing {
public void setLastAccBalanceResponseId(Long lastAccBalanceResponseId) {
this.lastAccBalanceResponseId = lastAccBalanceResponseId;
}
private static <T> OrElse<T> orElse( Optional<T> optional) {
return new OrElse<>(optional);
}
private static class OrElse<T> implements IOptionalOrElse<T> {
private final Optional<T> optional;
private OrElse(Optional<T> optional) {
this.optional = optional;
}
@Override
public T ifPresentOrElse(Consumer<T> consumer, Supplier<T> orElse) {
if (optional.isPresent()) {
consumer.accept(optional.get());
return optional.get();
} else {
return orElse.get();
}
}
}
private interface IOptionalOrElse<T> {
T ifPresentOrElse(Consumer<T> consumer, Supplier<T> orElse);
}
}

135
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/LiabilitiesClaimsAssetsCreator.java
View file

@ -13,42 +13,34 @@ import ru.spcex.platform.enumeration.ClearingCategory;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import ru.spcex.platform.utils.number.BigDecimalUtil;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Map;
import java.util.Optional;
@Component
public class LiabilitiesClaimsAssetsCreator {
private final Imdg<Account> accountImdg;
private final Imdg<Company> companyImdg;
private final Imdg<LiabilitiesClaimsAssets> assetsImdg;
@Autowired
public LiabilitiesClaimsAssetsCreator(ImdgProvider imdgProvider) {
this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.assetsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_LiabilitiesClaimsAssets, LiabilitiesClaimsAssets.class);
}
public LiabilitiesClaimsAssets createLiabilitiesClaimsAssets(ClearingCategory category, ExecutionDeposit executionDeposit) {
private LiabilitiesClaimsAssets createLCA(ExecutionDeposit executionDeposit, Account account) {
LiabilitiesClaimsAssets liabilitiesClaimsAssets = new LiabilitiesClaimsAssets();
liabilitiesClaimsAssets.setCompanyId(executionDeposit.getCompanyId());
liabilitiesClaimsAssets.setAccountId(executionDeposit.getAccountId());
Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId());
liabilitiesClaimsAssets.setAccountType(account.getAccountType());
liabilitiesClaimsAssets.setAccount(account.getAccount());
AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType());
boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType);
boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType);
boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType);
if (iClrn || vInfo) {
liabilitiesClaimsAssets.setLiabilitiesQuantity(executionDeposit.getFirstLegAmount());
}
if (bClrn) {
liabilitiesClaimsAssets.setClaimsQuantity(executionDeposit.getSecondLegAmount());
}
liabilitiesClaimsAssets.setCurrency(executionDeposit.getSettlementCurrency());
liabilitiesClaimsAssets.setSettlementDate(executionDeposit.getFirstLegSettlementDate());
liabilitiesClaimsAssets.setTradingDate(executionDeposit.getTradingDate());
liabilitiesClaimsAssets.setRefundDate(executionDeposit.getSecondLegSettlementDate());
liabilitiesClaimsAssets.setPrice(executionDeposit.getPrice());
@ -59,18 +51,117 @@ public class LiabilitiesClaimsAssetsCreator {
liabilitiesClaimsAssets.setShortName(company.getShortName());
liabilitiesClaimsAssets.setContract(executionDeposit.getSecuritySymbol());
liabilitiesClaimsAssets.setFullName(company.getFullName());
//todo liabilitiesClaimsAssets.setLiabilitiesClaimsMoneyId(company.getFullName());
//fixme liabilitiesClaimsAssets.setClearingStatus();
//todo liabilitiesClaimsAssets.setPaymentId();
//todo liabilitiesClaimsAssets.setRefundPaymentId();
liabilitiesClaimsAssets.setCreated(Instant.now());
liabilitiesClaimsAssets.setClearingDate(LocalDate.now());
return liabilitiesClaimsAssets;
}
public void updateLca(LiabilitiesClaimsAssets lca,
LiabilitiesClaimsMoney firstLeg) {
lca.setLiabilitiesClaimsMoneyId(firstLeg.getId());
public LiabilitiesClaimsAssets createFirstLegLCA(ClearingCategory category, ExecutionDeposit executionDeposit) {
Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId());
LiabilitiesClaimsAssets lca = createLCA(executionDeposit, account);
lca.setSettlementDate(executionDeposit.getFirstLegSettlementDate());
AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType());
boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType);
boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType);
boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType);
if (iClrn || vInfo) {
lca.setLiabilitiesQuantity(executionDeposit.getFirstLegAmount());
}
if (bClrn) {
lca.setClaimsQuantity(executionDeposit.getFirstLegAmount());
}
return lca;
}
public LiabilitiesClaimsAssets createSecondLegLCA(ClearingCategory category, ExecutionDeposit executionDeposit) {
Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId());
LiabilitiesClaimsAssets lca = createLCA(executionDeposit, account);
lca.setSettlementDate(executionDeposit.getSecondLegSettlementDate());
AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType());
boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType);
boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType);
boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType);
if (iClrn || vInfo) {
lca.setClaimsQuantity(executionDeposit.getSecondLegAmount());
}
if (bClrn) {
lca.setLiabilitiesQuantity(executionDeposit.getSecondLegAmount());
}
return null;
}
public void setLcaLcmId(LiabilitiesClaimsAssets lca,
LiabilitiesClaimsMoney lcm) {
lca.setLiabilitiesClaimsMoneyId(lcm.getId());
lca.setUpdated(Instant.now());
}
public Optional<LiabilitiesClaimsAssets> searchLCA(Long accountId,
Long companyId,
Long securityId,
LocalDate dt) {
LiabilitiesClaimsAssets asset = assetsImdg.getSingleObjectByFieldValues(
Map.of("accountId", accountId,
"companyId", companyId,
"securityId", securityId,
"settlementDate", dt));
return Optional.ofNullable(asset);
}
public void updateSecondLegLca(LiabilitiesClaimsAssets lca, ExecutionDeposit executionDeposit, ClearingCategory category) {
Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId());
AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType());
boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType);
boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType);
boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType);
if (iClrn || vInfo) {
BigDecimal prevCQuantity = BigDecimalUtil.safeBD(lca.getClaimsQuantity());
BigDecimal secondLegAmount = BigDecimalUtil.safeBD(executionDeposit.getSecondLegAmount());
lca.setClaimsQuantity(prevCQuantity.add(secondLegAmount));
}
if (bClrn) {
BigDecimal prevLQuantity = BigDecimalUtil.safeBD(lca.getLiabilitiesQuantity());
BigDecimal secondLegAmount = BigDecimalUtil.safeBD(executionDeposit.getSecondLegAmount());
lca.setLiabilitiesQuantity(prevLQuantity.add(secondLegAmount));
}
}
public void updateFirstLegLca(LiabilitiesClaimsAssets lca, ExecutionDeposit executionDeposit, ClearingCategory category) {
Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId());
AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType());
boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType);
boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType);
boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType);
//liabilitiesQuantity
//Клиринг (по первой ноге и категория I и счет CLRN):
//текущее значение liabilitiesClaimsAssets.liabilitiesQuantity + executionDeposit.firstLegAmount
if (iClrn || vInfo) {
BigDecimal prevLQuantity = BigDecimalUtil.safeBD(lca.getLiabilitiesQuantity());
BigDecimal firstLegAmount = BigDecimalUtil.safeBD(executionDeposit.getFirstLegAmount());
lca.setLiabilitiesQuantity(prevLQuantity.add(firstLegAmount));
}
if (bClrn) {
BigDecimal prevCQuantity = BigDecimalUtil.safeBD(lca.getClaimsQuantity());
BigDecimal firstLegAmount = BigDecimalUtil.safeBD(executionDeposit.getFirstLegAmount());
lca.setClaimsQuantity(prevCQuantity.add(firstLegAmount));
}
//
//Клиринг (по второй ноге и категория I и счет CLRN):
//не меняется.
//
// Клиринг (по первой ноге и категория V и счет INFO):
//текущее значение liabilitiesClaimsAssets.liabilitiesQuantity + executionDeposit.firstLegAmount
//
//Клиринг (по второй ноге и категория V и счет INFO):
//не меняется.
//
//Клиринг (по первой ноге и категория B и счет CLRN):
//не меняется.
//
//Клиринг (по второй ноге и категория B и счет CLRN):
//= текущее значение liabilitiesClaimsAssets.liabilitiesQuantity + executionDeposit.secondLegAmount
}
}