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

copy SDF*executors to clearing-service

Browse source
This commit is contained in:
etreschenkov 2023-05-24 13:27:40 +03:00
parent 3dcb785ebb
commit 4bcf820019
13 changed files with 871 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/SdfExecutorsConfig.java Normal file
View file

@ -0,0 +1,24 @@
package ru.spcex.clearing.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import ru.spcex.clearing.service.executors.AbstractExecutor;
import ru.spcex.clearing.service.executors.Sdf01Executor;
import ru.spcex.clearing.service.executors.Sdf57Executor;
import ru.spcex.platform.enumeration.SdfTable;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class SdfExecutorsConfig {
@Bean("sdfExecutors")
public Map<SdfTable, AbstractExecutor<?>> executorsMap(Sdf01Executor sdf01Executor,
Sdf57Executor sdf57Executor) {
Map<SdfTable, AbstractExecutor<?>> executors = new HashMap<>();
executors.put(SdfTable.SDF_01, sdf01Executor);
executors.put(SdfTable.SDF_57, sdf57Executor);
return executors;
}
}

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

@ -10,12 +10,11 @@ import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
import ru.clearing.classes.statics.data.misc.STrades;
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.SDf57;
import ru.clearing.classes.statics.data.security.Security;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.service.validation.ClrngValidationStored;
import ru.spcex.clearing.service.validation.ExecutionDepositValidationRule;
import ru.spcex.clearing.service.validation.RegistryStep3ValidationRule;
import ru.spcex.clearing.service.validation.STradesValidationRule;
import ru.spcex.clearing.service.validation.*;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.ClearingCategory;
import ru.spcex.platform.imdg.api.Imdg;
@ -28,6 +27,7 @@ import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
@Configuration
@ -107,4 +107,38 @@ public class ValidationConfig {
RegistryStep3ValidationRule.TradingClearingRegistryActive);
};
}
@Bean("sdf01Validator")
public Function<SDf01, IValidator> sdf01Validator() {
return sDf01 -> {
ImdgValidationContext<SDf01> context = new ImdgValidationContext<>();
context.setValidatedObject(sDf01);
Consumer<String> addImdg = (s) -> context.addImdg(s, getImdg(s));
addImdg.accept(IMDGDistributedNames.Map_Account);
addImdg.accept(IMDGDistributedNames.Map_Company);
return new ValidatorImpl<>(context,
Sdf01ValidationRule.CompanyPresent,
Sdf01ValidationRule.AccountPresent,
Sdf01ValidationRule.CurrencyCode,
Sdf01ValidationRule.CurrentDateOnly,
MarketIsUValidationRule.instance,
Sdf01ValidationRule.accountType);
};
}
@Bean("sdf57Validator")
public Function<SDf57, IValidator> sdf57Validator() {
return sDf57 -> {
ImdgValidationContext<SDf57> context = new ImdgValidationContext<>();
context.setValidatedObject(sDf57);
Consumer<String> addImdg = (s) -> context.addImdg(s, getImdg(s));
addImdg.accept(IMDGDistributedNames.Map_Account);
addImdg.accept(IMDGDistributedNames.Map_Company);
return new ValidatorImpl<>(context,
Sdf57ValidationRule.CompanyDebPresent,
Sdf57ValidationRule.CompanyCredPresent,
Sdf57ValidationRule.AccountDebPresent,
Sdf57ValidationRule.CurrencyCode
);
};
}
}

4
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/error/ClearingError.java
View file

@ -5,12 +5,14 @@ import ru.spcex.platform.utils.enumeration.IErrorEnumId;
public enum ClearingError implements IErrorEnumId {
GeneralError(5400L),
RecordNotFound(5406L),
CompanyNotFound(5410L),
CompanyNotActive(5411L),
CompanyCreditCheck(5412L),
CompanyDebitCheck(5413L),
CompanyNotFound(5410L),
CurrentDateOnly(5214L),
AccountNotActive(5415L),
SecurityNotFound(5416L),
AccountNotPresent(5417L),
TradingClearingRegistryNotFound(5418L),
TradingClearingRegistryNotActive(5419L),
ClearingUnavailableForCompany(5421L),

27
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/LoggingService.java Normal file
View file

@ -0,0 +1,27 @@
package ru.spcex.clearing.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
@Component
public class LoggingService {
private final Logger log = LoggerFactory.getLogger(getClass());
private final IMessageResolver errorResolver;
@Autowired
public LoggingService(IMessageResolver errorResolver) {
this.errorResolver = errorResolver;
}
public void logError(String message, EnumMessage error, Object... args) {
log.error(message + " {}", args, errorResolver.resolve(error));
}
public void logError(EnumMessage error) {
log.error("{}", errorResolver.resolve(error));
}
}

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

@ -0,0 +1,108 @@
package ru.spcex.clearing.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.sdf.SDf01;
import ru.clearing.classes.statics.data.sdf.SDf57;
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.account.sdf01.AccountSdf01Request;
import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.ExportToFileRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
import ru.spcex.clearing.service.executors.AbstractExecutor;
import ru.spcex.clearing.service.model.Result;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.SdfTable;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.util.Collection;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Service
public class StatementService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final ImdgProvider imdgProvider;
private final KafkaSender kafkaSender;
private final Map<SdfTable, Imdg<? extends SpcexObjectBase>> sdfImdgs;
private final Map<SdfTable, AbstractExecutor<?>> executorsMap;
@Autowired
public StatementService(Consumer<String, Object> kafkaQueue,
ImdgProvider imdgProvider,
KafkaSender kafkaSender,
@Qualifier("sdfExecutors") Map<SdfTable, AbstractExecutor<?>> executorsMap) {
super(kafkaQueue);
this.imdgProvider = imdgProvider;
this.sdfImdgs = new EnumMap<>(SdfTable.class);
this.kafkaSender = kafkaSender;
this.executorsMap = executorsMap;
this.sdfImdgs.put(SdfTable.SDF_01, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class));
this.sdfImdgs.put(SdfTable.SDF_57, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf57, SDf57.class));
}
@Override
public void afterPropertiesSet() throws Exception {
callback(StatementRequest.class)
.setConsumer(this::process)
.forDestination(Consts.STATEMENT_PROCESS, callbacks::put);
init();
}
private void process(BaseRequest<StatementRequest> systemRequest) {
StatementRequest statementRequest = systemRequest.getRequestPayload();
Collection<? extends SpcexObjectBase> sdfGroup;
SdfTable table = statementRequest.getTable();
Imdg<? extends SpcexObjectBase> sdfImdg = sdfImdgs.get(table);
if (statementRequest.getAccountCreationResults().size() == 0) {
sdfGroup = sdfImdg.getCollectionObjectsByFieldValues(Map.of("generationId", statementRequest.getGroupId()));
} else {
sdfGroup = statementRequest.getAccountCreationResults()
.stream()
.filter(part -> part.getErrorCode() == null) //fixme эти случае должны попадать в ошибочный sdf02
.map(part -> sdfImdg.getSingleObjectByID(part.getSdfId()))
.collect(Collectors.toList());
}
// sdf01Group = sdf01Group
// .stream()
// .sorted(Comparator.comparing(SpcexObjectBase::getId))
// .collect(Collectors.toList());
AbstractExecutor service = executorsMap.get(table);
Result res = service.execute(sdfGroup, statementRequest);
if (res.getAccountRequests().size() == 0) {
ExportToFileRequest exportRequest = new ExportToFileRequest();
exportRequest.setSdfGroupId(res.getGenerationId());
exportRequest.setNameOfTable(service.exportTableName());
kafkaSender.sendRequestToQueue(Consts.EXPORT_PROCESS, exportRequest);
} else {
kafkaSender.sendRequestToQueue(Consts.ACCOUNT_NEW_SDF01, createAccountsRequest(statementRequest.getGroupId(), res.getAccountRequests()));
}
}
private AccountSdf01Request createAccountsRequest(Long sdf01GroupingId, List<AccountSdfRequestPart> accountRequests) {
AccountSdf01Request r = new AccountSdf01Request();
r.setGroupingSdf01Id(sdf01GroupingId);
r.setAccounts(accountRequests);
return r;
}
private Imdg<?> defineImdgByTableName(SdfTable table){
switch (table){
case SDF_01 -> imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class);
case SDF_57 -> imdgProvider.getImdg(IMDGDistributedNames.Map_SDf57, SDf57.class);
}
return null;
}
}

11
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/AbstractExecutor.java Normal file
View file

@ -0,0 +1,11 @@
package ru.spcex.clearing.service.executors;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
import ru.spcex.clearing.service.model.Result;
import java.util.Collection;
public abstract class AbstractExecutor<T> {
public abstract Result execute(Collection<T> sdf, StatementRequest statementRequest);
public abstract String exportTableName();
}

198
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf01Executor.java Normal file
View file

@ -0,0 +1,198 @@
package ru.spcex.clearing.service.executors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.account.AccountBalance;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.sdf.SDf01;
import ru.clearing.classes.statics.data.sdf.SDf02;
import ru.clearing.classes.statics.data.statement.Statement;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
import ru.spcex.clearing.service.LoggingService;
import ru.spcex.clearing.service.model.Result;
import ru.spcex.clearing.service.validation.ValidationStored;
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.EnumMessage;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.number.BigDecimalUtil;
import ru.spcex.platform.utils.validation.IValidator;
import java.time.Instant;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
@Service
public class Sdf01Executor extends AbstractExecutor<SDf01> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
private final Imdg<Statement> statementImdg;
private final Function<SDf01, IValidator> sDf01Validator;
private final LoggingService errorLogger;
private final Imdg<SDf02> sdf02Imdg;
private final ImdgProvider imdgProvider;
private final IMessageResolver errorResolver;
private final Imdg<AccountBalance> accountBalanceImdg;
public Sdf01Executor(Function<SDf01, IValidator> sDf01Validator,
LoggingService errorLogger,
ImdgProvider imdgProvider,
IMessageResolver errorResolver) {
this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);
this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
;
this.sDf01Validator = sDf01Validator;
this.errorLogger = errorLogger;
this.imdgProvider = imdgProvider;
this.errorResolver = errorResolver;
}
@Override
public String exportTableName() {
return "DF-02";
}
public Result execute(Collection<SDf01> sdf, StatementRequest statementRequest) {
Result result = new Result();
Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId();
result.setGenerationId(generationIdForGroup);
for (SDf01 sdf01 : sdf) {
IValidator validator = sDf01Validator.apply(sdf01);
Optional<EnumMessage> error = validator.tillFirstError();
Company company = validator.getStored(ValidationStored.Company);
if (statementRequest.getAccountCreationResults().size() == 0
&& ClearingError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
//на данном шаге company существует -> getId ok
//формируем пакетный запрос на добавление account
//ответ придет в этот же метод, process
result.getAccountRequests().add(createAccountRequestPart(sdf01.getId(), sdf01.getAccount(), company.getId()));
log.info("account {} for sdf01.id={} not found - send request for creation", sdf01.getAccount(), sdf01.getId());
continue;
} else if (ClearingError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
log.error("fatal error: resumed processing after generating accounts, but no account found for sdf01.id={}", sdf01.getId());
}
if (error.isPresent()) {
errorLogger.logError("sdf01.id={}", error.get(), sdf01.getId());
sdf02Imdg.insert(createErrorSdf02(sdf01, error.get(), generationIdForGroup));
continue;
}
Statement statement = statementImdg.getSingleObjectByFieldValues(Map.of("account", sdf01.getAccount()));
if (statement == null) {
statement = createFlow(sdf01,
company,
validator.getStored(ValidationStored.Account));
} else {
updateFlow(statement, sdf01,
validator.getStored(ValidationStored.Account));
}
SDf02 sdf02New = createSuccessSdf02(sdf01, generationIdForGroup);
sdf02Imdg.insert(sdf02New);
statement.setOutSDfId(sdf02New.getId());
// AccountResult accountResult = accountBalanceService.createAccountBalance(statement.getAddresseeId(), statement.getAccountId(), statement.getAmount(),
// null/*statement.getCashMovementCurrencyCode()*/);
// if (accountResult.getError() != null) {
// statement.setErrorCodeId(accountResult.getError().getSubject().getId());
// todo statement.setErrorText(errorResolver.resolve(accountResult.getError()));
// } else {
// accountBalanceImdg.insert(accountResult.getAccount()); //insert == update?
// statement.setOperationStatus(OperationStatus.Executed.getKey());
// }
statementImdg.update(statement);
}
return result;
}
private Statement createFlow(SDf01 sdf01, Company company, Account account) {
Statement statement = new Statement();
statement.setAddresseeId(company.getId());
statement.setSenderId(Sender.Prc.getId());
statement.setCreated(Instant.now());
statement.setClearingDate(LocalDate.now());
statement.setStatementType(StatementType.full.getKey());
statement.setAccountId(account.getId());
statement.setAccount(sdf01.getAccount());
statement.setInOutDirection(InOutDirection.in.getKey());
statement.setSettlementDate(LocalDate.parse(sdf01.getDat(), datFormatter));
statement.setAmount(BigDecimalUtil.parse(sdf01.getRemainder()));
statement.setOperationStatus(OperationStatus.Pending.getKey());
statement.setInSDfId(sdf01.getId());
statement.setInOutSDfType(InOutSDfType.type1.getKey());
statementImdg.insert(statement);
return statement;
}
private void updateFlow(Statement statement, SDf01 sdf01, Account account) {
statement.setUpdated(Instant.now());
statement.setAccountId(account.getId());
statement.setAccount(sdf01.getAccount());
statement.setInOutDirection(InOutDirection.in.getKey());
statement.setSettlementDate(LocalDate.parse(sdf01.getDat(), datFormatter));
statement.setAmount(BigDecimalUtil.parse(sdf01.getRemainder()));
statementImdg.update(statement);
}
private AccountSdfRequestPart createAccountRequestPart(Long sdf01Id, String account, Long companyId) {
AccountSdfRequestPart req = new AccountSdfRequestPart();
req.setAccount(account);
req.setCompanyId(companyId);
req.setAccountType(AccountType.Clrn.getKey());
req.setSdfId(sdf01Id);
return req;
}
private SDf02 createErrorSdf02(SDf01 sdf01, EnumMessage error, Long generationIdForGroup) {
SDf02 sDf02 = new SDf02();
sDf02.setCurr_code(sdf01.getCurr_code());
sDf02.setAccount(sdf01.getAccount());
sDf02.setRemainder(sdf01.getRemainder());
sDf02.setDeal(sdf01.getDeal());
sDf02.setAcc_code(sdf01.getAcc_code());
sDf02.setDat(sdf01.getDat());
sDf02.setMarket(sdf01.getMarket());
sDf02.setAcc_name(sdf01.getAcc_name());
sDf02.setAcc_type(sdf01.getAcc_type());
sDf02.setSumengage(sdf01.getSumengage());
sDf02.setSumunblock(sdf01.getSumunblock());
sDf02.setFile_type(sdf01.getFile_type());
sDf02.setInSDfId(sdf01.getId());
String errorId = error.getSubject().getId().toString();
sDf02.setResult(errorId.substring(errorId.length() - 3));
sDf02.setGenerationId(generationIdForGroup);
sDf02.setGenerationTime(Instant.now());
return sDf02;
}
private SDf02 createSuccessSdf02(SDf01 sdf01, Long generationIdForGroup) {
SDf02 sDf02 = new SDf02();
sDf02.setCurr_code(sdf01.getCurr_code());
sDf02.setAccount(sdf01.getAccount());
sDf02.setRemainder(sdf01.getRemainder());
sDf02.setDeal(sdf01.getDeal());
sDf02.setAcc_code(sdf01.getAcc_code());
sDf02.setDat(sdf01.getDat());
sDf02.setMarket(sdf01.getMarket());
sDf02.setAcc_name(sdf01.getAcc_name());
sDf02.setAcc_type(sdf01.getAcc_type());
sDf02.setSumengage(sdf01.getSumengage());
sDf02.setSumunblock(sdf01.getSumunblock());
sDf02.setFile_type(sdf01.getFile_type());
sDf02.setInSDfId(sdf01.getId());
sDf02.setGenerationId(generationIdForGroup);
sDf02.setGenerationTime(Instant.now());
sDf02.setResult("OK!");
return sDf02;
}
}

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

@ -0,0 +1,215 @@
package ru.spcex.clearing.service.executors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.account.AccountBalance;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.sdf.SDf02;
import ru.clearing.classes.statics.data.sdf.SDf57;
import ru.clearing.classes.statics.data.statement.Statement;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
import ru.spcex.clearing.service.LoggingService;
import ru.spcex.clearing.service.model.Result;
import ru.spcex.clearing.service.validation.ValidationStored;
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.EnumMessage;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.text.TextUtil;
import ru.spcex.platform.utils.validation.IValidator;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Collection;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
@Service
public class Sdf57Executor extends AbstractExecutor<SDf57> {
private final Logger log = LoggerFactory.getLogger(getClass());
private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
private final Imdg<Statement> statementImdg;
private final Imdg<Registry> registryImdg;
private final Function<SDf57, IValidator> sDf57Validator;
private final LoggingService errorLogger;
private final Imdg<SDf02> sdf02Imdg;
private final ImdgProvider imdgProvider;
private final IMessageResolver errorResolver;
private final Imdg<AccountBalance> accountBalanceImdg;
private final IMessageResolver messageResolver;
public Sdf57Executor(@Qualifier("sdf57Validator") Function<SDf57, IValidator> sDf57Validator,
LoggingService errorLogger,
ImdgProvider imdgProvider,
IMessageResolver errorResolver, IMessageResolver messageResolver) {
this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);
this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
this.sDf57Validator = sDf57Validator;
this.errorLogger = errorLogger;
this.imdgProvider = imdgProvider;
this.errorResolver = errorResolver;
this.messageResolver = messageResolver;
}
@Override
public String exportTableName() {
return "DF-57";
} //no need...
//V - Изменение statement по sDf57
//
//1. Перед изменением statement необходимо выполнить ряд проверок:
// 1.1. Найти в company запись, у которой company.tradingCode=sDf57.deal_deb. Если такой записи нет, записать в лог ошибку (5211) "Компания %s не найдена".
// 1.2. Найти в company запись, у которой company.tradingCode=sDf57.deal_cred. Если такой записи нет, записать в лог ошибку (5211) "Компания %s не найдена".
// 1.3. Проверить, есть ли в таблице account счет, у которого account.account=sDf57.c_acc_deb. Если такой записи нет, записать в лог ошибку (5217) "Счет %s не найден".
// 1.4. Проверить, есть ли в таблице account счет, у которого account.account=sDf57.c_acc_cred. Если такой записи нет, записать в лог ошибку (5217) "Счет %s не найден".
// 1.5. Проверить, что sDf57.pay_val=RUR. Иначе записать в лог ошибку (5213) "Валюта %s не найдена".
//2. В зависимости от результата прохождения проверок в п.1 раздела Изменение statement по sDf57:
// 2.1. Если все проверки пройдены, необходимо сформировать 2 новые записи согласно описанию с соответствующим тэгом,
// где первая запись будет содержать информацию о плательщике (по sDf57.deal_deb),
// а вторая о получателе (по sDf57.deal_cred) и связаны по одному inSDfId (= sDf57.id).
// 2.2. Иначе запись в statement не добавляется.
//3. По итогу добавления statement:
// Если в п.1 раздела Изменение statement по sDf57 ошибок не обнаружено, то инициировать изменение таблицы registry согласно описанию с соответствующим тэгом.
// По итогу изменения registry должны быть обновлены значения полей в statement:
// - operationStatus;
// - errorCode в случае выявления ошибки;
// - errorText в случае выявления ошибки.
public Result execute(Collection<SDf57> sdf, StatementRequest statementRequest) {
Result result = new Result();
Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId();
result.setGenerationId(generationIdForGroup);
for (SDf57 sdf57 : sdf) {
IValidator validator = sDf57Validator.apply(sdf57);
Optional<EnumMessage> error = validator.tillFirstError();
if (error.isPresent()) {
log.error("error while validating sdf57.id={} - {}", sdf57.getId(), messageResolver.resolve(error.get()));
continue;
}
//create by companyDeb
Company companyDeb = validator.getStored(ValidationStored.Sdf57CompanyDeb);
Account accountDeb = validator.getStored(ValidationStored.Sdf57AccountDeb);
Statement statementDeb = create(sdf57, companyDeb, accountDeb);
statementImdg.insert(statementDeb);
//create by companyCred
Company companyCred = validator.getStored(ValidationStored.Sdf57CompanyCred);
Account accountCred = validator.getStored(ValidationStored.Sdf57AccountCred);
Statement statementCred = create(sdf57, companyCred, accountCred);
statementImdg.insert(statementCred);
Consumer<StmtCmpAcc> createRegistryIfNeeded = stmtCmpAcc -> {
Statement stmt = stmtCmpAcc.statement();
Optional<EnumMessage> err = validateActiveness(stmtCmpAcc.company(), stmtCmpAcc.account(), stmt);
if (err.isEmpty()) {
Consumer<Registry> update = rgs -> {
updateReg(stmt, rgs);
registryImdg.update(rgs);
};
Runnable create = () -> {
Registry registry = createRegistryByStatement(stmt);
registryImdg.insert(registry);
};
findReg(stmt, RegistryDesignation.A).ifPresentOrElse(update, create);
findReg(stmt, RegistryDesignation.D).ifPresentOrElse(update, create);
stmt.setOperationStatus(OperationStatus.Executed.getKey());
} else {
stmt.setErrorCodeId(err.get().getSubject().getId()); // fixme ErrorText insert
stmt.setOperationStatus(OperationStatus.Rejected.getKey());
statementImdg.update(stmt);
}
};
createRegistryIfNeeded.accept(new StmtCmpAcc(statementDeb, companyDeb, accountDeb));
createRegistryIfNeeded.accept(new StmtCmpAcc(statementCred, companyCred, accountCred));
}
return result;
}
private static record StmtCmpAcc(Statement statement, Company company, Account account) {
}
private Optional<EnumMessage> validateActiveness(Company company, Account account, Statement statement) {
if (!WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus())) {
return Optional.of(new EnumMessage(ClearingError.CompanyNotActive, company.getId()));
}
if (!WorkflowStatus.Active.equalsByKey(account.getStatus())) {
return Optional.of(new EnumMessage(ClearingError.AccountNotActive, account.getId()));
}
return Optional.empty();
}
private Statement create(SDf57 sdf57, Company companyDeb, Account accountDeb) {
Statement statement = new Statement();
statement.setAddresseeId(companyDeb.getId());
statement.setSenderId(Sender.Prc.getId());
statement.setStatementType(StatementType.full.getKey());
statement.setContract(getContractFromSpecif(sdf57.getSpecif()));
statement.setAccountId(accountDeb.getId());
statement.setAccount(accountDeb.getAccount());
statement.setInOutDirection(InOutDirection.out.getKey());
statement.setSettlementDate(payDate(sdf57.getPay_date())); //fixme pay_date format
statement.setAmount(TextUtil.isEmpty(sdf57.getSum_deb()) ? null : new BigDecimal(sdf57.getSum_deb()));
statement.setOperationStatus(OperationStatus.Pending.getKey());
statement.setInSDfId(sdf57.getId());
statement.setInOutSDfType(InOutSDfType.type57.getKey());
return statement;
}
private Registry createRegistryByStatement(Statement statement) {
//todo
return new Registry();
}
private void updateReg(Statement s, Registry r) {
//todo
}
private Optional<Registry> findReg(Statement s, RegistryDesignation des) {
//todo add dependency on Registry search
// RegistryTradingParams p = new RegistryTradingParams(
// des, RegistryInstrumentType.M, RegistryCapacity.A, RegistryUnit.T
// );
// String sql = RegistryCodeSqlBuilder.getInstance(p).build();
// ImdgPredicateBuilder pb = registryImdg.predicateBuilder();
// ImdgPredicate rgstrPredicate = pb.and(pb.sql(sql),
// pb.sql(sql),
// pb.equals("companyId", s.getAddresseeId()) //fixme companyId?
// );
// if (des.equals(RegistryDesignation.D) && !TextUtil.isEmpty(s.getContract())) {
// rgstrPredicate = pb.and(rgstrPredicate, pb.equals("contract", s.getContract()));
// }
// return Optional.ofNullable(registryImdg.getSingleObjectByPredicate(rgstrPredicate));
return null;
}
DateTimeFormatter payDateFormatter = DateTimeFormatter.ofPattern("yyyyMMdd");
private LocalDate payDate(String payDate) {
if (TextUtil.isEmpty(payDate)) {
return null;
}
return LocalDate.parse(payDate, payDateFormatter);
}
private String getContractFromSpecif(String specif) {
if (specif == null) {
return null;
}
int index = specif.indexOf("№");
if (index == -1) {
return null;
}
return specif.substring(index + 1);
}
}

27
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/model/Result.java Normal file
View file

@ -0,0 +1,27 @@
package ru.spcex.clearing.service.model;
import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
import java.util.ArrayList;
import java.util.List;
public class Result {
private List<AccountSdfRequestPart> accountRequests = new ArrayList<>();
private Long generationId;
public List<AccountSdfRequestPart> getAccountRequests() {
return accountRequests;
}
public void setAccountRequests(List<AccountSdfRequestPart> accountRequests) {
this.accountRequests = accountRequests;
}
public Long getGenerationId() {
return generationId;
}
public void setGenerationId(Long generationId) {
this.generationId = generationId;
}
}

23
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/MarketIsUValidationRule.java Normal file
View file

@ -0,0 +1,23 @@
package ru.spcex.clearing.service.validation;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.platform.classes.base.interfaces.WithMarket;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.util.Optional;
public class MarketIsUValidationRule implements IValidationRule<ImdgValidationContext<WithMarket>> {
public static final MarketIsUValidationRule instance = new MarketIsUValidationRule();
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<WithMarket> context) {
WithMarket validatedObject = context.getValidatedObject();
if (!"U".equals(validatedObject.getMarket())) {
return of(ClearingError.AccountNotActive);
}
return empty();
}
}

99
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf01ValidationRule.java Normal file
View file

@ -0,0 +1,99 @@
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.SDf01;
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.validation.IValidationRule;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Map;
import java.util.Optional;
public enum Sdf01ValidationRule implements IValidationRule<ImdgValidationContext<SDf01>> {
CompanyPresent() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (sdf01.getDeal() == null) {
return of(ClearingError.CompanyNotFound);
}
Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
Company company = companyImdg.getSingleObjectByFieldValues(Map.of("tradingCode", sdf01.getDeal()));
if (company == null) {
return of(ClearingError.CompanyNotFound);
}
context.storeObject(ValidationStored.Company, company);
return empty();
}
},
AccountPresent() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (sdf01.getAccount() == null) {
return of(ClearingError.AccountNotPresent);
}
Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
Account account = accountImdg.getSingleObjectByFieldValues(Map.of("account", sdf01.getAccount(),
"accountType", AccountType.Clrn.getKey()));
if (account == null) {
return of(ClearingError.AccountNotPresent);
}
context.storeObject(ValidationStored.Account, account);
return empty();
}
},
CurrencyCode() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (!"RUR".equals(sdf01.getCurr_code())) {
return of(ClearingError.CompanyDebitCheck);
}
return empty();
}
},
CurrentDateOnly() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (sdf01.getDat() == null) {
return of(ClearingError.CurrentDateOnly);
}
LocalDate date;
try {
date = LocalDate.parse(sdf01.getDat(), datFormatter);
} catch (DateTimeParseException e) {
return of(ClearingError.CurrentDateOnly);
}
if (!LocalDate.now().equals(date)) {
return of(ClearingError.CurrentDateOnly);
}
return empty();
}
},
accountType() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (!"A".equals(sdf01.getAcc_type())) {
return of(ClearingError.SecurityNotFound);
}
return empty();
}
};
private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
@Override
public String ruleName() {
return "Sdf01ValidationRule." + name();
}
}

94
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf57ValidationRule.java Normal file
View file

@ -0,0 +1,94 @@
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.SDf57;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
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.Optional;
public enum Sdf57ValidationRule implements IValidationRule<ImdgValidationContext<SDf57>> {
CompanyDebPresent() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf57.getDeal_deb())) {
return of(ClearingError.CompanyNotFound, sdf57.getDeal_deb());
}
Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
Company found = companyImdg.getSingleObjectBySQL("tradingCode = '" + sdf57.getDeal_deb() + "'");
if (found == null) {
return of(ClearingError.CompanyNotFound, sdf57.getDeal_deb());
}
context.storeObject(ValidationStored.Sdf57CompanyDeb, found);
return empty();
}
}, CompanyCredPresent() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf57.getDeal_cred())) {
return of(ClearingError.CompanyNotFound, sdf57.getDeal_deb());
}
Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
Company found = companyImdg.getSingleObjectBySQL("tradingCode = '" + sdf57.getDeal_cred() + "'");
if (found == null) {
return of(ClearingError.CompanyNotFound, sdf57.getDeal_deb());
}
context.storeObject(ValidationStored.Sdf57CompanyCred, found);
return empty();
}
}, AccountDebPresent() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf57.getC_acc_deb())) {
return of(ClearingError.AccountNotPresent, sdf57.getDeal_deb());
}
Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
Account found = accountImdg.getSingleObjectBySQL("account = '" + sdf57.getC_acc_deb() + "'");
if (found == null) {
return of(ClearingError.AccountNotPresent, sdf57.getDeal_deb());
}
context.storeObject(ValidationStored.Sdf57AccountDeb, found);
return empty();
}
}, AccountCredPresent() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf57.getC_acc_cred())) {
return of(ClearingError.AccountNotPresent, sdf57.getDeal_deb());
}
Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
Account found = accountImdg.getSingleObjectBySQL("account = '" + sdf57.getC_acc_cred() + "'");
if (found == null) {
return of(ClearingError.AccountNotPresent, sdf57.getDeal_deb());
}
context.storeObject(ValidationStored.Sdf57AccountCred, found);
return empty();
}
}, CurrencyCode() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (!ru.spcex.platform.enumeration.CurrencyCode.RUR.equalsByKey(sdf57.getPay_val())) {
return of(ClearingError.CompanyDebitCheck, sdf57.getPay_val());
}
return empty();
}
};
@Override
public String ruleName() {
return "Sdf57ValidationRule." + name();
}
}

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

@ -1,5 +1,8 @@
package ru.spcex.clearing.service.validation;
public enum ValidationStored {
STradesCompany, STradesCounterCompany, STradesSecurity, STradesTradingClearingRegistry
STradesCompany, STradesCounterCompany, STradesSecurity, STradesTradingClearingRegistry,
Account, Company,
Sdf57CompanyDeb, Sdf57CompanyCred, Sdf57AccountDeb, Sdf57AccountCred
}