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

Merge remote-tracking branch 'origin/dev' into dev

Browse source
This commit is contained in:
ialbert 2023-05-24 13:52:21 +03:00
commit 3e6f6121c4
25 changed files with 762 additions and 637 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java
View file

@ -116,8 +116,8 @@ public class AccountValidationConfig {
AccountError.RequiredFieldEmpty,
AccountError.AccountNotFound,
account -> {
String statusFromRequest = correspondentAccountUpdateRequest.getStatus();
if (statusFromRequest != null && !statusFromRequest.equalsIgnoreCase(account.getStatus()))
// проверка на заблокированность счёта
if (!AccountStatus.ACTIVE.getKey().equalsIgnoreCase(account.getStatus()))
return AccountError.WrongFieldValue;
return null;
}),

8
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClientCodeService.java
View file

@ -229,11 +229,13 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
ClientCode clientCode = clientCodeMap.getSingleObjectByID(req.getId());
if (clientCode.getMoneyAccountId() != null) {
log.debug("Delete clientCode.id = {}: send message to account-service", clientCode.getId());
log.debug("Blocking clientCode.id = {}: send message to account-service", clientCode.getId());
sendBlockTCR(clientCode.getTradingClearingRegistryId(), clientCode.getMoneyAccountId());
}
log.debug("Delete clientCode.id={}", clientCode.getId());
clientCodeMap.delete(clientCode);
log.debug("Blocking clientCode.id={}", clientCode.getId());
clientCode.setUpdated(Instant.now());
clientCode.setStatus(WorkflowStatus.Blocked.getKey());
clientCodeMap.update(clientCode);
return null;
}

26
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java
View file

@ -153,6 +153,14 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
// Пока что она соответствует ТЗ, но возможно будет правиться, поэтому расписана без выноса кода в методы и
// прочих методов сокращения кода. В дальнейшем, после тестирования и окончательного выяснения вида проверки,
// её стоит вынести на этап валидации запроса.
if (req.getMoneyAccountId() == null && (req.getMoneyAccountId() == null || req.getDepoAccountId() == null)) {
TradingClearingRegistry registryByCompany = tradingClearingRegistryImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
if (registryByCompany == null) {
return requestHelper.makeErrorResponse(userRequest,
AccountError.TradingClearingRegistryNotFound,
req.getCompanyId());
}
}
Relation relation = relationImdg.getSingleObjectByFieldValues(Map.of("consumerId", req.getCompanyId()));
if (ru.spcex.platform.enumeration.Service.MKR.equalsByKey(relation.getService())) {
TradingClearingRegistry registry = tradingClearingRegistryImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
@ -281,6 +289,15 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
}
TradingClearingRegistryNewRequest req = userRequest.getRequestPayload();
// Дополнительная проверка
if (req.getMoneyAccountId() == null && (req.getMoneyAccountId() == null || req.getDepoAccountId() == null)) {
TradingClearingRegistry registryByCompany = tradingClearingRegistryImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
if (registryByCompany == null) {
return requestHelper.makeErrorResponse(userRequest,
AccountError.TradingClearingRegistryNotFound,
"companyId=" + req.getCompanyId());
}
}
Long id = tradingClearingRegistryImdg.nextIDSequenceFor();
TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry();
@ -335,6 +352,15 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
TradingClearingRegistryUpdateRequest req = userRequest.getRequestPayload();
TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId());
// Дополнительная проверка
if (req.getMoneyAccountId() == null && (req.getMoneyAccountId() == null || req.getDepoAccountId() == null)) {
TradingClearingRegistry registryByCompany = tradingClearingRegistryImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
if (registryByCompany == null) {
return requestHelper.makeErrorResponse(userRequest,
AccountError.TradingClearingRegistryNotFound,
"companyId=" + req.getCompanyId());
}
}
if (req.getStatus() != null) tradingClearingRegistry.setStatus(req.getStatus());

10
clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/SdfExecutorsConfig.java
View file

@ -3,9 +3,7 @@ package ru.spcex.clearing.balance.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import ru.spcex.clearing.balance.service.AbstractExecutor;
import ru.spcex.clearing.balance.service.Sdf01Executor;
import ru.spcex.clearing.balance.service.Sdf16Executor;
import ru.spcex.clearing.balance.service.Sdf57Executor;
import ru.spcex.platform.enumeration.SdfTable;
import java.util.HashMap;
@ -15,15 +13,11 @@ import java.util.Map;
public class SdfExecutorsConfig {
@Bean("sdfExecutors")
public Map<SdfTable, AbstractExecutor<?>> executorsMap(Sdf01Executor sdf01Executor,
//Sdf09Executor sdf09Executor,
Sdf16Executor sdf16Executor,
Sdf57Executor sdf57Executor) {
public Map<SdfTable, AbstractExecutor<?>> executorsMap(//Sdf09Executor sdf09Executor,
Sdf16Executor sdf16Executor) {
Map<SdfTable, AbstractExecutor<?>> executors = new HashMap<>();
executors.put(SdfTable.SDF_01, sdf01Executor);
// todo возможно удалят или переделают: executors.put(SdfTable.SDF_09, sdf09Executor);
executors.put(SdfTable.SDF_16, sdf16Executor);
executors.put(SdfTable.SDF_57, sdf57Executor);
return executors;
}
}

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

@ -7,10 +7,8 @@ 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.company.CompanySymbols;
import ru.clearing.classes.statics.data.sdf.SDf01;
import ru.clearing.classes.statics.data.sdf.SDf09;
import ru.clearing.classes.statics.data.sdf.SDf16;
import ru.clearing.classes.statics.data.sdf.SDf57;
import ru.spcex.clearing.balance.validation.*;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.classes.base.SpcexObjectBase;
@ -46,41 +44,6 @@ public class ValidationConfig {
return imdgs.get(key);
}
@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
);
};
}
@Bean("sdf16Validator")
public Function<SDf16, IValidator> sdf16Validator() {
return sDf16 -> {

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

@ -7,29 +7,16 @@ 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.SDf16;
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.AccountBalanceClearingRequest;
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.domain.cud.common.CommonIdRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
import ru.spcex.platform.classes.base.interfaces.WithAccount;
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 {
@ -37,31 +24,25 @@ public class StatementService extends QueueConsumer implements InitializingBean
private final ImdgProvider imdgProvider;
private final KafkaSender kafkaReqProducer;
private final Map<SdfTable, Imdg<? extends WithAccount>> sdfImdgs;
private final Map<SdfTable, AbstractExecutor<?>> executorsMap;
private final AccountBalanceService accountBalanceService;
@Autowired
public StatementService(Consumer<String, Object> kafkaQueue,
ImdgProvider imdgProvider,
KafkaSender kafkaReqProducer,
@Qualifier("sdfExecutors") Map<SdfTable, AbstractExecutor<?>> executorsMap, AccountBalanceService accountBalanceService) {
@Qualifier("sdfExecutors") Map<SdfTable, AbstractExecutor<?>> executorsMap,
AccountBalanceService accountBalanceService) {
super(kafkaQueue);
this.imdgProvider = imdgProvider;
this.accountBalanceService = accountBalanceService;
this.sdfImdgs = new EnumMap<>(SdfTable.class);
this.kafkaReqProducer = kafkaReqProducer;
this.executorsMap = executorsMap;
this.sdfImdgs.put(SdfTable.SDF_01, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class));
// todo изменение классов. this.sdfImdgs.put(SdfTable.SDF_09, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf09, SDf09.class));
this.sdfImdgs.put(SdfTable.SDF_16, imdgProvider.getImdg(IMDGDistributedNames.Map_SDf16, SDf16.class));
}
@Override
public void afterPropertiesSet() throws Exception {
callback(StatementRequest.class)
.setConsumer(this::process)
.forDestination(Consts.STATEMENT_PROCESS, callbacks::put);
// callback(StatementRequest.class)
// .setConsumer(this::process)
// .forDestination(Consts.STATEMENT_PROCESS, callbacks::put);
callback(AccountBalanceClearingRequest.class)
.setConsumer(this::accountBalanceClearingUpdate)
.forDestination(Consts.BALANCE_ACCOUNT_UPDATE, callbacks::put);
@ -77,42 +58,4 @@ public class StatementService extends QueueConsumer implements InitializingBean
commonIdRequest.setId(updateAccBalanceReq.getId());
kafkaReqProducer.sendRequestToQueue(Consts.CONTINUE_CLEARING, commonIdRequest, updateAccBalanceReq.getCorrelationId());
}
private void process(BaseRequest<StatementRequest> systemRequest) {
StatementRequest statementRequest = systemRequest.getRequestPayload();
Collection<? extends WithAccount> sdfGroup;
SdfTable table = statementRequest.getTable();
//map = getMapByTable(table)
Imdg<? extends WithAccount> 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());
kafkaReqProducer.sendRequestToQueue(Consts.EXPORT_PROCESS, exportRequest);
} else {
kafkaReqProducer.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;
}
}

34
clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/AbstractServiceTest.java
View file

@ -22,17 +22,13 @@ import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.util.concurrent.atomic.AtomicLong;
import static ru.spcex.clearing.balance.service.Sdf01ExecutorTest.acc;
import static ru.spcex.clearing.balance.service.Sdf01ExecutorTest.datFormatter;
import static ru.spcex.clearing.balance.utils.MatcherFactory.usingIgnoringFieldsComparator;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
AccountBalanceService.class,
Sdf01Executor.class,
Sdf08Service.class,
// Sdf09Executor.class,
Sdf16Executor.class,
@ -140,19 +136,19 @@ public abstract class AbstractServiceTest {
accountBalance.setFullName(company.getFullName());
return accountBalance;
}
protected SDf01 getTestSdf01(long id, long generationId) {
LocalDate date = LocalDate.now();
SDf01 sdf01 = new SDf01();
sdf01.setId(id);
sdf01.setGenerationId(generationId);
sdf01.setMarket("U");
sdf01.setDeal(deal);
sdf01.setAccount(acc);
sdf01.setCurr_code("RUR");
sdf01.setDat(date.format(datFormatter));
sdf01.setAcc_type("A");
sdf01.setRemainder(amountNew.toString());
return sdf01;
}
//
// protected SDf01 getTestSdf01(long id, long generationId) {
// LocalDate date = LocalDate.now();
// SDf01 sdf01 = new SDf01();
// sdf01.setId(id);
// sdf01.setGenerationId(generationId);
// sdf01.setMarket("U");
// sdf01.setDeal(deal);
// sdf01.setAccount(acc);
// sdf01.setCurr_code("RUR");
// sdf01.setDat(date.format(datFormatter));
// sdf01.setAcc_type("A");
// sdf01.setRemainder(amountNew.toString());
// return sdf01;
// }
}

263
clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/Sdf01ExecutorTest.java
View file

@ -1,263 +0,0 @@
package ru.spcex.clearing.balance.service;
import org.apache.kafka.clients.producer.MockProducer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.mock.mockito.SpyBean;
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.balance.errors.BalanceError;
import ru.spcex.clearing.balance.utils.MatcherFactory;
import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
import ru.spcex.platform.enumeration.*;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.number.BigDecimalUtil;
import javax.annotation.PostConstruct;
import java.time.Instant;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import static ru.spcex.clearing.balance.utils.MatcherFactory.usingIgnoringFieldsComparator;
class Sdf01ExecutorTest extends AbstractServiceTest {
public final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
public final static String acc = "123456789";
private static final MatcherFactory.Matcher<SDf02> SDF_02_MATCHER = usingIgnoringFieldsComparator("created", "comment", "outSDfId", "generationTime", "generationId", "id");
private final Long ID = 1L;
@Autowired
Sdf01Executor sdf01Executor;
private StatementRequest statementRequest;
@SpyBean
private MockProducer<String, Object> producer;
@PostConstruct
void init() {
super.init();
statementRequest = new StatementRequest();
}
/**
* {@link Sdf01Executor#execute(Collection collection, StatementRequest statementRequest)}<br>
* Тест проверяет генерацию сущностей {@link Result}, {@link Statement}, {@link SDf02}<br>
* Входные параметры:<br>
* accountId - {@link StatementRequest}: new StatementRequest()<br>
* addresseeId - {@link Collection<SDf01>}<br>
* addresseeId - {@link SDf01}<br>
* {@link SDf01#market} - "U"<br>
* {@link SDf01#deal} - "111111111"<br>
* {@link SDf01#account} - "123456789"<br>
* {@link SDf01#curr_code} - "RUR"<br>
* {@link SDf01#dat} - текущая дата<br>
* {@link SDf01#acc_type} - "A"<br>
* {@link SDf01#remainder} - "1000"<br>
*/
@Test
void execute() {
//check create statement, SDf02 and AccountBalance
SDf01 sdf01 = getTestSdf01(ID, 1L);
Company company = getTestCompany();
companyMap.put(addresseeIdNew, company);
Account account = getTestAccount(ID, acc);
accountMap.put(accountIdNew, account);
Result predictableResult = new Result();
predictableResult.setGenerationId(ID);
Statement predictableStatement = getTestStatement(currentId.getAndIncrement(), company, account, sdf01);
predictableStatement.setOperationStatus(OperationStatus.Executed.getKey());
SDf02 predictableSdf02 = getTestSdf02(currentId.getAndIncrement(), sdf01, ID);
predictableStatement.setOutSDfId(predictableSdf02.getId());
AccountResult predictableNewResult = getTestAccountResult(currentId.getAndIncrement(), account, company);
Result result = sdf01Executor.execute(Collections.singletonList(sdf01), statementRequest);
Statement resultStatement = statementImdg.getSingleObjectByFieldValues(Map.of("account", acc));
SDf02 resultSdf02 = sdf02Imdg.getSingleObjectByFieldValues(Map.of("account", acc));
AccountBalance resultAccountBalance = accountBalanceImdg.getSingleObjectByFieldValues(Map.of("account", acc));
RESULT_MATCHER.assertMatch(result, predictableResult);
STATEMENT_MATCHER.assertMatch(resultStatement, predictableStatement);
SDF_02_MATCHER.assertMatch(resultSdf02, predictableSdf02);
ACCOUNT_BALANCE_MATCHER.assertMatch(resultAccountBalance, predictableNewResult.getAccount());
}
/**
* {@link Sdf01Executor#execute(Collection collection, StatementRequest statementRequest)}<br>
* Тест проверяет валидацию<br>
* Входные параметры:<br>
* accountId - {@link StatementRequest}: new StatementRequest()<br>
* addresseeId - {@link Collection<SDf01>}<br>
* addresseeId - {@link SDf01}<br>
* {@link SDf01#market} - "U"<br>
* {@link SDf01#deal} - "111111111"<br>
* {@link SDf01#account} - "123456789"<br>
* {@link SDf01#curr_code} - "RUR"<br>
* {@link SDf01#dat} - текущая дата<br>
* {@link SDf01#acc_type} - "A"<br>
* {@link SDf01#remainder} - "1000"<br>
*/
@Test
void validatedExecute() {
//CompanyNotFound
SDf01 sdf01 = getTestSdf01(ID, 1L);
companyMap.delete(addresseeIdNew);
checkError(new EnumMessage(BalanceError.CompanyNotFound), sdf01);
sdf01.setDeal(null);
checkError(new EnumMessage(BalanceError.CompanyNotFound), sdf01);
//AccountNotPresent accountType=null
sdf01.setDeal(deal);
Company company = getTestCompany();
companyMap.put(addresseeIdNew, company);
Account account = new Account();
account.setAccount(acc);
account.setStatus(Status.Active.getKey());
accountMap.put(accountIdNew, account);
checkErrorAccountNotPresent(company, sdf01);
//AccountNotPresent account=null
account.setAccount(null);
account.setAccountType(AccountType.Clrn.getKey());
account.setStatus(Status.Active.getKey());
accountMap.put(accountIdNew, account);
checkErrorAccountNotPresent(company, sdf01);
//AccountNotPresent sdf01.account==null
sdf01.setAccount(null);
checkErrorAccountNotPresent(company, sdf01);
//CurrencyNotFound sdf01.curr_code =! "RUR"
accountMap.put(accountIdNew, getTestAccount(ID, acc));
sdf01.setAccount(acc);
sdf01.setCurr_code("RUB");
checkError(new EnumMessage(BalanceError.CurrencyNotFound), sdf01);
//CurrencyNotFound sdf01.curr_code =! "RUR"
sdf01.setCurr_code(null);
checkError(new EnumMessage(BalanceError.CurrencyNotFound), sdf01);
//CurrentDateOnly
sdf01.setCurr_code("RUR");
sdf01.setDat("19.01.23");
checkError(new EnumMessage(BalanceError.CurrentDateOnly), sdf01);
//CurrentDateOnly
sdf01.setDat("19.01.2023");
checkError(new EnumMessage(BalanceError.CurrentDateOnly), sdf01);
//CurrentDateOnly
sdf01.setDat(null);
checkError(new EnumMessage(BalanceError.CurrentDateOnly), sdf01);
//WrongAccount
sdf01.setDat(LocalDate.now().format(datFormatter));
sdf01.setAcc_type(null);
checkError(new EnumMessage(BalanceError.WrongAccount), sdf01);
//WrongMarket
sdf01.setAcc_type("A");
sdf01.setMarket(null);
checkError(new EnumMessage(BalanceError.WrongMarket), sdf01);
sdf01.setMarket("U");
}
private void checkError(EnumMessage enumMessage, SDf01 sdf01) {
// SDf01 sdf01 = getTestSdf01();
SDf02 predictableSdf02 = getTestErrorSdf02(sdf01, enumMessage, ID);
Result result = sdf01Executor.execute(Collections.singletonList(sdf01), statementRequest);
Collection<SDf02> resultsSdf02 = sdf02Imdg.getCollectionObjectsByFieldValues(Map.of("account", acc));
SDf02 resultSdf02 = resultsSdf02.stream().max((entry1, entry2) -> entry1.getId() > entry2.getId() ? 1 : -1).get();
SDF_02_MATCHER.assertMatch(resultSdf02, predictableSdf02);
}
private void checkErrorAccountNotPresent(Company company, SDf01 sdf01) {
Result predictableResult = new Result();
predictableResult.getAccountRequests().add(createAccountRequestPart(sdf01.getId(), sdf01.getAccount(), company.getId()));
Result result = sdf01Executor.execute(Collections.singletonList(sdf01), statementRequest);
RESULT_MATCHER.assertMatch(result, predictableResult);
}
private SDf02 getTestSdf02(Long id, SDf01 sdf01, Long generationIdForGroup) {
SDf02 sDf02 = new SDf02();
sDf02.setId(id);
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;
}
private Statement getTestStatement(Long id, Company company, Account account, SDf01 sdf01) {
Statement statement = new Statement();
statement.setId(id);
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());
return statement;
}
private SDf02 getTestErrorSdf02(SDf01 sdf01, EnumMessage error, Long generationIdForGroup) {
SDf02 sDf02 = new SDf02();
sDf02.setId(ID);
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 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;
}
}

137
clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/StatementServiceServiceTest.java
View file

@ -1,137 +0,0 @@
package ru.spcex.clearing.balance.service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.mock.mockito.SpyBean;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.sdf.SDf01;
import ru.spcex.clearing.platform.messaging.domain.ActionType;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
import ru.spcex.clearing.platform.messaging.service.RequestInfo;
import javax.annotation.PostConstruct;
import java.util.concurrent.atomic.AtomicLong;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import static ru.spcex.clearing.balance.utils.MockKafkaUtils.addRecordToKafka;
import static ru.spcex.platform.enumeration.SdfTable.SDF_01;
class StatementServiceServiceTest extends AbstractServiceTest {
private static final String TOPIC = Consts.STATEMENT_PROCESS;
private static final int PARTITION = 1;
private static final Long groupId = 111L;
private final static AtomicLong cuurentOffset = new AtomicLong(1L);
private final Long ID = 11L;
@Autowired
StatementService statementService;
@Captor
ArgumentCaptor<ProducerRecord> producerRecord;
private MockConsumer<String, Object> mockConsumer;
private SDf01 sDf01;
private Company company;
@SpyBean
private MockProducer<String, Object> producer;
@PostConstruct
void init() {
super.init();
mockConsumer = (MockConsumer<String, Object>) statementService.getConsumer();
sDf01 = getTestSdf01(ID, groupId);
company = getTestCompany();
}
/**
* {@link StatementService}<br>
* Тест проверяет генерацию сущностей {@link RequestInfo}<br>
* Входные параметры:<br>
* {@link StatementRequest}: new StatementRequest()<br>
* {@link StatementRequest#table} - SDF_01<br>
*/
@Test
void processEXPORT_PROCESS() {
sdf01Imdg.delete(sDf01);
companyImdg.delete(company);
companyImdg.delete(company);
StatementRequest statementRequest = new StatementRequest();
statementRequest.setGroupId(groupId);
statementRequest.setTable(SDF_01);
BaseRequest<StatementRequest> baseNewRequest = new BaseRequest<>();
baseNewRequest.setRequestPayload(statementRequest);
baseNewRequest.setId(currentId.getAndIncrement());
baseNewRequest.setActionType(ActionType.NEW);
String jsonBaseNewRequest;
ObjectMapper objectMapper = new ObjectMapper();
try {
jsonBaseNewRequest = objectMapper.writeValueAsString(baseNewRequest);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
addRecordToKafka(mockConsumer, TOPIC, PARTITION, cuurentOffset.getAndIncrement(), jsonBaseNewRequest);
//waiting for kafka producer send message (finale event)
verify(producer, timeout(30_000L).times(1))
.send(producerRecord.capture());
BaseRequest<Object> baseRequest = (BaseRequest<Object>) producerRecord.getValue().value();
RequestInfo resultRequestInfo = requestInfoImdg.getSingleObjectByID(baseRequest.getId());
assertEquals(Consts.EXPORT_PROCESS, producerRecord.getValue().topic());
assertNotNull(baseRequest);
assertNotNull(resultRequestInfo);
}
/**
* {@link StatementService}<br>
* Тест проверяет генерацию сущностей {@link RequestInfo}<br>
* Входные параметры:<br>
* {@link StatementRequest}: new StatementRequest()<br>
* {@link StatementRequest#table} - SDF_01<br>
*/
@Test
void processACCOUNT_NEW() {
sdf01Imdg.insert(sDf01);
companyImdg.insert(company);
StatementRequest statementRequest = new StatementRequest();
statementRequest.setGroupId(groupId);
statementRequest.setTable(SDF_01);
BaseRequest<StatementRequest> baseNewRequest = new BaseRequest<>();
baseNewRequest.setRequestPayload(statementRequest);
baseNewRequest.setId(currentId.getAndIncrement());
baseNewRequest.setActionType(ActionType.NEW);
String jsonBaseNewRequest;
ObjectMapper objectMapper = new ObjectMapper();
try {
jsonBaseNewRequest = objectMapper.writeValueAsString(baseNewRequest);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
addRecordToKafka(mockConsumer, TOPIC, PARTITION, cuurentOffset.getAndIncrement(), jsonBaseNewRequest);
//waiting for kafka producer send message (finale event)
verify(producer, timeout(30_000L).times(1))
.send(producerRecord.capture());
BaseRequest<Object> baseRequest = (BaseRequest<Object>) producerRecord.getValue().value();
RequestInfo resultRequestInfo = requestInfoImdg.getSingleObjectByID(baseRequest.getId());
assertEquals(Consts.ACCOUNT_NEW_SDF01, producerRecord.getValue().topic());
assertNotNull(baseRequest);
assertNotNull(resultRequestInfo);
}
}

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));
}
}

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

@ -0,0 +1,98 @@
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());
}
AbstractExecutor service = executorsMap.get(table);
Result res = service.execute(sdfGroup, statementRequest);
if (res.getAccountRequests().size() != 0) {
kafkaSender.sendRequestToQueue(Consts.ACCOUNT_NEW_SDF01, createAccountsRequest(statementRequest.getGroupId(), res.getAccountRequests()));
} else if (service.isNeedToSendCommandToExport()) {
ExportToFileRequest exportRequest = new ExportToFileRequest();
exportRequest.setSdfGroupId(res.getGenerationId());
exportRequest.setNameOfTable(service.exportTableName());
kafkaSender.sendRequestToQueue(Consts.EXPORT_PROCESS, exportRequest);
}
}
private AccountSdf01Request createAccountsRequest(Long sdf01GroupingId, List<AccountSdfRequestPart> accountRequests) {
AccountSdf01Request r = new AccountSdf01Request();
r.setGroupingSdf01Id(sdf01GroupingId);
r.setAccounts(accountRequests);
return r;
}
}

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

@ -0,0 +1,12 @@
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();
public abstract boolean isNeedToSendCommandToExport();
}

40
clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/Sdf01Executor.java → clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf01Executor.java
View file

@ -1,4 +1,4 @@
package ru.spcex.clearing.balance.service;
package ru.spcex.clearing.service.executors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -9,11 +9,13 @@ 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.balance.errors.BalanceError;
import ru.spcex.clearing.balance.validation.ValidationStored;
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;
@ -40,14 +42,12 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
private final LoggingService errorLogger;
private final Imdg<SDf02> sdf02Imdg;
private final ImdgProvider imdgProvider;
private final AccountBalanceService accountBalanceService;
private final IMessageResolver errorResolver;
private final Imdg<AccountBalance> accountBalanceImdg;
public Sdf01Executor(Function<SDf01, IValidator> sDf01Validator,
LoggingService errorLogger,
ImdgProvider imdgProvider,
AccountBalanceService accountBalanceService,
IMessageResolver errorResolver) {
this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);
@ -56,15 +56,19 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
this.sDf01Validator = sDf01Validator;
this.errorLogger = errorLogger;
this.imdgProvider = imdgProvider;
this.accountBalanceService = accountBalanceService;
this.errorResolver = errorResolver;
}
@Override
String exportTableName() {
public String exportTableName() {
return "DF-02";
}
@Override
public boolean isNeedToSendCommandToExport() {
return true;
}
public Result execute(Collection<SDf01> sdf, StatementRequest statementRequest) {
Result result = new Result();
Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId();
@ -74,14 +78,14 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
Optional<EnumMessage> error = validator.tillFirstError();
Company company = validator.getStored(ValidationStored.Company);
if (statementRequest.getAccountCreationResults().size() == 0
&& BalanceError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
&& 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 (BalanceError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) {
} 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()) {
@ -101,15 +105,15 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
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());
}
// 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;

27
clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/Sdf57Executor.java → clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java
View file

@ -1,4 +1,4 @@
package ru.spcex.clearing.balance.service;
package ru.spcex.clearing.service.executors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -11,10 +11,12 @@ 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.balance.errors.BalanceError;
import ru.spcex.clearing.balance.validation.ValidationStored;
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;
@ -42,7 +44,6 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
private final LoggingService errorLogger;
private final Imdg<SDf02> sdf02Imdg;
private final ImdgProvider imdgProvider;
private final AccountBalanceService accountBalanceService;
private final IMessageResolver errorResolver;
private final Imdg<AccountBalance> accountBalanceImdg;
private final IMessageResolver messageResolver;
@ -50,7 +51,6 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
public Sdf57Executor(@Qualifier("sdf57Validator") Function<SDf57, IValidator> sDf57Validator,
LoggingService errorLogger,
ImdgProvider imdgProvider,
AccountBalanceService accountBalanceService,
IMessageResolver errorResolver, IMessageResolver messageResolver) {
this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
@ -59,15 +59,19 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
this.sDf57Validator = sDf57Validator;
this.errorLogger = errorLogger;
this.imdgProvider = imdgProvider;
this.accountBalanceService = accountBalanceService;
this.errorResolver = errorResolver;
this.messageResolver = messageResolver;
}
@Override
String exportTableName() {
return "DF-57";
} //no need...
public String exportTableName() {
return null;
}
@Override
public boolean isNeedToSendCommandToExport() {
return false;
}//no need...
//V - Изменение statement по sDf57
//
@ -142,10 +146,10 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
private Optional<EnumMessage> validateActiveness(Company company, Account account, Statement statement) {
if (!WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus())) {
return Optional.of(new EnumMessage(BalanceError.CompanyNotActive, company.getId()));
return Optional.of(new EnumMessage(ClearingError.CompanyNotActive, company.getId()));
}
if (!WorkflowStatus.Active.equalsByKey(account.getStatus())) {
return Optional.of(new EnumMessage(BalanceError.AccountNotActive, account.getId()));
return Optional.of(new EnumMessage(ClearingError.AccountNotActive, account.getId()));
}
return Optional.empty();
}
@ -195,6 +199,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
}
DateTimeFormatter payDateFormatter = DateTimeFormatter.ofPattern("yyyyMMdd");
private LocalDate payDate(String payDate) {
if (TextUtil.isEmpty(payDate)) {
return null;

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();
}
}

22
clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java → clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf01ValidationRule.java
View file

@ -1,9 +1,9 @@
package ru.spcex.clearing.balance.validation;
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.balance.errors.BalanceError;
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;
@ -23,12 +23,12 @@ public enum Sdf01ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (sdf01.getDeal() == null) {
return of(BalanceError.CompanyNotFound);
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(BalanceError.CompanyNotFound);
return of(ClearingError.CompanyNotFound);
}
context.storeObject(ValidationStored.Company, company);
return empty();
@ -39,13 +39,13 @@ public enum Sdf01ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (sdf01.getAccount() == null) {
return of(BalanceError.AccountNotPresent);
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(BalanceError.AccountNotPresent);
return of(ClearingError.AccountNotPresent);
}
context.storeObject(ValidationStored.Account, account);
return empty();
@ -56,7 +56,7 @@ public enum Sdf01ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (!"RUR".equals(sdf01.getCurr_code())) {
return of(BalanceError.CurrencyNotFound);
return of(ClearingError.CompanyDebitCheck);
}
return empty();
}
@ -66,16 +66,16 @@ public enum Sdf01ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (sdf01.getDat() == null) {
return of(BalanceError.CurrentDateOnly);
return of(ClearingError.CurrentDateOnly);
}
LocalDate date;
try {
date = LocalDate.parse(sdf01.getDat(), datFormatter);
} catch (DateTimeParseException e) {
return of(BalanceError.CurrentDateOnly);
return of(ClearingError.CurrentDateOnly);
}
if (!LocalDate.now().equals(date)) {
return of(BalanceError.CurrentDateOnly);
return of(ClearingError.CurrentDateOnly);
}
return empty();
}
@ -85,7 +85,7 @@ public enum Sdf01ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
SDf01 sdf01 = context.getValidatedObject();
if (!"A".equals(sdf01.getAcc_type())) {
return of(BalanceError.WrongAccount);
return of(ClearingError.SecurityNotFound);
}
return empty();
}

22
clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf57ValidationRule.java → clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/Sdf57ValidationRule.java
View file

@ -1,9 +1,9 @@
package ru.spcex.clearing.balance.validation;
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.balance.errors.BalanceError;
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;
@ -19,12 +19,12 @@ public enum Sdf57ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf57.getDeal_deb())) {
return of(BalanceError.CompanyNotFound, 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(BalanceError.CompanyNotFound, sdf57.getDeal_deb());
return of(ClearingError.CompanyNotFound, sdf57.getDeal_deb());
}
context.storeObject(ValidationStored.Sdf57CompanyDeb, found);
return empty();
@ -34,12 +34,12 @@ public enum Sdf57ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf57.getDeal_cred())) {
return of(BalanceError.CompanyNotFound, 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_cred() + "'");
if (found == null) {
return of(BalanceError.CompanyNotFound, sdf57.getDeal_deb());
return of(ClearingError.CompanyNotFound, sdf57.getDeal_deb());
}
context.storeObject(ValidationStored.Sdf57CompanyCred, found);
return empty();
@ -49,12 +49,12 @@ public enum Sdf57ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf57.getC_acc_deb())) {
return of(BalanceError.AccountNotPresent, sdf57.getDeal_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(BalanceError.AccountNotPresent, sdf57.getDeal_deb());
return of(ClearingError.AccountNotPresent, sdf57.getDeal_deb());
}
context.storeObject(ValidationStored.Sdf57AccountDeb, found);
return empty();
@ -65,12 +65,12 @@ public enum Sdf57ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (TextUtil.isEmpty(sdf57.getC_acc_cred())) {
return of(BalanceError.AccountNotPresent, sdf57.getDeal_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_cred() + "'");
if (found == null) {
return of(BalanceError.AccountNotPresent, sdf57.getDeal_deb());
return of(ClearingError.AccountNotPresent, sdf57.getDeal_deb());
}
context.storeObject(ValidationStored.Sdf57AccountCred, found);
return empty();
@ -81,7 +81,7 @@ public enum Sdf57ValidationRule implements IValidationRule<ImdgValidationContext
public Optional<EnumMessage> validate(ImdgValidationContext<SDf57> context) {
SDf57 sdf57 = context.getValidatedObject();
if (!ru.spcex.platform.enumeration.CurrencyCode.RUR.equalsByKey(sdf57.getPay_val())) {
return of(BalanceError.CurrencyNotFound, sdf57.getPay_val());
return of(ClearingError.CompanyDebitCheck, sdf57.getPay_val());
}
return empty();
}

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
}

111
clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/StatementServiceServiceTest.java Normal file
View file

@ -0,0 +1,111 @@
package ru.spcex.clearing.service;
//todo раскоментить тест
class StatementServiceServiceTest {
// extends AbstractServiceTest {
// private static final String TOPIC = Consts.STATEMENT_PROCESS;
// private static final int PARTITION = 1;
// private static final Long groupId = 111L;
// private final static AtomicLong cuurentOffset = new AtomicLong(1L);
// private final Long ID = 11L;
// @Autowired
// StatementService statementService;
// @Captor
// ArgumentCaptor<ProducerRecord> producerRecord;
// private MockConsumer<String, Object> mockConsumer;
// private SDf01 sDf01;
// private Company company;
// @SpyBean
// private MockProducer<String, Object> producer;
//
// @PostConstruct
// void init() {
// super.init();
// mockConsumer = (MockConsumer<String, Object>) statementService.getConsumer();
// sDf01 = getTestSdf01(ID, groupId);
// company = getTestCompany();
// }
//
// /**
// * {@link StatementService}<br>
// * Тест проверяет генерацию сущностей {@link RequestInfo}<br>
// * Входные параметры:<br>
// * {@link StatementRequest}: new StatementRequest()<br>
// * {@link StatementRequest#table} - SDF_01<br>
// */
// @Test
// void processEXPORT_PROCESS() {
// sdf01Imdg.delete(sDf01);
// companyImdg.delete(company);
//
// companyImdg.delete(company);
// StatementRequest statementRequest = new StatementRequest();
// statementRequest.setGroupId(groupId);
// statementRequest.setTable(SDF_01);
// BaseRequest<StatementRequest> baseNewRequest = new BaseRequest<>();
// baseNewRequest.setRequestPayload(statementRequest);
// baseNewRequest.setId(currentId.getAndIncrement());
// baseNewRequest.setActionType(ActionType.NEW);
// String jsonBaseNewRequest;
// ObjectMapper objectMapper = new ObjectMapper();
// try {
// jsonBaseNewRequest = objectMapper.writeValueAsString(baseNewRequest);
// } catch (JsonProcessingException e) {
// throw new RuntimeException(e);
// }
//
// addRecordToKafka(mockConsumer, TOPIC, PARTITION, cuurentOffset.getAndIncrement(), jsonBaseNewRequest);
//
// //waiting for kafka producer send message (finale event)
// verify(producer, timeout(30_000L).times(1))
// .send(producerRecord.capture());
//
// BaseRequest<Object> baseRequest = (BaseRequest<Object>) producerRecord.getValue().value();
// RequestInfo resultRequestInfo = requestInfoImdg.getSingleObjectByID(baseRequest.getId());
//
// assertEquals(Consts.EXPORT_PROCESS, producerRecord.getValue().topic());
// assertNotNull(baseRequest);
// assertNotNull(resultRequestInfo);
// }
//
// /**
// * {@link StatementService}<br>
// * Тест проверяет генерацию сущностей {@link RequestInfo}<br>
// * Входные параметры:<br>
// * {@link StatementRequest}: new StatementRequest()<br>
// * {@link StatementRequest#table} - SDF_01<br>
// */
// @Test
// void processACCOUNT_NEW() {
// sdf01Imdg.insert(sDf01);
// companyImdg.insert(company);
//
// StatementRequest statementRequest = new StatementRequest();
// statementRequest.setGroupId(groupId);
// statementRequest.setTable(SDF_01);
// BaseRequest<StatementRequest> baseNewRequest = new BaseRequest<>();
// baseNewRequest.setRequestPayload(statementRequest);
// baseNewRequest.setId(currentId.getAndIncrement());
// baseNewRequest.setActionType(ActionType.NEW);
// String jsonBaseNewRequest;
// ObjectMapper objectMapper = new ObjectMapper();
// try {
// jsonBaseNewRequest = objectMapper.writeValueAsString(baseNewRequest);
// } catch (JsonProcessingException e) {
// throw new RuntimeException(e);
// }
//
// addRecordToKafka(mockConsumer, TOPIC, PARTITION, cuurentOffset.getAndIncrement(), jsonBaseNewRequest);
//
// //waiting for kafka producer send message (finale event)
// verify(producer, timeout(30_000L).times(1))
// .send(producerRecord.capture());
//
// BaseRequest<Object> baseRequest = (BaseRequest<Object>) producerRecord.getValue().value();
// RequestInfo resultRequestInfo = requestInfoImdg.getSingleObjectByID(baseRequest.getId());
//
// assertEquals(Consts.ACCOUNT_NEW_SDF01, producerRecord.getValue().topic());
// assertNotNull(baseRequest);
// assertNotNull(resultRequestInfo);
// }
}

91
clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/builder/sql/RegistryCodeSqlBuilderTest.java
View file

@ -1,54 +1,47 @@
package ru.spcex.clearing.service.builder.sql;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import ru.spcex.clearing.models.RegistryTradingParams;
import ru.spcex.platform.enumeration.RegistryCapacity;
import ru.spcex.platform.enumeration.RegistryDesignation;
import ru.spcex.platform.enumeration.RegistryInstrumentType;
import ru.spcex.platform.enumeration.RegistryUnit;
public class RegistryCodeSqlBuilderTest {
//todo раскоментить тесты
@Test
public void testBuildByOneObject() {
RegistryTradingParams registryTradingParams = new RegistryTradingParams(RegistryDesignation.C, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R);
RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams);
String sql = registryCodeSqlBuilder.build();
Assertions.assertEquals("(registryDesignation = 'C' and registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')", sql);
registryTradingParams = new RegistryTradingParams(null, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R);
registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams);
sql = registryCodeSqlBuilder.build();
Assertions.assertEquals("(registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')", sql);
registryTradingParams = new RegistryTradingParams(RegistryDesignation.C, null, null, RegistryUnit.R);
registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams);
sql = registryCodeSqlBuilder.build();
Assertions.assertEquals("(registryDesignation = 'C' and registryUnit = 'R')", sql);
}
@Test
public void testBuildByFewObjects() {
RegistryTradingParams registryTradingParams_first = new RegistryTradingParams(RegistryDesignation.C, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R);
RegistryTradingParams registryTradingParams_second = new RegistryTradingParams(RegistryDesignation.O, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F);
RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second);
String sql = registryCodeSqlBuilder.build();
Assertions.assertEquals("(registryDesignation = 'C' and registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')" +
" or (registryDesignation = 'O' and registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql);
registryTradingParams_first = new RegistryTradingParams(null, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R);
registryTradingParams_second = new RegistryTradingParams(null, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F);
registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second);
sql = registryCodeSqlBuilder.build();
Assertions.assertEquals("(registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R') or " +
"(registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql);
registryTradingParams_first = new RegistryTradingParams(RegistryDesignation.C, null, null, RegistryUnit.R);
registryTradingParams_second = new RegistryTradingParams(null, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F);
registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second);
sql = registryCodeSqlBuilder.build();
Assertions.assertEquals("(registryDesignation = 'C' and registryUnit = 'R') or " +
"(registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql);
}
// @Test
// public void testBuildByOneObject() {
// RegistryTradingParams registryTradingParams = new RegistryTradingParams(RegistryDesignation.C, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R);
// RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams);
// String sql = registryCodeSqlBuilder.build();
// Assertions.assertEquals("(registryDesignation = 'C' and registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')", sql);
//
// registryTradingParams = new RegistryTradingParams(null, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R);
// registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams);
// sql = registryCodeSqlBuilder.build();
// Assertions.assertEquals("(registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')", sql);
//
// registryTradingParams = new RegistryTradingParams(RegistryDesignation.C, null, null, RegistryUnit.R);
// registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams);
// sql = registryCodeSqlBuilder.build();
// Assertions.assertEquals("(registryDesignation = 'C' and registryUnit = 'R')", sql);
// }
//
// @Test
// public void testBuildByFewObjects() {
// RegistryTradingParams registryTradingParams_first = new RegistryTradingParams(RegistryDesignation.C, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R);
// RegistryTradingParams registryTradingParams_second = new RegistryTradingParams(RegistryDesignation.O, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F);
// RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second);
// String sql = registryCodeSqlBuilder.build();
// Assertions.assertEquals("(registryDesignation = 'C' and registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R')" +
// " or (registryDesignation = 'O' and registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql);
//
// registryTradingParams_first = new RegistryTradingParams(null, RegistryInstrumentType.M, RegistryCapacity.B, RegistryUnit.R);
// registryTradingParams_second = new RegistryTradingParams(null, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F);
// registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second);
// sql = registryCodeSqlBuilder.build();
// Assertions.assertEquals("(registryInstrumentType = 'M' and registryCapacity = 'B' and registryUnit = 'R') or " +
// "(registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql);
//
// registryTradingParams_first = new RegistryTradingParams(RegistryDesignation.C, null, null, RegistryUnit.R);
// registryTradingParams_second = new RegistryTradingParams(null, RegistryInstrumentType.S, RegistryCapacity.A, RegistryUnit.F);
// registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParams_first, registryTradingParams_second);
// sql = registryCodeSqlBuilder.build();
// Assertions.assertEquals("(registryDesignation = 'C' and registryUnit = 'R') or " +
// "(registryInstrumentType = 'S' and registryCapacity = 'A' and registryUnit = 'F')", sql);
// }
}

238
clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/executors/Sdf01ExecutorTest.java Normal file
View file

@ -0,0 +1,238 @@
package ru.spcex.clearing.service.executors;
//todo раскоментить тест
//
class Sdf01ExecutorTest {
// extends AbstractServiceTest {
// public final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
// public final static String acc = "123456789";
// private static final MatcherFactory.Matcher<SDf02> SDF_02_MATCHER = usingIgnoringFieldsComparator("created", "comment", "outSDfId", "generationTime", "generationId", "id");
// private final Long ID = 1L;
// @Autowired
// Sdf01Executor sdf01Executor;
// private StatementRequest statementRequest;
// @SpyBean
// private MockProducer<String, Object> producer;
//
// @PostConstruct
// void init() {
// super.init();
// statementRequest = new StatementRequest();
// }
//
// /**
// * {@link Sdf01Executor#execute(Collection collection, StatementRequest statementRequest)}<br>
// * Тест проверяет генерацию сущностей {@link Result}, {@link Statement}, {@link SDf02}<br>
// * Входные параметры:<br>
// * accountId - {@link StatementRequest}: new StatementRequest()<br>
// * addresseeId - {@link Collection<SDf01>}<br>
// * addresseeId - {@link SDf01}<br>
// * {@link SDf01#market} - "U"<br>
// * {@link SDf01#deal} - "111111111"<br>
// * {@link SDf01#account} - "123456789"<br>
// * {@link SDf01#curr_code} - "RUR"<br>
// * {@link SDf01#dat} - текущая дата<br>
// * {@link SDf01#acc_type} - "A"<br>
// * {@link SDf01#remainder} - "1000"<br>
// */
// @Test
// void execute() {
// //check create statement, SDf02 and AccountBalance
// SDf01 sdf01 = getTestSdf01(ID, 1L);
// Company company = getTestCompany();
// companyMap.put(addresseeIdNew, company);
//
// Account account = getTestAccount(ID, acc);
// accountMap.put(accountIdNew, account);
//
// Result predictableResult = new Result();
// predictableResult.setGenerationId(ID);
// Statement predictableStatement = getTestStatement(currentId.getAndIncrement(), company, account, sdf01);
// predictableStatement.setOperationStatus(OperationStatus.Executed.getKey());
// SDf02 predictableSdf02 = getTestSdf02(currentId.getAndIncrement(), sdf01, ID);
// predictableStatement.setOutSDfId(predictableSdf02.getId());
// AccountResult predictableNewResult = getTestAccountResult(currentId.getAndIncrement(), account, company);
//
// Result result = sdf01Executor.execute(Collections.singletonList(sdf01), statementRequest);
// Statement resultStatement = statementImdg.getSingleObjectByFieldValues(Map.of("account", acc));
// SDf02 resultSdf02 = sdf02Imdg.getSingleObjectByFieldValues(Map.of("account", acc));
// AccountBalance resultAccountBalance = accountBalanceImdg.getSingleObjectByFieldValues(Map.of("account", acc));
//
// RESULT_MATCHER.assertMatch(result, predictableResult);
// STATEMENT_MATCHER.assertMatch(resultStatement, predictableStatement);
// SDF_02_MATCHER.assertMatch(resultSdf02, predictableSdf02);
// ACCOUNT_BALANCE_MATCHER.assertMatch(resultAccountBalance, predictableNewResult.getAccount());
// }
//
// /**
// * {@link Sdf01Executor#execute(Collection collection, StatementRequest statementRequest)}<br>
// * Тест проверяет валидацию<br>
// * Входные параметры:<br>
// * accountId - {@link StatementRequest}: new StatementRequest()<br>
// * addresseeId - {@link Collection<SDf01>}<br>
// * addresseeId - {@link SDf01}<br>
// * {@link SDf01#market} - "U"<br>
// * {@link SDf01#deal} - "111111111"<br>
// * {@link SDf01#account} - "123456789"<br>
// * {@link SDf01#curr_code} - "RUR"<br>
// * {@link SDf01#dat} - текущая дата<br>
// * {@link SDf01#acc_type} - "A"<br>
// * {@link SDf01#remainder} - "1000"<br>
// */
// @Test
// void validatedExecute() {
// //CompanyNotFound
// SDf01 sdf01 = getTestSdf01(ID, 1L);
// companyMap.delete(addresseeIdNew);
// checkError(new EnumMessage(BalanceError.CompanyNotFound), sdf01);
//
// sdf01.setDeal(null);
// checkError(new EnumMessage(BalanceError.CompanyNotFound), sdf01);
//
// //AccountNotPresent accountType=null
// sdf01.setDeal(deal);
// Company company = getTestCompany();
// companyMap.put(addresseeIdNew, company);
// Account account = new Account();
// account.setAccount(acc);
// account.setStatus(Status.Active.getKey());
// accountMap.put(accountIdNew, account);
// checkErrorAccountNotPresent(company, sdf01);
//
// //AccountNotPresent account=null
// account.setAccount(null);
// account.setAccountType(AccountType.Clrn.getKey());
// account.setStatus(Status.Active.getKey());
// accountMap.put(accountIdNew, account);
// checkErrorAccountNotPresent(company, sdf01);
//
// //AccountNotPresent sdf01.account==null
// sdf01.setAccount(null);
// checkErrorAccountNotPresent(company, sdf01);
//
// //CurrencyNotFound sdf01.curr_code =! "RUR"
// accountMap.put(accountIdNew, getTestAccount(ID, acc));
// sdf01.setAccount(acc);
// sdf01.setCurr_code("RUB");
// checkError(new EnumMessage(BalanceError.CurrencyNotFound), sdf01);
//
// //CurrencyNotFound sdf01.curr_code =! "RUR"
// sdf01.setCurr_code(null);
// checkError(new EnumMessage(BalanceError.CurrencyNotFound), sdf01);
//
// //CurrentDateOnly
// sdf01.setCurr_code("RUR");
// sdf01.setDat("19.01.23");
// checkError(new EnumMessage(BalanceError.CurrentDateOnly), sdf01);
//
// //CurrentDateOnly
// sdf01.setDat("19.01.2023");
// checkError(new EnumMessage(BalanceError.CurrentDateOnly), sdf01);
//
// //CurrentDateOnly
// sdf01.setDat(null);
// checkError(new EnumMessage(BalanceError.CurrentDateOnly), sdf01);
//
// //WrongAccount
// sdf01.setDat(LocalDate.now().format(datFormatter));
// sdf01.setAcc_type(null);
// checkError(new EnumMessage(BalanceError.WrongAccount), sdf01);
//
// //WrongMarket
// sdf01.setAcc_type("A");
// sdf01.setMarket(null);
// checkError(new EnumMessage(BalanceError.WrongMarket), sdf01);
//
// sdf01.setMarket("U");
// }
//
// private void checkError(EnumMessage enumMessage, SDf01 sdf01) {
//// SDf01 sdf01 = getTestSdf01();
// SDf02 predictableSdf02 = getTestErrorSdf02(sdf01, enumMessage, ID);
// Result result = sdf01Executor.execute(Collections.singletonList(sdf01), statementRequest);
// Collection<SDf02> resultsSdf02 = sdf02Imdg.getCollectionObjectsByFieldValues(Map.of("account", acc));
// SDf02 resultSdf02 = resultsSdf02.stream().max((entry1, entry2) -> entry1.getId() > entry2.getId() ? 1 : -1).get();
// SDF_02_MATCHER.assertMatch(resultSdf02, predictableSdf02);
// }
//
// private void checkErrorAccountNotPresent(Company company, SDf01 sdf01) {
// Result predictableResult = new Result();
// predictableResult.getAccountRequests().add(createAccountRequestPart(sdf01.getId(), sdf01.getAccount(), company.getId()));
// Result result = sdf01Executor.execute(Collections.singletonList(sdf01), statementRequest);
// RESULT_MATCHER.assertMatch(result, predictableResult);
//
// }
//
// private SDf02 getTestSdf02(Long id, SDf01 sdf01, Long generationIdForGroup) {
// SDf02 sDf02 = new SDf02();
// sDf02.setId(id);
// 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;
// }
//
// private Statement getTestStatement(Long id, Company company, Account account, SDf01 sdf01) {
// Statement statement = new Statement();
// statement.setId(id);
// 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());
// return statement;
// }
//
// private SDf02 getTestErrorSdf02(SDf01 sdf01, EnumMessage error, Long generationIdForGroup) {
// SDf02 sDf02 = new SDf02();
// sDf02.setId(ID);
// 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 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;
// }
}