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

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

Browse source 
---
registry service update
This commit is contained in:
aalehin 2023-05-22 16:50:58 +03:00
parent 343497b556
commit 91b7b99f86
10 changed files with 424 additions and 187 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/register/MoneyBalanceRegister.java
View file

@ -7,7 +7,7 @@ import java.math.BigDecimal;
/**
* Реестр остатков денежных средств
*
* <p>
* DB table: MONEY_BALANCE_REGISTER
**/
public class MoneyBalanceRegister extends BusinessObject {
@ -24,74 +24,108 @@ public class MoneyBalanceRegister extends BusinessObject {
private String companyFullName;
private Long companyId;
public static MoneyBalanceRegister makeMoneyBalanceRegister(String setHouseName,
String account,
String infoAccount,
BigDecimal remainderSum,
BigDecimal blockedSum,
BigDecimal unblockedSum,
String inn,
Long sessionId,
String companyFullName,
Long companyId) {
MoneyBalanceRegister moneyBalanceRegister = new MoneyBalanceRegister();
moneyBalanceRegister.setSetHouseName(setHouseName);
moneyBalanceRegister.setAccount(account);
moneyBalanceRegister.setInfoAccount(infoAccount);
moneyBalanceRegister.setRemainderSum(remainderSum);
moneyBalanceRegister.setBlockedSum(blockedSum);
moneyBalanceRegister.setUnblockedSum(unblockedSum);
moneyBalanceRegister.setInn(inn);
moneyBalanceRegister.setSessionId(sessionId);
moneyBalanceRegister.setCompanyFullName(companyFullName);
moneyBalanceRegister.setCompanyId(companyId);
return moneyBalanceRegister;
}
public String getSetHouseName() {
return setHouseName;
}
public void setSetHouseName(String value) {
this.setHouseName=value;
this.setHouseName = value;
}
public String getAccount() {
return account;
}
public void setAccount(String value) {
this.account=value;
this.account = value;
}
public String getInfoAccount() {
return infoAccount;
}
public void setInfoAccount(String value) {
this.infoAccount=value;
this.infoAccount = value;
}
public BigDecimal getRemainderSum() {
return remainderSum;
}
public void setRemainderSum(BigDecimal value) {
this.remainderSum=value;
this.remainderSum = value;
}
public BigDecimal getBlockedSum() {
return blockedSum;
}
public void setBlockedSum(BigDecimal value) {
this.blockedSum=value;
this.blockedSum = value;
}
public BigDecimal getUnblockedSum() {
return unblockedSum;
}
public void setUnblockedSum(BigDecimal value) {
this.unblockedSum=value;
this.unblockedSum = value;
}
public String getInn() {
return inn;
}
public void setInn(String value) {
this.inn=value;
this.inn = value;
}
public Long getSessionId() {
return sessionId;
}
public void setSessionId(Long value) {
this.sessionId=value;
this.sessionId = value;
}
public String getCompanyFullName() {
return companyFullName;
}
public void setCompanyFullName(String value) {
this.companyFullName=value;
this.companyFullName = value;
}
public Long getCompanyId() {
return companyId;
}
public void setCompanyId(Long value) {
this.companyId=value;
this.companyId = value;
}
}

82
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterService.java
View file

@ -6,19 +6,31 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.register.AdmittedLiabilitiesRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.security.Security;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.AdmittedLiabilitiesRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Optional;
import static ru.spcex.platform.enumeration.Task.createRegistry_GRRT;
public class AdmittedLiabilitiesRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<AdmittedLiabilitiesRegister> admittedLiabilitiesRegisterMap;
private final Imdg<Registry> registryMap;
private final Imdg<Company> companyMap;
private final Imdg<Security> securityMap;
@Autowired
public AdmittedLiabilitiesRegisterService(Consumer<String, Object> kafkaQueue,
@ -26,33 +38,59 @@ public class AdmittedLiabilitiesRegisterService extends QueueConsumer implements
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.admittedLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister, AdmittedLiabilitiesRegister.class);
this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.securityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
}
@Override
public void afterPropertiesSet() {
callback(AdmittedLiabilitiesRegisterNewRequest.class)
callback(LauncherCommandRequest.class)
.setConsumer(this::admittedLiabilitiesRegisterNew)
.forDestination(Consts.REGISTRY_ADMITTED_LIABILITIES_REGISTER_NEW, callbacks::put);
.forDestination(createRegistry_GRRT.topic(), callbacks::put);//TODO FIX UP WHAT KIND OF TOPIC
init();
}
public void admittedLiabilitiesRegisterNew(BaseRequest<AdmittedLiabilitiesRegisterNewRequest> userRequest) {
AdmittedLiabilitiesRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("AdmittedLiabilitiesRegisterNewRequest received");
AdmittedLiabilitiesRegister register = new AdmittedLiabilitiesRegister();
register.setSecuritySymbol(req.getSecuritySymbol());
register.setSecurityFullName(req.getSecurityFullName());
register.setSessionId(req.getSessionId());
register.setClearingCode(req.getClearingCode());
register.setAccount(req.getAccount());
register.setCompanyId(req.getCompanyId());
register.setAmount(req.getAmount());
register.setId(req.getId());
register.setCreated(req.getCreatedAt());
register.setUpdated(req.getUpdatedAt());
register.setClearingDate(req.getClearingDate());
register.setCompanyFullName(req.getCompanyFullName());
admittedLiabilitiesRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
public void admittedLiabilitiesRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GRRT.topic()); //TODO FIX UP WHAT KIND OF TOPIC
List<Registry> registries = registryMap.getAllValues().stream().filter((x) -> {
return x.getRegistryDesignation().equalsIgnoreCase("O") &&
x.getRegistryCapacity().equalsIgnoreCase("P") &&
x.getRegistryCode().equalsIgnoreCase("T") &&
(x.getRegistryInstrumentType().equalsIgnoreCase("S")
|| x.getRegistryInstrumentType().equalsIgnoreCase("M"));
}
).toList();
HashMap<Long, Long> sessionIdByCompanyId = new HashMap<>();
Collection<AdmittedLiabilitiesRegister> collection = admittedLiabilitiesRegisterMap.getAllValues();
collection.forEach(x -> sessionIdByCompanyId.put(x.getCompanyId(), x.getSessionId()));
registries.forEach(x -> {
Long existingCompanySessionId = sessionIdByCompanyId.get(x.getCompanyId());
if (existingCompanySessionId == null) {
insertAdmittedLiabilitiesRegister(x);
}
});
log.debug("successfully processed");
}
private void insertAdmittedLiabilitiesRegister(Registry registry) {
AdmittedLiabilitiesRegister admittedLiabilitiesRegister = new AdmittedLiabilitiesRegister();
Optional<Company> company = companyMap.getAllValues().stream().filter((x)-> x.getId() == 1L).findFirst();
Optional<Security> security = securityMap.getAllValues().stream().filter((x)-> x.getId().equals(registry.getSecurityId())).findFirst();
String securitySymbol = security.map(Security::getSecuritySymbol).orElse(null);
String securityFullName = security.map(Security::getShortName).orElse(null);
String companyFullName = company.map(Company::getFullName).orElse(null);
admittedLiabilitiesRegister.setCompanyFullName(companyFullName);
admittedLiabilitiesRegister.setSessionId(registry.getSessionId());
admittedLiabilitiesRegister.setSecuritySymbol(securitySymbol);
admittedLiabilitiesRegister.setSecurityFullName(securityFullName);
admittedLiabilitiesRegister.setCompanyId(registry.getCompanyId());
admittedLiabilitiesRegister.setClearingCode(registry.getClearingCode());
admittedLiabilitiesRegister.setAccount(registry.getAccount());
admittedLiabilitiesRegister.setAmount(registry.getBalance());
admittedLiabilitiesRegister.setClearingDate(registry.getClearingDate());
admittedLiabilitiesRegisterMap.insert(admittedLiabilitiesRegister);
}
}

85
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterService.java
View file

@ -6,19 +6,31 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.register.CoveredLiabilitiesRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.security.Security;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.CoveredLiabilitiesRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Optional;
import static ru.spcex.platform.enumeration.Task.createRegistry_GRRT;
public class CoveredLiabilitiesRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<CoveredLiabilitiesRegister> coveredLiabilitiesRegisterMap;
private final Imdg<Registry> registryMap;
private final Imdg<Company> companyMap;
private final Imdg<Security> securityMap;
@Autowired
public CoveredLiabilitiesRegisterService(Consumer<String, Object> kafkaQueue,
@ -26,33 +38,62 @@ public class CoveredLiabilitiesRegisterService extends QueueConsumer implements
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.coveredLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CoveredLiabilitiesRegister, CoveredLiabilitiesRegister.class);
this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.securityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
}
@Override
public void afterPropertiesSet() {
callback(CoveredLiabilitiesRegisterNewRequest.class)
callback(LauncherCommandRequest.class)
.setConsumer(this::coveredLiabilitiesRegisterNew)
.forDestination(Consts.REGISTRY_COVERED_LIABILITIES_REGISTER_NEW, callbacks::put);
.forDestination(createRegistry_GRRT.topic(), callbacks::put);//TODO FIX UP WHAT KIND OF TOPIC
init();
}
public void coveredLiabilitiesRegisterNew(BaseRequest<CoveredLiabilitiesRegisterNewRequest> userRequest) {
CoveredLiabilitiesRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("CoveredLiabilitiesRegisterNewRequest received");
CoveredLiabilitiesRegister register = new CoveredLiabilitiesRegister();
register.setCompanyFullName(req.getCompanyFullName());
register.setSessionId(req.getSessionId());
register.setSecuritySymbol(req.getSecuritySymbol());
register.setSecurityFullName(req.getSecurityFullName());
register.setCompanyId(req.getCompanyId());
register.setClearingCode(req.getClearingCode());
register.setAccount(req.getAccount());
register.setAmount(req.getAmount());
register.setId(req.getId());
register.setCreated(req.getCreatedAt());
register.setUpdated(req.getUpdatedAt());
register.setClearingDate(req.getClearingDate());
coveredLiabilitiesRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
public void coveredLiabilitiesRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GRRT.topic()); //TODO FIX UP WHAT KIND OF TOPIC
HashMap<Long, Long> sessionIdByCompanyId = new HashMap<>();
List<Registry> registries = registryMap.getAllValues().stream().filter((x) -> {
return x.getRegistryDesignation().equalsIgnoreCase("O") &&
x.getRegistryCapacity().equalsIgnoreCase("P") &&
x.getRegistryCode().equalsIgnoreCase("T") &&
(x.getRegistryInstrumentType().equalsIgnoreCase("S")
|| x.getRegistryInstrumentType().equalsIgnoreCase("M")) &&
(x.getRegistryStatus().equalsIgnoreCase("OK") ||
x.getRegistryStatus().equalsIgnoreCase("PROC"));
}
).toList();
Collection<CoveredLiabilitiesRegister> collection = coveredLiabilitiesRegisterMap.getAllValues();
collection.forEach(x -> sessionIdByCompanyId.put(x.getCompanyId(), x.getSessionId()));
registries.forEach(x -> {
Long existingCompanySessionId = sessionIdByCompanyId.get(x.getCompanyId());
if (existingCompanySessionId == null) {
insertCoveredLiabilitiesRegister(x);
}
});
log.debug("successfully processed");
}
private void insertCoveredLiabilitiesRegister(Registry registry) {
CoveredLiabilitiesRegister coveredLiabilitiesRegister = new CoveredLiabilitiesRegister();
Optional<Company> company = companyMap.getAllValues().stream().filter((x) -> x.getId() == 1L).findFirst();
Optional<Security> security = securityMap.getAllValues().stream().filter((x) -> x.getId().equals(registry.getSecurityId())).findFirst();
String securitySymbol = security.map(Security::getSecuritySymbol).orElse(null);
String securityFullName = security.map(Security::getShortName).orElse(null);
String companyFullName = company.map(Company::getFullName).orElse(null);
coveredLiabilitiesRegister.setCompanyFullName(companyFullName);
coveredLiabilitiesRegister.setSessionId(registry.getSessionId());
coveredLiabilitiesRegister.setSecurityFullName(securityFullName);
coveredLiabilitiesRegister.setCompanyId(registry.getCompanyId());
coveredLiabilitiesRegister.setClearingCode(registry.getClearingCode());
coveredLiabilitiesRegister.setAccount(registry.getAccount());
coveredLiabilitiesRegister.setAmount(registry.getBalance());
coveredLiabilitiesRegister.setClearingDate(registry.getClearingDate());
coveredLiabilitiesRegisterMap.insert(coveredLiabilitiesRegister);
}
}

57
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterService.java
View file

@ -8,19 +8,27 @@ import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.register.DepoBalanceRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.DepoBalanceRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.time.Instant;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import static ru.spcex.platform.enumeration.Task.createRegistry_GRRT;
@Service
public class DepoBalanceRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<DepoBalanceRegister> depoBalanceRegisterMap;
private final Imdg<Registry> registryMap;
@Autowired
public DepoBalanceRegisterService(Consumer<String, Object> kafkaQueue,
@ -28,29 +36,42 @@ public class DepoBalanceRegisterService extends QueueConsumer implements Initial
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.depoBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoBalanceRegister, DepoBalanceRegister.class);
this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
}
@Override
public void afterPropertiesSet() {
callback(DepoBalanceRegisterNewRequest.class)
callback(LauncherCommandRequest.class)
.setConsumer(this::depoBalanceRegisterNew)
.forDestination(Consts.REGISTRY_DEPO_BALANCE_REGISTER_NEW, callbacks::put);
.forDestination(createRegistry_GRRT.topic(), callbacks::put);
init();
}
public void depoBalanceRegisterNew(BaseRequest<DepoBalanceRegisterNewRequest> userRequest) {
DepoBalanceRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("DepoBalanceRegisterNewRequest received");
DepoBalanceRegister register = new DepoBalanceRegister();
register.setId(req.getId());
register.setCreated(req.getCreatedAt());
register.setUpdated(req.getUpdatedAt());
register.setCompanyId(req.getCompanyId());
register.setSessionId(req.getSessionId());
register.setDepoCode(req.getDepoCode());
register.setQuantity(req.getQuantity());
register.setSecuritySymbol(req.getSecuritySymbol());
depoBalanceRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
public void depoBalanceRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GRRT.topic());
HashMap<Long, Long> sessionIdByCompanyId = new HashMap<>();
List<Registry> registries = registryMap.getAllValues().stream().filter((x) -> x.getAccountType().equalsIgnoreCase("DEPO")).toList();
Collection<DepoBalanceRegister> collection = depoBalanceRegisterMap.getAllValues();
collection.forEach(x -> sessionIdByCompanyId.put(x.getCompanyId(), x.getSessionId()));
registries.forEach(x -> {
Long existingCompanySessionId = sessionIdByCompanyId.get(x.getCompanyId());
if (existingCompanySessionId == null) {
insertDepoBalanceRegister(x);
}
});
log.debug("successfully processed");
}
private void insertDepoBalanceRegister(Registry registry) {
DepoBalanceRegister depoBalanceRegister = new DepoBalanceRegister();
depoBalanceRegister.setUpdated(Instant.now());
depoBalanceRegister.setCreated(Instant.now());
depoBalanceRegister.setCompanyId(registry.getCompanyId());
depoBalanceRegister.setSessionId(registry.getSessionId());
depoBalanceRegister.setDepoCode(registry.getAccountType());
depoBalanceRegister.setQuantity(registry.getCloseBalance());
depoBalanceRegister.setSecuritySymbol(registry.getSecuritySymbol());
depoBalanceRegisterMap.insert(depoBalanceRegister);
}
}

73
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterService.java
View file

@ -6,19 +6,31 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import ru.clearing.classes.statics.data.misc.Session;
import ru.clearing.classes.statics.data.payment.PaymentInstruction;
import ru.clearing.classes.statics.data.register.DepoPaymentInstructionRegister;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.DepoPaymentInstructionRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import static ru.spcex.platform.enumeration.Task.createRegistry_GORR;
import static ru.spcex.platform.enumeration.Task.createRegistry_GRRT;
public class DepoPaymentInstructionRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<DepoPaymentInstructionRegister> depoPaymentInstructionRegisterMap;
private final Imdg<PaymentInstruction> paymentInstructionMap;
private final Imdg<Session> sessionMap;
private final Imdg<TradingClearingRegistry> tradingClearingRegistryMap;
@Autowired
public DepoPaymentInstructionRegisterService(Consumer<String, Object> kafkaQueue,
@ -26,31 +38,52 @@ public class DepoPaymentInstructionRegisterService extends QueueConsumer impleme
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.depoPaymentInstructionRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoPaymentInstructionRegister, DepoPaymentInstructionRegister.class);
this.paymentInstructionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
this.tradingClearingRegistryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
}
@Override
public void afterPropertiesSet() {
callback(DepoPaymentInstructionRegisterNewRequest.class)
callback(LauncherCommandRequest.class)
.setConsumer(this::depoPaymentInstructionRegisterNew)
.forDestination(Consts.REGISTRY_DEPO_PAYMENT_INSTRUCTION_REGISTER_NEW, callbacks::put);
.forDestination(createRegistry_GRRT.topic(), callbacks::put);
init();
}
public void depoPaymentInstructionRegisterNew(BaseRequest<DepoPaymentInstructionRegisterNewRequest> userRequest) {
DepoPaymentInstructionRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("DepoPaymentInstructionRegisterNewRequest received");
DepoPaymentInstructionRegister register = new DepoPaymentInstructionRegister();
register.setId(req.getId());
register.setCreated(req.getCreatedAt());
register.setUpdated(req.getUpdatedAt());
register.setCompanyId(req.getCompanyId());
register.setTradingClearingRegistryType(req.getTradingClearingRegistryType());
register.setTradingClearingRegistry(req.getTradingClearingRegistry());
register.setCbCode(req.getCbCode());
register.setQuantity(req.getQuantity());
register.setDirection(req.getDirection());
register.setSessionId(req.getSessionId());
depoPaymentInstructionRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
public void depoPaymentInstructionRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GORR.topic());
HashMap<Long, PaymentInstruction> sessionIdByPaymentInstructions = new HashMap<>();
paymentInstructionMap.getAllValues().stream().forEach(x -> sessionIdByPaymentInstructions.put(x.getSessionId(), x));
List<Session> actualSession = sessionMap.getAllValues().stream().filter(x ->
sessionIdByPaymentInstructions.containsKey(x.getId()) && x.getSection().equalsIgnoreCase("FOND")
).toList();
HashMap<Long, Long> sessionIdByCompanyId = new HashMap<>();
Collection<DepoPaymentInstructionRegister> collection = depoPaymentInstructionRegisterMap.getAllValues();
collection.forEach(x -> sessionIdByCompanyId.put(x.getCompanyId(), x.getSessionId()));
actualSession.forEach(x -> {
Long existingCompanySessionId = sessionIdByCompanyId.get(x.getCompanyId());
if (existingCompanySessionId == null) {
insertDepoPaymentInstructionRegister(sessionIdByPaymentInstructions.get(x.getId()));
}
});
log.debug("successfully processed");
}
private void insertDepoPaymentInstructionRegister(PaymentInstruction paymentInstruction) {
DepoPaymentInstructionRegister depoPaymentInstructionRegister = new DepoPaymentInstructionRegister();
//todo fix up Optional<TradingClearingRegistry> tradingClearingRegistry = tradingClearingRegistryMap.getAllValues().stream().filter((x)-> x.getCompanyId().equals(paymentInstruction.getCompanyId())).findFirst();
depoPaymentInstructionRegister.setCompanyId(paymentInstruction.getSenderId());
//todo fix up depoPaymentInstructionRegister.setTradingClearingRegistryType();
//todo fix up depoPaymentInstructionRegister.setTradingClearingRegistry();
depoPaymentInstructionRegister.setCbCode("=RNCB-BE-01");
depoPaymentInstructionRegister.setQuantity(paymentInstruction.getCreditLeg_amount());
//todo fix up depoPaymentInstructionRegister.setDirection(paymentInstruction.getCreditLeg_direction());
depoPaymentInstructionRegister.setSessionId(paymentInstruction.getSessionId());
depoPaymentInstructionRegisterMap.insert(depoPaymentInstructionRegister);
}
}

64
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterService.java
View file

@ -7,18 +7,25 @@ import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import ru.clearing.classes.statics.data.register.ExcludeLiabilitiesRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.ExcludeLiabilitiesRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import static ru.spcex.platform.enumeration.Task.createRegistry_GRRT;
public class ExcludeLiabilitiesRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<ExcludeLiabilitiesRegister> excludeLiabilitiesRegisterMap;
private final Imdg<Registry> registryMap;
@Autowired
public ExcludeLiabilitiesRegisterService(Consumer<String, Object> kafkaQueue,
@ -26,37 +33,44 @@ public class ExcludeLiabilitiesRegisterService extends QueueConsumer implements
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.excludeLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class);
this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
}
@Override
public void afterPropertiesSet() {
callback(ExcludeLiabilitiesRegisterNewRequest.class)
callback(LauncherCommandRequest.class)
.setConsumer(this::excludeLiabilitiesRegisterNew)
.forDestination(Consts.REGISTRY_DEPO_PAYMENT_INSTRUCTION_REGISTER_NEW, callbacks::put);
.forDestination(createRegistry_GRRT.topic(), callbacks::put);//TODO FIX UP WHAT KIND OF TOPIC
init();
}
public void excludeLiabilitiesRegisterNew(BaseRequest<ExcludeLiabilitiesRegisterNewRequest> userRequest) {
ExcludeLiabilitiesRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("ExcludeLiabilitiesRegisterNewRequest received");
ExcludeLiabilitiesRegister register = new ExcludeLiabilitiesRegister();
register.setId(req.getId());
register.setCreated(req.getCreatedAt());
register.setUpdated(req.getUpdatedAt());
register.setSessionId(req.getSessionId());
register.setValidFromDate(req.getValidFromDate());
register.setValidToDate(req.getValidToDate());
register.setCompanyId(req.getCompanyId());
register.setCompanyFullName(req.getCompanyFullName());
register.setInn(req.getInn());
register.setSegment(req.getSegment());
register.setRegistryCode(req.getRegistryCode());
register.setAccount(req.getAccount());
register.setRegistryStatus(req.getRegistryStatus());
register.setCurrency(req.getCurrency());
register.setSumLiabilities(req.getSumLiabilities());
excludeLiabilitiesRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
public void excludeLiabilitiesRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GRRT.topic()); //TODO FIX UP WHAT KIND OF TOPIC
HashMap<Long, Long> sessionIdByCompanyId = new HashMap<>();
List<Registry> registries = registryMap.getAllValues().stream().filter((x) -> {
return x.getRegistryDesignation().equalsIgnoreCase("O") &&
x.getRegistryCapacity().equalsIgnoreCase("P") &&
x.getRegistryCode().equalsIgnoreCase("T") &&
(x.getRegistryInstrumentType().equalsIgnoreCase("S")
|| x.getRegistryInstrumentType().equalsIgnoreCase("M")) &&
x.getRegistryStatus().equalsIgnoreCase("FAIL");
}
).toList();
Collection<ExcludeLiabilitiesRegister> collection = excludeLiabilitiesRegisterMap.getAllValues();
collection.forEach(x -> sessionIdByCompanyId.put(x.getCompanyId(), x.getSessionId()));
registries.forEach(x -> {
Long existingCompanySessionId = sessionIdByCompanyId.get(x.getCompanyId());
if (existingCompanySessionId == null) {
insertExcludeLiabilitiesRegister(x);
}
});
log.debug("successfully processed");
}
private void insertExcludeLiabilitiesRegister(Registry registry) {
ExcludeLiabilitiesRegister excludeLiabilitiesRegister = new ExcludeLiabilitiesRegister();
//TODO MAPPING
excludeLiabilitiesRegisterMap.insert(excludeLiabilitiesRegister);
}
}

65
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterService.java
View file

@ -7,18 +7,25 @@ import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import ru.clearing.classes.statics.data.register.LiabilitiesRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.LiabilitiesRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import static ru.spcex.platform.enumeration.Task.createRegistry_GRRT;
public class LiabilitiesRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<LiabilitiesRegister> liabilitiesRegisterMap;
private final Imdg<Registry> registryMap;
@Autowired
public LiabilitiesRegisterService(Consumer<String, Object> kafkaQueue,
@ -26,37 +33,43 @@ public class LiabilitiesRegisterService extends QueueConsumer implements Initial
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.liabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class);
this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
}
@Override
public void afterPropertiesSet() {
callback(LiabilitiesRegisterNewRequest.class)
callback(LauncherCommandRequest.class)
.setConsumer(this::liabilitiesRegisterNew)
.forDestination(Consts.REGISTRY_LIABILITIES_REGISTER_NEW, callbacks::put);
.forDestination(createRegistry_GRRT.topic(), callbacks::put);//TODO FIX UP WHAT KIND OF TOPIC
init();
}
public void liabilitiesRegisterNew(BaseRequest<LiabilitiesRegisterNewRequest> userRequest) {
LiabilitiesRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("LiabilitiesRegisterNewRequest received");
LiabilitiesRegister register = new LiabilitiesRegister();
register.setId(req.getId());
register.setCreated(req.getCreatedAt());
register.setUpdated(req.getUpdatedAt());
register.setSessionId(req.getSessionId());
register.setValidFromDate(req.getValidFromDate());
register.setValidToDate(req.getValidToDate());
register.setCompanyId(req.getCompanyId());
register.setCompanyFullName(req.getCompanyFullName());
register.setInn(req.getInn());
register.setSegment(req.getSegment());
register.setRegistryCode(req.getRegistryCode());
register.setAccount(req.getAccount());
register.setRegistryStatus(req.getRegistryStatus());
register.setCurrency(req.getCurrency());
register.setSumLiabilities(req.getSumLiabilities());
register.setSettlementDate(req.getSettlementDate());
liabilitiesRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
public void liabilitiesRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GRRT.topic()); //TODO FIX UP WHAT KIND OF TOPIC
HashMap<Long, Long> sessionIdByCompanyId = new HashMap<>();
List<Registry> registries = registryMap.getAllValues().stream().filter((x) -> {
return x.getRegistryDesignation().equalsIgnoreCase("L") &&
x.getRegistryCapacity().equalsIgnoreCase("P") &&
x.getRegistryCode().equalsIgnoreCase("T") &&
(x.getRegistryInstrumentType().equalsIgnoreCase("S")
|| x.getRegistryInstrumentType().equalsIgnoreCase("M"));
}
).toList();
Collection<LiabilitiesRegister> collection = liabilitiesRegisterMap.getAllValues();
collection.forEach(x -> sessionIdByCompanyId.put(x.getCompanyId(), x.getSessionId()));
registries.forEach(x -> {
Long existingCompanySessionId = sessionIdByCompanyId.get(x.getCompanyId());
if (existingCompanySessionId == null) {
insertLiabilitiesRegister(x);
}
});
log.debug("successfully processed");
}
private void insertLiabilitiesRegister(Registry registry) {
LiabilitiesRegister liabilitiesRegister = new LiabilitiesRegister();
//TODO FIX UP
liabilitiesRegisterMap.insert(liabilitiesRegister);
}
}

72
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterService.java
View file

@ -6,19 +6,31 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanySymbols;
import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.MoneyBalanceRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Optional;
import static ru.spcex.platform.enumeration.Task.createRegistry_GBRR;
public class MoneyBalanceRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<MoneyBalanceRegister> moneyBalanceRegisterMap;
private final Imdg<Registry> registryMap;
private final Imdg<CompanySymbols> companySymbolsMap;
private final Imdg<Company> companyMap;
@Autowired
public MoneyBalanceRegisterService(Consumer<String, Object> kafkaQueue,
@ -26,34 +38,48 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.moneyBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class);
this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
}
@Override
public void afterPropertiesSet() {
callback(MoneyBalanceRegisterNewRequest.class)
callback(LauncherCommandRequest.class)
.setConsumer(this::moneyBalanceRegisterNew)
.forDestination(Consts.REGISTRY_MONEY_BALANCE_REGISTER_NEW, callbacks::put);
.forDestination(createRegistry_GBRR.topic(), callbacks::put);
init();
}
public void moneyBalanceRegisterNew(BaseRequest<MoneyBalanceRegisterNewRequest> userRequest) {
MoneyBalanceRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("MoneyBalanceRegisterNewRequest received");
MoneyBalanceRegister register = new MoneyBalanceRegister();
register.setSetHouseName(req.getSetHouseName());
register.setAccount(req.getAccount());
register.setInfoAccount(req.getInfoAccount());
register.setRemainderSum(req.getRemainderSum());
register.setBlockedSum(req.getBlockedSum());
register.setUnblockedSum(req.getUnblockedSum());
register.setInn(req.getInn());
register.setSessionId(req.getSessionId());
register.setCompanyFullName(req.getCompanyFullName());
register.setCompanyId(req.getCompanyId());
register.setId(req.getId());
register.setCreated(req.getCreatedAt());
register.setUpdated(req.getUpdatedAt());
moneyBalanceRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
public void moneyBalanceRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GBRR.topic());
HashMap<Long, Long> sessionIdByCompanyId = new HashMap<>();
List<Registry> registries = registryMap.getAllValues().stream().filter((x) -> x.getAccountType().equalsIgnoreCase("INFO") || x.getAccountType().equalsIgnoreCase("CLRN")).toList();
Collection<MoneyBalanceRegister> collection = moneyBalanceRegisterMap.getAllValues();
collection.forEach(x -> sessionIdByCompanyId.put(x.getCompanyId(), x.getSessionId()));
registries.forEach(x -> {
Long existingCompanySessionId = sessionIdByCompanyId.get(x.getCompanyId());
if (existingCompanySessionId == null) {
insertMoneyBalanceRegister(x);
}
});
log.debug("successfully processed");
}
private void insertMoneyBalanceRegister(Registry registry){
MoneyBalanceRegister moneyBalanceRegister = new MoneyBalanceRegister();
Optional<Company> company = companyMap.getAllValues().stream().filter((x)-> x.getId() == 2L).findFirst();
String setHouseName = company.map(Company::getShortName).orElse(null);
moneyBalanceRegister.setSetHouseName(setHouseName);
moneyBalanceRegister.setAccount(registry.getAccount());
moneyBalanceRegister.setInfoAccount(registry.getAccountType());
moneyBalanceRegister.setRemainderSum(registry.getCloseBalance());
Optional<CompanySymbols> companySymbol = companySymbolsMap.getAllValues().stream().filter((x)-> x.getCompanyId().equals(registry.getCompanyId())).findFirst();
String inn = companySymbol.map(CompanySymbols::getCompanySymbolValue).orElse(null);
moneyBalanceRegister.setInn(inn);
moneyBalanceRegister.setSessionId(registry.getSessionId());
//moneyBalanceRegister.setCompanyFullName(registry.getCompanyFullName()) todo resolve is it ok that it is empty technical task
moneyBalanceRegister.setCompanyId(registry.getCompanyId());
moneyBalanceRegisterMap.insert(moneyBalanceRegister);
}
}

55
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterService.java
View file

@ -6,19 +6,27 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import ru.clearing.classes.statics.data.misc.Session;
import ru.clearing.classes.statics.data.payment.PaymentInstruction;
import ru.clearing.classes.statics.data.register.MoneyPaymentInstructionRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.MoneyPaymentInstructionRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.HashMap;
import java.util.List;
import static ru.spcex.platform.enumeration.Task.createRegistry_GORR;
public class MoneyPaymentInstructionRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<MoneyPaymentInstructionRegister> moneyPaymentInstructionRegisterMap;
private final Imdg<PaymentInstruction> paymentInstructionMap;
private final Imdg<Session> sessionMap;
@Autowired
public MoneyPaymentInstructionRegisterService(Consumer<String, Object> kafkaQueue,
@ -26,31 +34,38 @@ public class MoneyPaymentInstructionRegisterService extends QueueConsumer implem
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.moneyPaymentInstructionRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister, MoneyPaymentInstructionRegister.class);
this.paymentInstructionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
}
@Override
public void afterPropertiesSet() {
callback(MoneyPaymentInstructionRegisterNewRequest.class)
callback(LauncherCommandRequest.class)
.setConsumer(this::moneyPaymentInstructionRegisterNew)
.forDestination(Consts.REGISTRY_MONEY_PAYMENT_INSTRUCTION_REGISTER_NEW, callbacks::put);
.forDestination(createRegistry_GORR.topic(), callbacks::put);
init();
}
public void moneyPaymentInstructionRegisterNew(BaseRequest<MoneyPaymentInstructionRegisterNewRequest> userRequest) {
MoneyPaymentInstructionRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("MoneyPaymentInstructionRegisterNewRequest received");
MoneyPaymentInstructionRegister register = new MoneyPaymentInstructionRegister();
register.setCreditLegAccount(req.getCreditLegAccount());
register.setCreditLegAmount(req.getCreditLegAmount());
register.setCreditLegCurrencyCode(req.getCreditLegCurrencyCode());
register.setDebitLegAccount(req.getDebitLegAccount());
register.setSender(req.getSender());
register.setAddressee(req.getAddressee());
register.setId(req.getId());
register.setCreated(req.getCreatedAt());
register.setUpdated(req.getUpdatedAt());
register.setClearingDate(req.getClearingDate());
moneyPaymentInstructionRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
public void moneyPaymentInstructionRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GORR.topic());
HashMap<Long, PaymentInstruction> sessionIdByPaymentInstructions = new HashMap<>();
paymentInstructionMap.getAllValues().stream().forEach(x -> sessionIdByPaymentInstructions.put(x.getSessionId(), x));
List<Session> actualSession = sessionMap.getAllValues().stream().filter(x->
sessionIdByPaymentInstructions.containsKey(x.getId()) && x.getSection().equalsIgnoreCase("MKR")
).toList();
actualSession.forEach(x -> insertMoneyPaymentInstructionRegister(sessionIdByPaymentInstructions.get(x.getId())));
log.debug("successfully processed");
}
private void insertMoneyPaymentInstructionRegister(PaymentInstruction paymentInstruction){
MoneyPaymentInstructionRegister moneyPaymentInstructionRegister = new MoneyPaymentInstructionRegister();
moneyPaymentInstructionRegister.setCreditLegAccount(paymentInstruction.getCreditLeg_account());
moneyPaymentInstructionRegister.setCreditLegAmount(paymentInstruction.getCreditLeg_amount());
moneyPaymentInstructionRegister.setCreditLegCurrencyCode(paymentInstruction.getCreditLeg_currencyCode());
moneyPaymentInstructionRegister.setDebitLegAccount(paymentInstruction.getDebitLeg_account());
moneyPaymentInstructionRegister.setSender(paymentInstruction.getSenderId().toString());
moneyPaymentInstructionRegister.setAddressee(paymentInstruction.getAddresseeId().toString());
moneyPaymentInstructionRegister.setClearingDate(paymentInstruction.getClearingDate());
moneyPaymentInstructionRegisterMap.insert(moneyPaymentInstructionRegister);
}
}

2
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/Task.java
View file

@ -29,7 +29,9 @@ public enum Task implements IEnumKey {
reconciliationRequest_RCHK("RCHK"),//Запрос на сверку активов
createRegistry_GRYT("GRYT"),//Сформировать регистр на текущий день
createRegistry_GRRT("GRRT"),//Сформировать реестр на текущий день
createRegistry_GBRR("GBRR"),//Сформировать реестр на текущий день
createRegistry_GORD("GORD"), // Формирование реестра распоряжений, направленных расчетному депозитарию
createRegistry_GORR("GORR"), // Формирование реестра распоряжений, направленных расчетному депозитарию
;
private final String key;