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

D**V registries

Browse source
This commit is contained in:
ialbert 2023-09-13 17:31:53 +03:00
parent 41d66b9e96
commit 9c559b5c80
8 changed files with 232 additions and 13 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -10,6 +10,7 @@ import ru.clearing.classes.statics.data.account.AccountBalance;
import ru.clearing.classes.statics.data.account.ClearingAccount;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.misc.Currency;
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.SDf02;
@ -60,6 +61,7 @@ import java.util.function.Consumer;
import java.util.function.Function;
import java.util.regex.Pattern;
import static ru.spcex.platform.enumeration.RegistryTradingParams.D__V;
import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
@Service
@ -69,6 +71,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
private final Imdg<Statement> statementImdg;
private final Imdg<Registry> registryImdg;
private final Imdg<Session> sessionImdg;
private final Function<SDf57, IValidator> sDf57Validator;
private final LoggingService errorLogger;
private final Imdg<SDf02> sdf02Imdg;
@ -103,6 +106,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
this.sDf57Validator = sDf57Validator;
this.errorLogger = errorLogger;
this.imdgProvider = imdgProvider;
@ -676,6 +680,21 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
private AssetOperationListRequest gatewayRequest(Statement stmt, String tradingCode, String tcrCode) {
AssetOperationListRequest gatewayRequest = new AssetOperationListRequest();
AssetOperationRequest req = GatewayRequestCreator.gatewayRequestPart(stmt, tradingCode, tcrCode);
Session existActiveSession = sessionImdg.getFirstObjectByFieldValues(Map.of(
"workflowStatus", SessionStatus.ACTV.getKey()
));
if (existActiveSession != null) {
log.debug("active session.id={} type {}", existActiveSession.getId(), existActiveSession.getSessionType());
List<Registry> d__vs = assets.searchByParams(stmt.getAccount(), CurrencyCode.RUB.getKey(), stmt.getSenderId(), D__V)
.stream()
.filter(rgs -> existActiveSession.getId().equals(rgs.getSessionId()))
.toList();
BigDecimal d__vSum = d__vs.stream()
.map(rgs -> safeBD(rgs.getBalance()))
.reduce(BigDecimal.ZERO, BigDecimal::add);
BigDecimal amount = req.getAmount();
req.setAmount(safeBD(amount).subtract(d__vSum));
}
gatewayRequest.setAssetOperationRequests(List.of(req));
return gatewayRequest;
}

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

@ -15,7 +15,6 @@ 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;
import java.math.BigDecimal;
import java.time.Instant;
@ -43,18 +42,25 @@ public class AssetTBFProcessing {
safeWrapField(am_t::getBalance, am_t::setBalance);
safeWrapField(am_b::getBalance, am_b::setBalance);
safeWrapField(am_f::getBalance, am_f::setBalance);
Collection<Registry> d__is = searchD__i(am_b.getAccount(),
Collection<Registry> d__is = searchByParams(am_b.getAccount(),
am_b.getSecuritySymbol(),
am_b.getCompanyId(),
IEnumKey.getEnumByKey(RegistryInstrumentType.class, am_b.getRegistryInstrumentType()));
D__I.type(am_b.getRegistryInstrumentType()));
BigDecimal d__iSum = d__is.stream()
.filter(d__i -> safeBD(d__i.getBalance()).compareTo(BigDecimal.ZERO) < 0)
.map(rgs -> safeBD(rgs.getBalance()))
.reduce(BigDecimal.ZERO, BigDecimal::add);
Collection<Registry> d__vs = searchByParams(am_b.getAccount(),
am_b.getSecuritySymbol(),
am_b.getCompanyId(),
D__V.type(am_b.getRegistryInstrumentType()));
BigDecimal d__vSum = d__vs.stream()
.map(rgs -> safeBD(rgs.getBalance()))
.reduce(BigDecimal.ZERO, BigDecimal::add);
Instant now = Instant.now();
am_b.setBalance(am_b.getBalance().subtract(sum));
am_f.setBalance(am_t.getBalance().subtract(am_b.getBalance()).add(d__iSum));
am_f.setBalance(am_t.getBalance().subtract(am_b.getBalance()).add(d__iSum).subtract(d__vSum));
am_b.setUpdated(now);
am_f.setUpdated(now);
@ -62,15 +68,11 @@ public class AssetTBFProcessing {
rgsImdg.update(am_f);
}
private Collection<Registry> searchD__i(String account,
String securitySymbol,
Long companyId,
RegistryInstrumentType instrumentType) {
public Collection<Registry> searchByParams(String account,
String securitySymbol,
Long companyId,
RegistryTradingParams params) {
ImdgPredicateBuilder pb = rgsImdg.predicateBuilder();
RegistryTradingParams params = new RegistryTradingParams(
RegistryDesignation.D, instrumentType, null, RegistryUnit.I
);
ImdgPredicate d__iPrdct = pb.and(
pb.equals("account", account),
pb.equals("securitySymbol", securitySymbol),

98
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/PaymentStateMarkService.java Normal file
View file

@ -0,0 +1,98 @@
package ru.spcex.clearing.service.registry;
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.company.Company;
import ru.clearing.classes.statics.data.company.CompanyRoleSet;
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.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.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import static ru.spcex.platform.enumeration.RegistryTradingParams.CM_T;
import static ru.spcex.platform.enumeration.RegistryTradingParams.LM_T;
@Component
public class PaymentStateMarkService {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<Registry> rgsImdg;
private final Imdg<Company> cmpImdg;
private final Imdg<CompanyRoleSet> cmpRoleImdg;
private final AssetTBFProcessing assets;
@Autowired
public PaymentStateMarkService(ImdgProvider imdgProvider, AssetTBFProcessing assets) {
this.rgsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.cmpImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.cmpRoleImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class);
this.assets = assets;
}
public void createDmv(Long sessionId) {
ImdgPredicateBuilder pb = rgsImdg.predicateBuilder();
ImdgPredicate prdct = pb.and(
pb.sql(RegistryCodeSqlBuilder.getInstance(CM_T, LM_T).build()),
pb.equals("sessionId", sessionId),
pb.equals("registryStatus", RegistryStatus.OK.getKey())
);
Collection<Registry> claimsAndLiabilities = rgsImdg.getCollectionObjectsByPredicate(prdct);
Map<Long, List<Registry>> groups = claimsAndLiabilities
.stream()
.collect(Collectors.groupingBy(Registry::getGroupId));
log.debug("found {} ({} groups) CM*T/LM*T by {}", claimsAndLiabilities.size(), groups.size(), prdct.toString());
for (Map.Entry<Long, List<Registry>> group : groups.entrySet()) {
Long groupId = group.getKey();
Function<RegistryDesignation, Registry> findRgs = (rd) -> group.getValue()
.stream()
.filter(rgs -> rd.equalsByKey(rgs.getRegistryDesignation()))
.findFirst()
.orElse(null);
Registry cm_t = findRgs.apply(RegistryDesignation.C);
Registry lm_t = findRgs.apply(RegistryDesignation.L);
if (cm_t == null || lm_t == null) {
log.warn("groupId {}, coudn't find CM*T or LM*T", groupId);
continue;
}
CompanyRoleSet initRole = cmpRoleImdg.getFirstObjectBySQL(
"companyId = %d and companyRole = '%s' and workflowStatus = '%s'".formatted(
lm_t.getCompanyId(),
CompanyRole.ODEP.getKey(),
WorkflowStatus.Active.getKey()
)
);
if (initRole == null) {
log.debug("groupId {}, initiator (lm*t.id={}) does not have ODEP role", groupId, lm_t.getId());
continue;
}
Registry dm_v = cm_t.clone();
RegistryManager.zeroState(dm_v);
dm_v.setRegistryDesignation(RegistryDesignation.D.getKey());
dm_v.setRegistryUnit(RegistryUnit.V.getKey());
dm_v.setRegistryCode(RegistryUtil.clearingCode(dm_v));
dm_v.setBalance(cm_t.getBalance());
dm_v.setRegistryStatus(RegistryStatus.PROC.getKey());
rgsImdg.insert(dm_v);
log.debug("groupId {}, lm*t.id={}, cm*t.id={} created dm*v.id={}",
groupId, lm_t.getId(), cm_t.getId(), dm_v.getId());
Optional<AssetTrio> assetsFound = assets.searchMoneyByAccAndCompany(cm_t.getCompanyId(), cm_t.getAccountId());
assetsFound.ifPresent(assetTrio
-> assets.process(assetTrio.a__b(), assetTrio.a__t(), assetTrio.a__f(), BigDecimal.ZERO));
}
}
}

1
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/FinalMkrSession.java
View file

@ -109,6 +109,7 @@ public class FinalMkrSession extends AbstractSession implements InitializingBean
inspectionObligationsReturn.setSessionType(sessionType());
inspectionObligations.setSessionType(sessionType());
formingPaymentInstructionDeals.setSection(section());
formingPaymentInstructionDeals.setSessionType(sessionType());
imdgProvider.waitAvailable();
initSessionIfPresent();
}

13
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionAssets.java
View file

@ -21,6 +21,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.importexport.SwtExporterR
import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
import ru.spcex.clearing.service.Sdf03Creator;
import ru.spcex.clearing.service.builder.PaymentInstructionBuilderV2;
import ru.spcex.clearing.service.registry.PaymentStateMarkService;
import ru.spcex.clearing.service.registry.RegistryManager;
import ru.spcex.clearing.session.stage.ISessionStage;
import ru.spcex.clearing.session.stage.StageResult;
@ -68,10 +69,12 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
private final SecuritySelector<Security> securitySelector;
private final RegistryManager rgsMng;
private Section section;
private SessionType sessionType;
private final PaymentStateMarkService dmvSrv;
@Autowired
public FormingPaymentInstructionAssets(ImdgProvider imdgProvider,
Sdf03Creator sdf03Creator, KafkaSender kafkaSender, RegistryManager rgsMng) {
Sdf03Creator sdf03Creator, KafkaSender kafkaSender, RegistryManager rgsMng, PaymentStateMarkService dmvSrv) {
this.sdf03Creator = sdf03Creator;
this.kafkaSender = kafkaSender;
this.imdgProvider = imdgProvider;
@ -85,6 +88,7 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
this.paymentInstructionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
this.rgsMng = rgsMng;
this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class);
this.dmvSrv = dmvSrv;
}
@Override
@ -126,6 +130,9 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
private StageResult<?> formingPaymentInstructions(FormingPaymentInstructionPayload payload) {
Long sessionId = payload.getSessionId();
if (SessionType.FINL.equals(sessionType)) {
dmvSrv.createDmv(sessionId);
}
Collection<Registry> AMBregistries = selectAMBRegistries(sessionId);
log.debug("found AMB registries.size() = {}", AMBregistries.size());
Instant now = Instant.now();
@ -398,4 +405,8 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
public void setSection(Section section) {
this.section = section;
}
public void setSessionType(SessionType sessionType) {
this.sessionType = sessionType;
}
}

19
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CompanyRole.java Normal file
View file

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

68
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/RegistryTradingParams.java
View file

@ -1,5 +1,7 @@
package ru.spcex.platform.enumeration;
import ru.spcex.platform.utils.enumeration.IEnumKey;
public record RegistryTradingParams(RegistryDesignation registryDesignation,
RegistryInstrumentType registryInstrumentType,
RegistryCapacity registryCapacity,
@ -14,6 +16,67 @@ public record RegistryTradingParams(RegistryDesignation registryDesignation,
return isEqualDesignation && isEqualInstrumentType && isEqualCapacity && isEqualUnit;
}
public RegistryTradingParams dsgn(RegistryDesignation registryDesignation) {
return new RegistryTradingParams(registryDesignation,
registryInstrumentType,
registryCapacity,
registryUnit);
}
public RegistryTradingParams dsgn(String registryDesignationS) {
RegistryDesignation registryDesignation = IEnumKey.getEnumByKey(RegistryDesignation.class, registryDesignationS);
return new RegistryTradingParams(registryDesignation,
registryInstrumentType,
registryCapacity,
registryUnit);
}
public RegistryTradingParams type(RegistryInstrumentType registryInstrumentType) {
return new RegistryTradingParams(registryDesignation,
registryInstrumentType,
registryCapacity,
registryUnit);
}
public RegistryTradingParams type(String registryInstrumentTypeS) {
RegistryInstrumentType registryInstrumentType = IEnumKey.getEnumByKey(RegistryInstrumentType.class,
registryInstrumentTypeS);
return new RegistryTradingParams(registryDesignation,
registryInstrumentType,
registryCapacity,
registryUnit);
}
public RegistryTradingParams cpcty(RegistryCapacity registryCapacity) {
return new RegistryTradingParams(registryDesignation,
registryInstrumentType,
registryCapacity,
registryUnit);
}
public RegistryTradingParams cpcty(String registryCapacityS) {
RegistryCapacity registryCapacity = IEnumKey.getEnumByKey(RegistryCapacity.class, registryCapacityS);
return new RegistryTradingParams(registryDesignation,
registryInstrumentType,
registryCapacity,
registryUnit);
}
public RegistryTradingParams unit(RegistryUnit registryUnit) {
return new RegistryTradingParams(registryDesignation,
registryInstrumentType,
registryCapacity,
registryUnit);
}
public RegistryTradingParams unit(String registryUnitS) {
RegistryUnit registryUnit = IEnumKey.getEnumByKey(RegistryUnit.class, registryUnitS);
return new RegistryTradingParams(registryDesignation,
registryInstrumentType,
registryCapacity,
registryUnit);
}
public final static RegistryTradingParams OS_T;
public final static RegistryTradingParams OM_T;
public final static RegistryTradingParams TS_T;
@ -42,6 +105,7 @@ public record RegistryTradingParams(RegistryDesignation registryDesignation,
public final static RegistryTradingParams LM__;
public final static RegistryTradingParams DMAU;
public final static RegistryTradingParams D__I;
public final static RegistryTradingParams D__V;
static {
OS_T = new RegistryTradingParams(RegistryDesignation.O,
@ -157,6 +221,10 @@ public record RegistryTradingParams(RegistryDesignation registryDesignation,
null,
null,
RegistryUnit.I);
D__V = new RegistryTradingParams(RegistryDesignation.D,
null,
null,
RegistryUnit.V);
}
}

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

@ -11,6 +11,7 @@ public enum RegistryUnit implements IEnumKey {
X("X"),
U("U"),
I("I"),
V("V"),
;
private final String key;