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

Merge branch 'cls-271' into dev

Browse source
This commit is contained in:
akulikov 2023-05-10 16:10:05 +03:00
commit 907d76ed24
24 changed files with 1003 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/BeanConfiguration.java
View file

@ -6,10 +6,11 @@ import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import ru.spcex.clearing.account.errors.AccountError;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.IMDGMessageResolver;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.platform.enumeration.UserRole;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.clearing.util.services.IMDGMessageResolver;
@Configuration
public class BeanConfiguration {
@ -18,6 +19,12 @@ public class BeanConfiguration {
return new IMDGMessageResolver(imdgProvider);
}
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public RequestHelper requestHelper(IMessageResolver messageResolver) {
return new RequestHelper(messageResolver, AccountError.GeneralError);
}
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public UserRoleVerification userRoleVerification(ImdgProvider imdgProvider, IMessageResolver messageResolver) {

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

@ -5,18 +5,19 @@ import org.springframework.context.annotation.Configuration;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.platform.dictionary.AccountTypeDictionary;
import ru.clearing.platform.dictionary.ServiceStatusDictionary;
import ru.spcex.clearing.account.errors.AccountError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest;
import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
import ru.spcex.clearing.validation.common.rules.EnumPresentRule;
import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
import ru.spcex.clearing.validation.common.rules.IdPresentRule;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
@ -45,6 +46,7 @@ public class AccountValidationConfig {
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_Company);
addImdg.accept(IMDGDistributedNames.Map_Account);
addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
addImdg.accept(IMDGDistributedNames.Map_AccountTypeDictionary);
return new ValidatorImpl<>(context,
IdPresentRule.instance("companyId",
@ -69,12 +71,15 @@ public class AccountValidationConfig {
if (accounts.isEmpty()) return null;
return AccountError.AccountAlreadyExist;
}),
FieldRequiredRule.instance("status",
DictionaryPresentRule.instance("status",
CorrespondentAccountNewRequest::getStatus,
IMDGDistributedNames.Map_ServiceStatusDictionary,
ServiceStatusDictionary.class,
AccountError.RequiredFieldEmpty,
AccountError.WrongFieldValue,
false,
statusValue -> {
if (statusValue == null || AccountStatus.ACTIVE.equalsByKey(statusValue)) return null;
if (ServiceStatus.Active.equalsByKey(statusValue.getCode())) return null;
return AccountError.WrongFieldValue;
}),
DictionaryPresentRule.instance("accountType",
@ -127,16 +132,16 @@ public class AccountValidationConfig {
error = Objects.equals(company.getId(), correspondentAccountUpdateRequest.getCompanyId()) ? error : AccountError.WrongFieldValue;
return error;
}),
EnumPresentRule.instance("status",
DictionaryPresentRule.instance("status",
CorrespondentAccountUpdateRequest::getStatus,
AccountStatus.values(),
false,
AccountError.WrongFieldValue,
AccountError.RequiredFieldEmpty),
IMDGDistributedNames.Map_ServiceStatusDictionary,
ServiceStatusDictionary.class,
AccountError.RequiredFieldEmpty,
AccountError.WrongFieldValue),
DictionaryPresentRule.instance("accountType",
CorrespondentAccountUpdateRequest::getAccountType,
IMDGDistributedNames.Map_AccountTypeDictionary,
AccountTypeDictionary.class,
ServiceStatusDictionary.class,
AccountError.RequiredFieldEmpty,
AccountError.WrongFieldValue,
accountType -> {
@ -148,23 +153,23 @@ public class AccountValidationConfig {
}
@Bean("correspondentAccountBlockRequestValidator")
public Function<CommonDeleteRequest, IValidator> correspondentAccountBlockRequestValidator(
public Function<CommonIdRequest, IValidator> correspondentAccountBlockRequestValidator(
Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
) {
return correspondentAccountBlockRequest -> {
ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
ImdgValidationContext<CommonIdRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(correspondentAccountBlockRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_Account);
return new ValidatorImpl<>(context,
IdPresentRule.instance("id",
CommonDeleteRequest::getId,
CommonIdRequest::getId,
IMDGDistributedNames.Map_Account,
Account.class,
AccountError.RequiredFieldEmpty,
AccountError.AccountNotFound,
account -> {
if (AccountStatus.ACTIVE.equalsByKey(account.getStatus())) return null;
if (WorkflowStatus.Active.equalsByKey(account.getStatus())) return null;
return AccountError.AccountNotActive;
})
);

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

@ -10,13 +10,14 @@ import ru.spcex.clearing.account.errors.AccountError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest;
import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
import ru.spcex.clearing.validation.common.rules.IdPresentRule;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
@ -62,7 +63,7 @@ public class BankAccountValidationConfig {
);
ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
ImdgPredicate accountValuePredicate = pb.equals("account", accountValue);
ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey());
ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey());
ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Bank.getKey());
ImdgPredicate finalPredicate = pb.and(accountValuePredicate,
accountStatusPredicate,
@ -131,18 +132,18 @@ public class BankAccountValidationConfig {
}
@Bean("bankAccountBlockRequestValidator")
public Function<CommonDeleteRequest, IValidator> bankAccountBlockRequestValidator(
public Function<CommonIdRequest, IValidator> bankAccountBlockRequestValidator(
Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
) {
return bankAccountBlockRequest -> {
ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
ImdgValidationContext<CommonIdRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(bankAccountBlockRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_BankAccount);
addImdg.accept(IMDGDistributedNames.Map_Account);
return new ValidatorImpl<>(context,
IdPresentRule.instance("id",
CommonDeleteRequest::getId,
CommonIdRequest::getId,
IMDGDistributedNames.Map_BankAccount,
BankAccount.class,
AccountError.RequiredFieldEmpty,

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

@ -13,8 +13,8 @@ import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
import ru.spcex.clearing.validation.common.rules.IdPresentRule;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
@ -60,7 +60,7 @@ public class ClearingAccountValidationConfig {
);
ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
ImdgPredicate accountValuePredicate = pb.equals("account", accountValue);
ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey());
ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey());
ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey());
ImdgPredicate finalPredicate = pb.and(accountValuePredicate,
accountStatusPredicate,
@ -102,7 +102,7 @@ public class ClearingAccountValidationConfig {
);
ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
ImdgPredicate accountValuePredicate = pb.equals("account", accountValue);
ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey());
ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey());
ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey());
ImdgPredicate finalPredicate = pb.and(accountValuePredicate,
accountStatusPredicate,

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

@ -10,8 +10,8 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.DepoAccountNewReq
import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
import ru.spcex.clearing.validation.common.rules.IdPresentRule;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
@ -56,7 +56,7 @@ public class DepoAccountValidationConfig {
);
ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
ImdgPredicate accountValuePredicate = pb.equals("account", accountValue);
ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey());
ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey());
ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey());
ImdgPredicate finalPredicate = pb.and(accountValuePredicate,
accountStatusPredicate,

144
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java Normal file
View file

@ -0,0 +1,144 @@
package ru.spcex.clearing.account.config.validation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import ru.clearing.classes.statics.data.account.ClearingAccount;
import ru.clearing.classes.statics.data.account.DepoAccount;
import ru.clearing.classes.statics.data.account.InformationAccount;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.platform.dictionary.ServiceStatusDictionary;
import ru.spcex.clearing.account.errors.AccountError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest;
import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
import ru.spcex.clearing.validation.common.rules.IdPresentRule;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.validation.IValidator;
import ru.spcex.platform.utils.validation.ValidatorImpl;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
@Configuration
public class TradingClearingRegistryValidationConfig {
@Bean("tradingClearingRegistryNewRequest")
public Function<TradingClearingRegistryNewRequest, IValidator> tradingClearingRegistryNewRequestValidator(
Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
) {
return tradingClearingRegistryNewRequest -> {
ImdgValidationContext<TradingClearingRegistryNewRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(tradingClearingRegistryNewRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_Company);
addImdg.accept(IMDGDistributedNames.Map_ClearingAccount);
addImdg.accept(IMDGDistributedNames.Map_DepoAccount);
addImdg.accept(IMDGDistributedNames.Map_InformationAccount);
addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
return new ValidatorImpl<>(context,
IdPresentRule.instance("companyId",
TradingClearingRegistryNewRequest::getCompanyId,
IMDGDistributedNames.Map_Company,
Company.class,
AccountError.RequiredFieldEmpty,
AccountError.CompanyNotFound),
FieldRequiredRule.instance("moneyAccountId",
TradingClearingRegistryNewRequest::getMoneyAccountId,
AccountError.RequiredFieldEmpty,
moneyAccountId -> {
Imdg<ClearingAccount> clearingAccountImdg = context.obtainMap(
IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class
);
ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(moneyAccountId);
if (clearingAccount == null) {
Imdg<InformationAccount> informationAccountImdg = context.obtainMap(
IMDGDistributedNames.Map_InformationAccount, InformationAccount.class
);
InformationAccount infoAccount = informationAccountImdg.getSingleObjectByID(moneyAccountId);
if (infoAccount == null) return AccountError.AccountNotFound;
}
return null;
}),
FieldRequiredRule.instance("depoAccountId",
TradingClearingRegistryNewRequest::getDepoAccountId,
AccountError.RequiredFieldEmpty,
false,
depoAccountId -> {
if (depoAccountId == null) return null;
Imdg<DepoAccount> depoAccountImdg = context.obtainMap(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
DepoAccount depoAccount = depoAccountImdg.getSingleObjectByID(depoAccountId);
if (depoAccount == null) return AccountError.AccountNotFound;
return null;
}),
DictionaryPresentRule.instance("status",
TradingClearingRegistryNewRequest::getStatus,
IMDGDistributedNames.Map_ServiceStatusDictionary,
ServiceStatusDictionary.class,
AccountError.RequiredFieldEmpty,
AccountError.WrongFieldValue,
false,
statusValue -> {
String statusCode = statusValue.getCode();
if (ServiceStatus.Active.equalsByKey(statusCode)) return null;
return AccountError.WrongFieldValue;
})
);
};
}
@Bean("tradingClearingRegistryUpdateRequest")
public Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator(
Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
) {
return tradingClearingRegistryUpdateRequest -> {
ImdgValidationContext<TradingClearingRegistryUpdateRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(tradingClearingRegistryUpdateRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
return new ValidatorImpl<>(context,
IdPresentRule.instance("id",
TradingClearingRegistryUpdateRequest::getId,
IMDGDistributedNames.Map_TradingClearingRegistry,
TradingClearingRegistry.class,
AccountError.RequiredFieldEmpty,
AccountError.TradingClearingRegistryNotFound),
DictionaryPresentRule.instance("status",
TradingClearingRegistryUpdateRequest::getStatus,
IMDGDistributedNames.Map_ServiceStatusDictionary,
ServiceStatusDictionary.class,
AccountError.RequiredFieldEmpty,
AccountError.WrongFieldValue,
false)
);
};
}
@Bean("tradingClearingRegistryBlockRequest")
public Function<CommonIdRequest, IValidator> tradingClearingRegistryBlockRequestValidator(
Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
) {
return tradingClearingRegistryBlockRequest -> {
ImdgValidationContext<CommonIdRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(tradingClearingRegistryBlockRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
return new ValidatorImpl<>(context,
IdPresentRule.instance("id",
CommonIdRequest::getId,
IMDGDistributedNames.Map_TradingClearingRegistry,
TradingClearingRegistry.class,
AccountError.RequiredFieldEmpty,
AccountError.TradingClearingRegistryNotFound)
);
};
}
}

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

@ -3,15 +3,14 @@ package ru.spcex.clearing.account.config.validation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.account.BankAccount;
import ru.clearing.classes.statics.data.account.ClearingAccount;
import ru.clearing.classes.statics.data.account.InformationAccount;
import ru.clearing.classes.statics.data.account.*;
import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.platform.dictionary.AccountTypeDictionary;
import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary;
import ru.clearing.platform.dictionary.CurrencyCodeDictionary;
import ru.clearing.platform.dictionary.ServiceStatusDictionary;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.classes.base.SpcexObjectBase;
@ -40,6 +39,9 @@ public class ValidationConfig {
addImdg.accept(IMDGDistributedNames.Map_BankAccount, BankAccount.class);
addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary, CurrencyCodeDictionary.class);
addImdg.accept(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
addImdg.accept(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class);
addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
return imdg;
}

7
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java
View file

@ -3,6 +3,7 @@ package ru.spcex.clearing.account.errors;
import ru.spcex.platform.utils.enumeration.IErrorEnumId;
public enum AccountError implements IErrorEnumId {
GeneralError(5000L),
UserVerifyDenial(5001L),
RequiredFieldEmpty(5002L),
WrongFieldValue(5004L),
@ -12,7 +13,11 @@ public enum AccountError implements IErrorEnumId {
CompanyNotFound(5013L),
CompanyNotActive(5014L),
InfoAccountAlreadyExist(5015L),
ClearingCategoryNotFound(5019L)
TradingClearingRegistryAlreadyExist(5016L),
DepoAccountNotFound(5017L),
MoneyAccountNotFound(5018L),
ClearingCategoryNotFound(5019L),
TradingClearingRegistryNotFound(5022L),
;
private final Long id;

16
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java
View file

@ -21,15 +21,15 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf0
import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.AccountSdfToStatementRequestPart;
import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
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.RequestInfoUpdate;
import ru.spcex.clearing.platform.messaging.service.Status;
import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.ClearingCategory;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
@ -57,7 +57,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
private final ValidationHelper validationHelper;
private final Function<CorrespondentAccountNewRequest, IValidator> accountNewRequestValidator;
private final Function<CorrespondentAccountUpdateRequest, IValidator> accountUpdateRequestValidator;
private final Function<CommonDeleteRequest, IValidator> accountBlockRequestValidator;
private final Function<CommonIdRequest, IValidator> accountBlockRequestValidator;
@Autowired
public AccountService(Consumer<String, Object> kafkaQueue,
@ -72,7 +72,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
@Qualifier("correspondentAccountUpdateRequestValidator")
Function<CorrespondentAccountUpdateRequest, IValidator> accountUpdateRequestValidator,
@Qualifier("correspondentAccountBlockRequestValidator")
Function<CommonDeleteRequest, IValidator> accountBlockRequestValidator) {
Function<CommonIdRequest, IValidator> accountBlockRequestValidator) {
super(kafkaQueue, kafkaProducer);
this.accountMap = imdgProvider.getImdg(
IMDGDistributedNames.Map_Account, Account.class
@ -103,7 +103,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
callback(CorrespondentAccountUpdateRequest.class)
.setConsumer(this::correspondentAccountUpdate)
.forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_UPDATE, callbacks::put);
callback(CommonDeleteRequest.class)
callback(CommonIdRequest.class)
.setConsumer(this::correspondentAccountBlock)
.forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_BLOCK, callbacks::put);
init();
@ -161,7 +161,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
return null;
}
public RequestInfoUpdate correspondentAccountBlock(BaseRequest<CommonDeleteRequest> userRequest) {
public RequestInfoUpdate correspondentAccountBlock(BaseRequest<CommonIdRequest> userRequest) {
log.debug("AccountBlockRequest received");
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
@ -170,10 +170,10 @@ public class AccountService extends QueueConsumer implements InitializingBean {
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, accountBlockRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
CommonDeleteRequest request = userRequest.getRequestPayload();
CommonIdRequest request = userRequest.getRequestPayload();
Account account = accountMap.getSingleObjectByID(request.getId());
account.setStatus(AccountStatus.BLOCKED.getKey());
account.setStatus(ServiceStatus.Blocked.getKey());
account.setUpdated(Instant.now());
accountMap.update(account);

21
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java
View file

@ -15,13 +15,13 @@ 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.BankAccountNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
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.RequestInfoUpdate;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.ImdgTransaction;
@ -44,7 +44,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
private final Function<BankAccountNewRequest, IValidator> bankAccountNewRequestValidator;
private final Function<BankAccountUpdateRequest, IValidator> bankAccountUpdateRequestValidator;
private final Function<CommonDeleteRequest, IValidator> bankAccountBlockRequestValidator;
private final Function<CommonIdRequest, IValidator> bankAccountBlockRequestValidator;
@Autowired
public BankAccountService(Consumer<String, Object> kafkaQueue,
@ -58,7 +58,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
@Qualifier("bankAccountUpdateRequestValidator")
Function<BankAccountUpdateRequest, IValidator> bankAccountUpdateRequestValidator,
@Qualifier("bankAccountBlockRequestValidator")
Function<CommonDeleteRequest, IValidator> bankAccountBlockRequestValidator) {
Function<CommonIdRequest, IValidator> bankAccountBlockRequestValidator) {
super(kafkaQueue, kafkaProducer);
this.bankAccountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_BankAccount, BankAccount.class);
this.accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
@ -79,7 +79,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
callback(BankAccountUpdateRequest.class)
.setFunction(this::bankAccountUpdate)
.forDestination(Consts.DESTINATION_BANK_ACCOUNT_UPDATE, callbacks::put);
callback(CommonDeleteRequest.class)
callback(CommonIdRequest.class)
.setFunction(this::bankAccountBlock)
.forDestination(Consts.DESTINATION_BANK_ACCOUNT_BLOCK, callbacks::put);
init();
@ -101,7 +101,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
Account account = new Account();
account.setAccount(req.getAccount());
account.setAccountType(AccountType.Bank.getKey());
account.setStatus(AccountStatus.ACTIVE.getKey());
account.setStatus(ServiceStatus.Active.getKey());
account.setCompanyId(req.getCompanyId());
account.setCreated(now);
account.setUpdated(now);
@ -194,8 +194,8 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
return null;
}
private RequestInfoUpdate bankAccountBlock(BaseRequest<CommonDeleteRequest> userRequest) {
CommonDeleteRequest req = userRequest.getRequestPayload();
private RequestInfoUpdate bankAccountBlock(BaseRequest<CommonIdRequest> userRequest) {
CommonIdRequest req = userRequest.getRequestPayload();
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
@ -203,11 +203,11 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, bankAccountBlockRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
log.debug("CommonDeleteRequest received id = {}", req.getId());
log.debug("CommonIdRequest received id = {}", req.getId());
BankAccount bankAccount = bankAccountMap.getSingleObjectByID(req.getId());
Account account = accountMap.getSingleObjectByID(bankAccount.getAccountId());
account.setStatus(AccountStatus.BLOCKED.getKey());
account.setStatus(ServiceStatus.Blocked.getKey());
account.setUpdated(Instant.now());
ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
@ -224,7 +224,6 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
bankAccount.getId(),
account.getId());
} else {
// todo выяснить, что возвращать из метода в этой ситуации
log.debug("failed block, bank account id {}, new account id {}",
bankAccount.getId(),
account.getId());

40
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java
View file

@ -16,18 +16,19 @@ 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.ClearingAccountNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.account.ClearingAccountUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.platform.messaging.service.Status;
import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.ImdgTransaction;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.validation.IValidator;
@ -38,33 +39,39 @@ import java.util.function.Function;
@Service
public class ClearingAccountService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final KafkaSender kafkaSender;
private final AccountService accountService;
private final ValidationHelper validationHelper;
private final ImdgProvider imdgProvider;
private final Imdg<Account> accountImdg;
private final Imdg<ClearingAccount> clearingAccountImdg;
private final IMessageResolver messageResolver;
private final RequestHelper requestHelper;
private final Function<ClearingAccountNewRequest, IValidator> clearingAccountNewRequestValidator;
private final Function<ClearingAccountUpdateRequest, IValidator> clearingAccountUpdateRequestValidator;
@Autowired
public ClearingAccountService(Consumer<String, Object> kafkaQueue,
Producer<String, Object> kafkaResponseQueue,
KafkaSender kafkaSender,
AccountService accountService,
ValidationHelper validationHelper,
ImdgProvider imdgProvider,
IMessageResolver messageResolver,
RequestHelper requestHelper,
@Qualifier("clearingAccountNewRequestValidator")
Function<ClearingAccountNewRequest, IValidator> clearingAccountNewRequestValidator,
@Qualifier("clearingAccountUpdateRequestValidator")
Function<ClearingAccountUpdateRequest, IValidator> clearingAccountUpdateRequestValidator) {
super(kafkaQueue, kafkaResponseQueue);
this.kafkaSender = kafkaSender;
this.accountService = accountService;
this.validationHelper = validationHelper;
this.imdgProvider = imdgProvider;
this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
this.messageResolver = messageResolver;
this.requestHelper = requestHelper;
this.clearingAccountNewRequestValidator = clearingAccountNewRequestValidator;
this.clearingAccountUpdateRequestValidator = clearingAccountUpdateRequestValidator;
}
@ -92,7 +99,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
Account account = new Account();
account.setAccount(req.getAccount());
account.setAccountType(AccountType.Clrn.getKey());
account.setStatus(AccountStatus.ACTIVE.getKey());
account.setStatus(ServiceStatus.Active.getKey());
account.setCompanyId(req.getCompanyId());
account.setCreated(now);
account.setUpdated(now);
@ -104,10 +111,11 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
boolean txOk = false;
imdgTransaction.beginTransaction();
ClearingAccount clearingAccount = null;
try {
accountId = accountImdg.insert(account);
ClearingAccount clearingAccount = new ClearingAccount();
clearingAccount = new ClearingAccount();
clearingAccount.setCompanyId(req.getCompanyId());
clearingAccount.setAccountId(accountId);
clearingAccount.setClearingAccountType(req.getClearingAccountType());
@ -116,9 +124,12 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
} finally {
if (txOk) {
imdgTransaction.commitTransaction();
TradingClearingRegistryNewRequest request = new TradingClearingRegistryNewRequest();
request.setMoneyAccountId(accountId);
request.setCompanyId(clearingAccount.getCompanyId());
kafkaSender.sendRequestToQueue(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, request);
log.debug("successfully processed, new clearing account id {}, account id {}", clearingAccountId, accountId);
} else {
// todo выяснить, что возвращать из метода в этой ситуации
log.debug("failed insert, new clearing account id {}, new account id {} (if id = -1 then insert is failed)",
clearingAccountId,
accountId);
@ -137,7 +148,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
ClearingAccountUpdateRequest req = userRequest.getRequestPayload();
ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
ImdgPredicate accountValuePredicate = pb.equals("account", req.getAccount());
ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey());
ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey());
ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey());
ImdgPredicate finalPredicate = pb.and(accountValuePredicate,
accountStatusPredicate,
@ -147,18 +158,13 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
Long accountId = account.getId();
ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByFieldValues(Map.of("accountId", accountId));
if (clearingAccount == null) {
String errMsg = messageResolver.resolve(new EnumMessage(AccountError.AccountNotFound, account.getAccount()));
return new RequestInfoUpdate()
.setId(userRequest.getId())
.setStatus(Status.Error)
.setMessage(errMsg);
}
if (clearingAccount == null)
return requestHelper.makeErrorResponse(userRequest, AccountError.AccountNotFound, account.getAccount());
Integer statusValue = req.getStatus();
if (statusValue == 0) account.setStatus(AccountStatus.BLOCKED.getKey());
else if (statusValue == 1) account.setStatus(AccountStatus.ACTIVE.getKey());
else if (statusValue == 2) account.setStatus(AccountStatus.CLOSE.getKey());
if (statusValue == 0) account.setStatus(ServiceStatus.Blocked.getKey());
else if (statusValue == 1) account.setStatus(ServiceStatus.Active.getKey());
else if (statusValue == 2) account.setStatus(ServiceStatus.Closed.getKey());
account.setUpdated(Instant.now());
accountImdg.update(account);

17
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java
View file

@ -13,11 +13,13 @@ 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.DepoAccountNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.ImdgTransaction;
@ -30,6 +32,7 @@ import java.util.function.Function;
public class DepoAccountService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final KafkaSender kafkaSender;
private final ValidationHelper validationHelper;
private final ImdgProvider imdgProvider;
private final AccountService accountService;
@ -39,12 +42,14 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
public DepoAccountService(Consumer<String, Object> kafkaQueue,
Producer<String, Object> kafkaProducer,
KafkaSender kafkaSender,
ValidationHelper validationHelper,
ImdgProvider imdgProvider,
AccountService accountService,
@Qualifier("depoAccountNewRequestValidator")
Function<DepoAccountNewRequest, IValidator> depoAccountNewRequestValidator) {
super(kafkaQueue, kafkaProducer);
this.kafkaSender = kafkaSender;
this.validationHelper = validationHelper;
this.imdgProvider = imdgProvider;
this.accountService = accountService;
@ -74,7 +79,7 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
Account account = new Account();
account.setAccount(req.getAccount());
account.setAccountType(AccountType.Depo.getKey());
account.setStatus(AccountStatus.ACTIVE.getKey());
account.setStatus(ServiceStatus.Active.getKey());
account.setCompanyId(req.getCompanyId());
account.setCreated(now);
account.setUpdated(now);
@ -86,10 +91,11 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
boolean txOk = false;
imdgTransaction.beginTransaction();
DepoAccount depoAccount = null;
try {
accountId = accountImdg.insert(account);
DepoAccount depoAccount = new DepoAccount();
depoAccount = new DepoAccount();
depoAccount.setCompanyId(req.getCompanyId());
depoAccount.setAccountId(accountId);
depoAccount.setDepoAccountType(req.getDepoAccountType());
@ -98,9 +104,12 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
} finally {
if (txOk) {
imdgTransaction.commitTransaction();
TradingClearingRegistryNewRequest request = new TradingClearingRegistryNewRequest();
request.setDepoAccountId(accountId);
request.setCompanyId(depoAccount.getCompanyId());
kafkaSender.sendRequestToQueue(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, request);
log.debug("successfully processed, new depo account id {}, account id {}", depoAccountId, accountId);
} else {
// todo выяснить, что возвращать из метода в этой ситуации
log.debug("failed insert, new depo account id {}, new account id {} (if id = -1 then insert is failed)",
depoAccountId,
accountId);

29
clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java
View file

@ -15,18 +15,19 @@ 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.InformationAccountNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.platform.messaging.service.Status;
import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.AccountStatus;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.ImdgTransaction;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.validation.IValidator;
@ -37,10 +38,12 @@ import java.util.function.Function;
@Service
public class InformationAccountService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final KafkaSender kafkaSender;
private final IMessageResolver messageResolver;
private final ImdgProvider imdgProvider;
private final ValidationHelper validationHelper;
private final AccountService accountService;
private final RequestHelper requestHelper;
private final Function<InformationAccountNewRequest, IValidator> infoAccountNewRequestValidator;
private final Imdg<InformationAccount> informationAccountImdg;
private final Imdg<Account> accountImdg;
@ -48,17 +51,21 @@ public class InformationAccountService extends QueueConsumer implements Initiali
@Autowired
public InformationAccountService(Consumer<String, Object> kafkaQueue,
Producer<String, Object> kafkaResponseQueue,
KafkaSender kafkaSender,
IMessageResolver messageResolver,
ImdgProvider imdgProvider,
ValidationHelper validationHelper,
AccountService accountService,
RequestHelper requestHelper,
@Qualifier("informationAccountNewRequestValidator")
Function<InformationAccountNewRequest, IValidator> infoAccountNewRequestValidator) {
super(kafkaQueue, kafkaResponseQueue);
this.kafkaSender = kafkaSender;
this.messageResolver = messageResolver;
this.imdgProvider = imdgProvider;
this.validationHelper = validationHelper;
this.accountService = accountService;
this.requestHelper = requestHelper;
this.infoAccountNewRequestValidator = infoAccountNewRequestValidator;
this.informationAccountImdg = imdgProvider.getImdg(
IMDGDistributedNames.Map_InformationAccount, InformationAccount.class
@ -91,11 +98,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali
ImdgPredicate andPredicate = accountPredicateBuilder.and(companyIdPredicate, accountTypePredicate);
Collection<Account> accountsAnlt = accountImdg.getCollectionObjectsByPredicate(andPredicate);
if (accountsAnlt.isEmpty()) {
String errMsg = messageResolver.resolve(new EnumMessage(AccountError.WrongFieldValue, "clearingAccountId"));
return new RequestInfoUpdate()
.setId(userRequest.getId())
.setStatus(Status.Error)
.setMessage(errMsg);
return requestHelper.makeErrorResponse(userRequest, AccountError.WrongFieldValue, "clearingAccountId");
} else if (accountsAnlt.size() > 1) {
log.warn("Account for companyId 1 and accountType=ANLT contains multiply elements, use first");
}
@ -105,7 +108,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali
Account account = new Account();
account.setAccount(accountValue);
account.setAccountType(AccountType.Info.getKey());
account.setStatus(AccountStatus.ACTIVE.getKey());
account.setStatus(ServiceStatus.Active.getKey());
account.setCompanyId(userRequest.getRequestPayload().getCompanyId());
account.setCreated(now);
account.setUpdated(now);
@ -117,10 +120,11 @@ public class InformationAccountService extends QueueConsumer implements Initiali
boolean txOk = false;
Long informationAccountId = -1L;
Long accountId = -1L;
InformationAccount informationAccount = null;
try {
accountId = accountImdg.insert(account);
InformationAccount informationAccount = new InformationAccount();
informationAccount = new InformationAccount();
informationAccount.setId(newId);
informationAccount.setAccountId(accountId);
informationAccount.setClearingAccountId(anltAccount.getId());
@ -130,11 +134,14 @@ public class InformationAccountService extends QueueConsumer implements Initiali
} finally {
if (txOk) {
imdgTransaction.commitTransaction();
TradingClearingRegistryNewRequest request = new TradingClearingRegistryNewRequest();
request.setMoneyAccountId(informationAccountId);
request.setCompanyId(informationAccount.getCompanyId());
kafkaSender.sendRequestToQueue(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, request);
log.debug("successfully processed, new information account id {}, new account id {}",
informationAccountId,
accountId);
} else {
// todo выяснить, что возвращать из метода в этой ситуации
log.debug("failed insert, new information account id {}, new account id {} (if id = -1 then insert is failed)",
informationAccountId,
accountId);

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

@ -0,0 +1,359 @@
package ru.spcex.clearing.account.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.producer.Producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
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.ClearingAccount;
import ru.clearing.classes.statics.data.account.DepoAccount;
import ru.clearing.classes.statics.data.account.InformationAccount;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.relation.Relation;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.spcex.clearing.account.errors.AccountError;
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.common.CommonIdRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.AccountType;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose;
import ru.spcex.platform.enumeration.TradingClearingRegistryType;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.validation.IValidator;
import java.time.Instant;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
@Service
public class TradingClearingRegistryService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final ValidationHelper validationHelper;
private final UserRoleVerification userRoleVerification;
private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
private final Imdg<DepoAccount> depoAccountImdg;
private final Imdg<ClearingAccount> clearingAccountImdg;
private final Imdg<InformationAccount> informationAccountImdg;
private final Imdg<Account> accountImdg;
private final Imdg<Company> companyImdg;
private final Imdg<Relation> relationImdg;
private final Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator;
private final RequestHelper requestHelper;
private final Function<TradingClearingRegistryNewRequest, IValidator> tradingClearingRegistryNewRequestValidator;
private final Function<CommonIdRequest, IValidator> tradingClearingRegistryBlockRequestValidator;
private final IMessageResolver messageResolver;
public TradingClearingRegistryService(Consumer<String, Object> kafkaQueue,
Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider,
ValidationHelper validationHelper,
UserRoleVerification userRoleVerification,
IMessageResolver messageResolver,
RequestHelper requestHelper,
@Qualifier("tradingClearingRegistryNewRequest")
Function<TradingClearingRegistryNewRequest, IValidator> tradingClearingRegistryNewRequestValidator,
@Qualifier("tradingClearingRegistryUpdateRequest")
Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator,
@Qualifier("tradingClearingRegistryBlockRequest")
Function<CommonIdRequest, IValidator> tradingClearingRegistryBlockRequestValidator) {
super(kafkaQueue, kafkaProducer);
this.validationHelper = validationHelper;
this.userRoleVerification = userRoleVerification;
this.requestHelper = requestHelper;
this.tradingClearingRegistryNewRequestValidator = tradingClearingRegistryNewRequestValidator;
this.tradingClearingRegistryImdg = imdgProvider.getImdg(
IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class
);
this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
this.informationAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
this.relationImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Relation, Relation.class);
this.tradingClearingRegistryUpdateRequestValidator = tradingClearingRegistryUpdateRequestValidator;
this.tradingClearingRegistryBlockRequestValidator = tradingClearingRegistryBlockRequestValidator;
this.messageResolver = messageResolver;
}
@Override
public void afterPropertiesSet() throws Exception {
init();
callback(TradingClearingRegistryNewRequest.class)
.setConsumer(this::tradingClearingRegistryAutoNew)
.forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, callbacks::put);
callback(TradingClearingRegistryNewRequest.class)
.setConsumer(this::tradingClearingRegistryNew)
.forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, callbacks::put);
callback(TradingClearingRegistryUpdateRequest.class)
.setConsumer(this::tradingClearingRegistryUpdate)
.forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE, callbacks::put);
callback(CommonIdRequest.class)
.setConsumer(this::tradingClearingRegistryBlock)
.forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put);
}
public RequestInfoUpdate tradingClearingRegistryAutoNew(BaseRequest<TradingClearingRegistryNewRequest> userRequest) {
log.debug("TradingClearingRegistryNewRequest received");
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryNewRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
TradingClearingRegistryNewRequest req = userRequest.getRequestPayload();
Long id = tradingClearingRegistryImdg.nextIDSequenceFor();
TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry();
tradingClearingRegistry.setId(id);
tradingClearingRegistry.setCompanyId(req.getCompanyId());
tradingClearingRegistry.setMoneyAccountId(req.getMoneyAccountId());
tradingClearingRegistry.setDepoAaccountId(req.getDepoAccountId());
DepoAccount depoAccount = req.getDepoAccountId() != null ? depoAccountImdg.getSingleObjectByID(req.getDepoAccountId()) : null;
Account depoAccountMain = depoAccount != null ? accountImdg.getSingleObjectByID(depoAccount.getAccountId()) : null;
InformationAccount infoAccount = null;
ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId());
if (clearingAccount == null) infoAccount = informationAccountImdg.getSingleObjectByID(req.getMoneyAccountId());
Long accountId = clearingAccount != null ? clearingAccount.getAccountId() : infoAccount.getAccountId();
Account accountMain = accountImdg.getSingleObjectByID(accountId);
// TODO
// Проверка выглядит очень сложно и запутанно, потому что репортеры сами не до конца понимают, какая она должна быть.
// Пока что она соответствует ТЗ, но возможно будет правиться, поэтому расписана без выноса кода в методы и
// прочих методов сокращения кода. В дальнейшем, после тестирования и окончательного выяснения вида проверки,
// её стоит вынести на этап валидации запроса.
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()));
if (registry != null) {
return requestHelper.makeErrorResponse(userRequest,
AccountError.TradingClearingRegistryAlreadyExist,
req.getCompanyId(),
registry.getId());
}
DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
if (depoAccountForCheck == null)
return requestHelper.makeErrorResponse(userRequest, AccountError.DepoAccountNotFound, req.getCompanyId());
} else if (ru.spcex.platform.enumeration.Service.FOND.equalsByKey(relation.getService())) {
if (AccountType.Info.equalsByKey(accountMain.getStatus())) {
TradingClearingRegistry registry = tradingClearingRegistryImdg.getSingleObjectByFieldValues(Map.of(
"companyId", req.getCompanyId(),
"tradingClearingRegistryType", TradingClearingRegistryPurpose.M.getKey()
));
if (registry != null) {
return requestHelper.makeErrorResponse(userRequest,
AccountError.TradingClearingRegistryAlreadyExist,
req.getCompanyId(),
registry.getId());
}
DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
if (depoAccountForCheck == null)
return requestHelper.makeErrorResponse(userRequest, AccountError.DepoAccountNotFound, req.getCompanyId());
} else if (AccountType.Clrn.equalsByKey(accountMain.getStatus())) {
ImdgPredicateBuilder imdgPredicateBuilder = tradingClearingRegistryImdg.predicateBuilder();
ImdgPredicate predicate = imdgPredicateBuilder.and(
imdgPredicateBuilder.equals("companyId", req.getCompanyId()),
imdgPredicateBuilder.or(
imdgPredicateBuilder.equals("tradingClearingRegistryPurpose", TradingClearingRegistryPurpose.M.getKey()),
imdgPredicateBuilder.equals("tradingClearingRegistryPurpose", TradingClearingRegistryPurpose.C.getKey())
)
);
Collection<TradingClearingRegistry> registry = tradingClearingRegistryImdg.getCollectionObjectsByPredicate(predicate);
if (!registry.isEmpty()) {
return requestHelper.makeErrorResponse(userRequest,
AccountError.TradingClearingRegistryAlreadyExist,
req.getCompanyId(),
registry.iterator().next().getId());
}
DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
if (depoAccountForCheck == null) {
return requestHelper.makeErrorResponse(userRequest, AccountError.DepoAccountNotFound, req.getCompanyId());
}
} else if (AccountType.Depo.equalsByKey(accountMain.getStatus())) {
InformationAccount infoAccountForCheck = informationAccountImdg.getSingleObjectByFieldValues(
Map.of("companyId", req.getCompanyId())
);
ClearingAccount clearingAccountForCheck = clearingAccountImdg.getSingleObjectByFieldValues(
Map.of("companyId", req.getCompanyId())
);
if (infoAccountForCheck == null && clearingAccountForCheck == null)
return requestHelper.makeErrorResponse(userRequest, AccountError.MoneyAccountNotFound, req.getCompanyId());
}
}
List<String> activeStatuses = Arrays.asList(ServiceStatus.Active.getKey(), ServiceStatus.Reopened.getKey());
String status = null;
if (depoAccountMain != null && depoAccountMain.getStatus() != null) {
if (activeStatuses.contains(depoAccountMain.getStatus()) && activeStatuses.contains(accountMain.getStatus()))
status = ServiceStatus.Active.getKey();
if (depoAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey()) || accountMain.getStatus().equals(ServiceStatus.Blocked.getKey()))
status = ServiceStatus.Blocked.getKey();
if (depoAccountMain.getStatus().equals(ServiceStatus.Suspended.getKey()) || accountMain.getStatus().equals(ServiceStatus.Suspended.getKey()))
status = ServiceStatus.Suspended.getKey();
if (depoAccountMain.getStatus().equals(ServiceStatus.Closed.getKey()) || accountMain.getStatus().equals(ServiceStatus.Closed.getKey()))
status = ServiceStatus.Closed.getKey();
} else if (accountMain.getStatus() != null) {
if (activeStatuses.contains(accountMain.getStatus()))
status = ServiceStatus.Active.getKey();
if (accountMain.getStatus().equals(ServiceStatus.Blocked.getKey()))
status = ServiceStatus.Blocked.getKey();
if (accountMain.getStatus().equals(ServiceStatus.Suspended.getKey()))
status = ServiceStatus.Suspended.getKey();
if (accountMain.getStatus().equals(ServiceStatus.Closed.getKey()))
status = ServiceStatus.Closed.getKey();
}
if (status == null)
return requestHelper.makeErrorResponse(userRequest, AccountError.WrongFieldValue, req.getMoneyAccountId());
tradingClearingRegistry.setStatus(status);
String tradingRegistryType;
if (depoAccount != null) {
tradingRegistryType = depoAccount.getDepoAccountType();
} else {
if (clearingAccount != null) tradingRegistryType = clearingAccount.getClearingAccountType();
else tradingRegistryType = TradingClearingRegistryType.Owner_A.getKey();
}
tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType);
TradingClearingRegistryPurpose registryPurpose;
if (req.getDepoAccountId() != null) registryPurpose = TradingClearingRegistryPurpose.C;
else registryPurpose = TradingClearingRegistryPurpose.M;
tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey());
Company company = companyImdg.getSingleObjectByID(req.getCompanyId());
String code = "%4s".formatted(company.getClearingCode()).replace(' ', '0');
code += registryPurpose.getKey();
if (registryPurpose == TradingClearingRegistryPurpose.C) code += tradingRegistryType + id;
else code += "AT" + id;
tradingClearingRegistry.setCode(code);
Instant now = Instant.now();
tradingClearingRegistry.setCreated(now);
tradingClearingRegistry.setUpdated(now);
tradingClearingRegistryImdg.insert(tradingClearingRegistry);
log.debug("successfully processed, id {}", id);
return null;
}
public RequestInfoUpdate tradingClearingRegistryNew(BaseRequest<TradingClearingRegistryNewRequest> userRequest) {
log.debug("TradingClearingRegistryNewRequest received");
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryNewRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
TradingClearingRegistryNewRequest req = userRequest.getRequestPayload();
Long id = tradingClearingRegistryImdg.nextIDSequenceFor();
TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry();
tradingClearingRegistry.setId(id);
tradingClearingRegistry.setCompanyId(req.getCompanyId());
tradingClearingRegistry.setMoneyAccountId(req.getMoneyAccountId());
tradingClearingRegistry.setDepoAaccountId(req.getDepoAccountId());
DepoAccount depoAccount = req.getDepoAccountId() != null ? depoAccountImdg.getSingleObjectByID(req.getDepoAccountId()) : null;
ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId());
tradingClearingRegistry.setStatus(ServiceStatus.Active.getKey());
String tradingRegistryType;
if (depoAccount != null) {
tradingRegistryType = depoAccount.getDepoAccountType();
} else {
if (clearingAccount != null) tradingRegistryType = clearingAccount.getClearingAccountType();
else tradingRegistryType = TradingClearingRegistryType.Owner_A.getKey();
}
tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType);
TradingClearingRegistryPurpose registryPurpose;
if (req.getDepoAccountId() != null) registryPurpose = TradingClearingRegistryPurpose.C;
else registryPurpose = TradingClearingRegistryPurpose.M;
tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey());
Company company = companyImdg.getSingleObjectByID(req.getCompanyId());
String code = "%4s".formatted(company.getClearingCode()).replace(' ', '0');
code += registryPurpose.getKey();
if (registryPurpose == TradingClearingRegistryPurpose.C) code += tradingRegistryType + id;
else code += "AT" + id;
tradingClearingRegistry.setCode(code);
Instant now = Instant.now();
tradingClearingRegistry.setCreated(now);
tradingClearingRegistry.setUpdated(now);
tradingClearingRegistryImdg.insert(tradingClearingRegistry);
log.debug("successfully processed, id {}", id);
return null;
}
public RequestInfoUpdate tradingClearingRegistryUpdate(BaseRequest<TradingClearingRegistryUpdateRequest> userRequest) {
log.debug("TradingClearingRegistryUpdateRequest received");
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryUpdateRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
TradingClearingRegistryUpdateRequest req = userRequest.getRequestPayload();
TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId());
if (req.getStatus() != null) tradingClearingRegistry.setStatus(req.getStatus());
Instant now = Instant.now();
tradingClearingRegistry.setUpdated(now);
tradingClearingRegistryImdg.update(tradingClearingRegistry);
log.debug("successfully processed, id {}", tradingClearingRegistry.getId());
return null;
}
public RequestInfoUpdate tradingClearingRegistryBlock(BaseRequest<CommonIdRequest> userRequest) {
log.debug("TradingClearingRegistryBlockRequest received");
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryBlockRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
CommonIdRequest req = userRequest.getRequestPayload();
TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId());
tradingClearingRegistry.setStatus(ServiceStatus.Blocked.getKey());
tradingClearingRegistry.setUpdated(Instant.now());
tradingClearingRegistryImdg.update(tradingClearingRegistry);
log.debug("successfully processed, id {}", tradingClearingRegistry.getId());
return null;
}
}

21
clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/AccountServiceTest.java
View file

@ -19,6 +19,7 @@ import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.relation.Relation;
import ru.clearing.platform.dictionary.AccountTypeDictionary;
import ru.clearing.platform.dictionary.ServiceStatusDictionary;
import ru.spcex.clearing.account.config.BeanConfiguration;
import ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.account.config.KafkaConfigTest;
@ -87,6 +88,7 @@ class AccountServiceTest {
private Imdg<AccountTypeDictionary> accountTypeDictionaryImdg;
private Imdg<ClearingMemberCategory> clearingMemberCategoryImdg;
private Imdg<Relation> relationImdg;
private Imdg<ServiceStatusDictionary> serviceStatusDictionaryImdg;
@PostConstruct
private void init() {
@ -106,6 +108,13 @@ class AccountServiceTest {
relationImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_Relation, Relation.class
);
serviceStatusDictionaryImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class
);
ServiceStatusDictionary serviceStatusDictionary = new ServiceStatusDictionary();
serviceStatusDictionary.setCode(ServiceStatus.Active.getKey());
serviceStatusDictionary.setName(ServiceStatus.Active.getKey());
serviceStatusDictionaryImdg.insert(serviceStatusDictionary);
Company company = new Company();
company.setId(companyId);
@ -137,13 +146,13 @@ class AccountServiceTest {
correspondentAccountNewRequest.setAccount(uniqueAccount);
correspondentAccountNewRequest.setAccountType(AccountType.Corr.getKey());
correspondentAccountNewRequest.setCompanyId(companyId);
correspondentAccountNewRequest.setStatus(AccountStatus.ACTIVE.getKey());
correspondentAccountNewRequest.setStatus(ServiceStatus.Active.getKey());
Account predictableAccount = new Account();
predictableAccount.setAccount(uniqueAccount);
predictableAccount.setAccountType(AccountType.Corr.getKey());
predictableAccount.setCompanyId(companyId);
predictableAccount.setStatus(AccountStatus.ACTIVE.getKey());
predictableAccount.setStatus(ServiceStatus.Active.getKey());
predictableAccount.setRelationId(relationId);
String jsonString = getJsonStringForNew(correspondentAccountNewRequest, 0L);
@ -169,14 +178,14 @@ class AccountServiceTest {
Account existAccount = new Account();
existAccount.setAccount(account);
existAccount.setAccountType(AccountType.Corr.getKey());
existAccount.setStatus(AccountStatus.CLOSE.getKey());
existAccount.setStatus(ServiceStatus.Closed.getKey());
existAccount.setCompanyId(companyId);
Long accountId = accountImdg.insert(existAccount);
CorrespondentAccountUpdateRequest correspondentAccountUpdateRequest = new CorrespondentAccountUpdateRequest();
correspondentAccountUpdateRequest.setAccount(account);
correspondentAccountUpdateRequest.setAccountType(AccountType.Corr.getKey());
correspondentAccountUpdateRequest.setStatus(AccountStatus.ACTIVE.getKey());
correspondentAccountUpdateRequest.setStatus(ServiceStatus.Active.getKey());
correspondentAccountUpdateRequest.setCompanyId(companyId);
correspondentAccountUpdateRequest.setId(accountId);
@ -204,7 +213,7 @@ class AccountServiceTest {
Account existAccount = new Account();
existAccount.setAccount(account);
existAccount.setAccountType(AccountType.Corr.getKey());
existAccount.setStatus(AccountStatus.ACTIVE.getKey());
existAccount.setStatus(ServiceStatus.Active.getKey());
existAccount.setCompanyId(companyId);
Long accountId = accountImdg.insert(existAccount);
@ -224,7 +233,7 @@ class AccountServiceTest {
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
Account resultBlock = accountImdg.getSingleObjectByID(accountId);
existAccount.setStatus(AccountStatus.BLOCKED.getKey());
existAccount.setStatus(ServiceStatus.Blocked.getKey());
existAccount.setUpdated(resultBlock.getUpdated());
ACCOUNT_MATCHER.assertMatch(existAccount, resultBlock);

11
clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java
View file

@ -37,6 +37,8 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.util.Map;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.account.utils.TestUtils.*;
@ -151,12 +153,13 @@ class ClearingAccountServiceTest {
0,
jsonString);
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
verify(producer, timeout(30_000L).times(2))
.send(producerRecord.capture());
Account predictableAccount = new Account();
predictableAccount.setAccount(ACCOUNT_VALUE);
predictableAccount.setAccountType(AccountType.Clrn.getKey());
predictableAccount.setStatus(AccountStatus.ACTIVE.getKey());
predictableAccount.setStatus(ServiceStatus.Active.getKey());
predictableAccount.setRelationId(relationId);
predictableAccount.setCompanyId(companyId);
@ -182,7 +185,7 @@ class ClearingAccountServiceTest {
void clearingAccountUpdate() {
Account existAccount = new Account();
existAccount.setAccount(ACCOUNT_VALUE);
existAccount.setStatus(AccountStatus.ACTIVE.getKey());
existAccount.setStatus(ServiceStatus.Active.getKey());
existAccount.setAccountType(AccountType.Clrn.getKey());
Long accountId = accountImdg.insert(existAccount);
@ -193,7 +196,7 @@ class ClearingAccountServiceTest {
Account predictableAccount = new Account();
predictableAccount.setAccount(ACCOUNT_VALUE);
predictableAccount.setStatus(AccountStatus.BLOCKED.getKey());
predictableAccount.setStatus(ServiceStatus.Blocked.getKey());
predictableAccount.setAccountType(AccountType.Clrn.getKey());
clearingAccountImdg.insert(existClearingAccount);

10
clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/DepoAccountServiceTest.java
View file

@ -36,8 +36,11 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.util.Map;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.account.utils.TestUtils.*;
import static ru.spcex.clearing.account.utils.TestUtils.addRecordToKafka;
import static ru.spcex.clearing.account.utils.TestUtils.getJsonStringForNew;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
@ -150,12 +153,13 @@ class DepoAccountServiceTest {
0,
jsonString);
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
verify(producer, timeout(30_000L).times(2))
.send(producerRecord.capture());
Account predictableAccount = new Account();
predictableAccount.setAccount(ACCOUNT_VALUE);
predictableAccount.setAccountType(AccountType.Depo.getKey());
predictableAccount.setStatus(AccountStatus.ACTIVE.getKey());
predictableAccount.setStatus(ServiceStatus.Active.getKey());
predictableAccount.setRelationId(relationId);
predictableAccount.setCompanyId(companyId);

11
clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java
View file

@ -35,8 +35,11 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.util.Map;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.account.utils.TestUtils.*;
import static ru.spcex.clearing.account.utils.TestUtils.addRecordToKafka;
import static ru.spcex.clearing.account.utils.TestUtils.getJsonStringForNew;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
@ -140,11 +143,13 @@ class InformationAccountServiceTest {
0,
jsonString);
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
//waiting for kafka producer send message (finale event)
verify(producer, timeout(30_000L).times(2))
.send(producerRecord.capture());
Account predictableAccount = new Account();
predictableAccount.setAccountType(AccountType.Info.getKey());
predictableAccount.setStatus(AccountStatus.ACTIVE.getKey());
predictableAccount.setStatus(ServiceStatus.Active.getKey());
predictableAccount.setRelationId(relationId);
predictableAccount.setCompanyId(companyId);

314
clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java Normal file
View file

@ -0,0 +1,314 @@
package ru.spcex.clearing.account.service;
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.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.account.ClearingAccount;
import ru.clearing.classes.statics.data.account.DepoAccount;
import ru.clearing.classes.statics.data.account.InformationAccount;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.platform.dictionary.ServiceStatusDictionary;
import ru.spcex.clearing.account.config.BeanConfiguration;
import ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.account.config.KafkaConfigTest;
import ru.spcex.clearing.account.config.validation.TradingClearingRegistryValidationConfig;
import ru.spcex.clearing.account.config.validation.ValidationConfig;
import ru.spcex.clearing.account.utils.MatcherFactory;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose;
import ru.spcex.platform.enumeration.TradingClearingRegistryType;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.account.utils.TestUtils.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
BeanConfiguration.class,
ValidationConfig.class,
TradingClearingRegistryValidationConfig.class,
TradingClearingRegistryService.class,
HazelcastServiceTestConfiguration.class,
KafkaConfigTest.class})
class TradingClearingRegistryServiceTest {
public static final MatcherFactory.Matcher<TradingClearingRegistry> TRADING_CLEARING_REGISTRY_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final String TOPIC_ACCOUNT_NEW = Consts.ACCOUNT_NEW_SDF01;
private static final String account = "123456789123";
private static final Long companyId = 0L;
private static final Long relationId = 0L;
@Autowired
TradingClearingRegistryService tradingClearingRegistryService;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> producer;
private Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
private Imdg<Company> companyImdg;
private Imdg<ServiceStatusDictionary> serviceStatusDictionaryImdg;
private Imdg<ClearingAccount> clearingAccountImdg;
private Long clearingAccountId;
private Imdg<DepoAccount> depoAccountImdg;
private Long depoAccountId;
private Imdg<InformationAccount> informationAccountImdg;
private Long infoAccountId;
private Imdg<Account> accountImdg;
private Long accountId;
private Long account2Id;
static int newRequestCnt = 0;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
tradingClearingRegistryImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class
);
companyImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_Company, Company.class
);
serviceStatusDictionaryImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class
);
accountImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_Account, Account.class
);
clearingAccountImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class
);
depoAccountImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_DepoAccount, DepoAccount.class
);
informationAccountImdg = hazelcastServiceTest.getImdg(
IMDGDistributedNames.Map_InformationAccount, InformationAccount.class
);
ServiceStatusDictionary serviceStatusDictionary = new ServiceStatusDictionary();
serviceStatusDictionary.setCode(ServiceStatus.Active.getKey());
serviceStatusDictionary.setName(ServiceStatus.Active.getKey());
serviceStatusDictionaryImdg.insert(serviceStatusDictionary);
Company company = new Company();
company.setId(companyId);
company.setWorkflowStatus(WorkflowStatus.Active.getKey());
company.setClearingCode("77");
companyImdg.insert(company);
Account account = new Account();
account.setStatus(ServiceStatus.Active.getKey());
accountId = accountImdg.insert(account);
account2Id = accountImdg.insert(account);
DepoAccount depoAccount = new DepoAccount();
depoAccount.setAccountId(accountId);
depoAccount.setDepoAccountType("DAT");
depoAccountId = depoAccountImdg.insert(depoAccount);
ClearingAccount clearingAccount = new ClearingAccount();
clearingAccount.setAccountId(accountId);
clearingAccount.setClearingAccountType("CAT");
clearingAccountId = clearingAccountImdg.insert(clearingAccount);
InformationAccount informationAccount = new InformationAccount();
informationAccount.setAccountId(account2Id);
infoAccountId = informationAccountImdg.insert(informationAccount);
}
@Test
void tradingClearingRegistryNew_moneyAccount_clearingAccount() {
TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest();
tradingClearingRegistryNewRequest.setCompanyId(companyId);
tradingClearingRegistryNewRequest.setMoneyAccountId(clearingAccountId);
TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry();
predictableTradingClearingRegistry.setCompanyId(companyId);
predictableTradingClearingRegistry.setCode("0077MAT");
predictableTradingClearingRegistry.setMoneyAccountId(clearingAccountId);
predictableTradingClearingRegistry.setTradingClearingRegistryType("CAT");
predictableTradingClearingRegistry.setTradingClearingRegistryPurpose(TradingClearingRegistryPurpose.M.getKey());
predictableTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey());
String jsonString = getJsonStringForNew(tradingClearingRegistryNewRequest, 0L);
addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW,
newRequestCnt,
0,
jsonString);
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next();
predictableTradingClearingRegistry.setId(resultNew.getId());
predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId());
predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated());
predictableTradingClearingRegistry.setCreated(resultNew.getCreated());
TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry);
tradingClearingRegistryImdg.delete(resultNew);
newRequestCnt++;
}
@Test
void tradingClearingRegistryNew_moneyAccount_informationAccount() {
TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest();
tradingClearingRegistryNewRequest.setCompanyId(companyId);
tradingClearingRegistryNewRequest.setMoneyAccountId(infoAccountId);
TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry();
predictableTradingClearingRegistry.setCompanyId(companyId);
predictableTradingClearingRegistry.setCode("0077MAT");
predictableTradingClearingRegistry.setMoneyAccountId(infoAccountId);
predictableTradingClearingRegistry.setTradingClearingRegistryType(TradingClearingRegistryType.Owner_A.getKey());
predictableTradingClearingRegistry.setTradingClearingRegistryPurpose(TradingClearingRegistryPurpose.M.getKey());
predictableTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey());
String jsonString = getJsonStringForNew(tradingClearingRegistryNewRequest, 0L);
addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW,
newRequestCnt,
0,
jsonString);
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next();
predictableTradingClearingRegistry.setId(resultNew.getId());
predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId());
predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated());
predictableTradingClearingRegistry.setCreated(resultNew.getCreated());
TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry);
tradingClearingRegistryImdg.delete(resultNew);
newRequestCnt++;
}
@Test
void tradingClearingRegistryNew_depoAccount() {
TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest();
tradingClearingRegistryNewRequest.setCompanyId(companyId);
tradingClearingRegistryNewRequest.setMoneyAccountId(clearingAccountId);
tradingClearingRegistryNewRequest.setDepoAccountId(depoAccountId);
TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry();
predictableTradingClearingRegistry.setCompanyId(companyId);
predictableTradingClearingRegistry.setCode("0077CDAT");
predictableTradingClearingRegistry.setMoneyAccountId(clearingAccountId);
predictableTradingClearingRegistry.setDepoAaccountId(depoAccountId);
predictableTradingClearingRegistry.setTradingClearingRegistryType("DAT");
predictableTradingClearingRegistry.setTradingClearingRegistryPurpose(TradingClearingRegistryPurpose.C.getKey());
predictableTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey());
String jsonString = getJsonStringForNew(tradingClearingRegistryNewRequest, 0L);
addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW,
newRequestCnt,
0,
jsonString);
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next();
predictableTradingClearingRegistry.setId(resultNew.getId());
predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId());
predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated());
predictableTradingClearingRegistry.setCreated(resultNew.getCreated());
TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry);
tradingClearingRegistryImdg.delete(resultNew);
newRequestCnt++;
}
@Test
void tradingClearingRegistryUpdate() {
TradingClearingRegistry existTradingClearingRegistry = new TradingClearingRegistry();
existTradingClearingRegistry.setStatus(ServiceStatus.Closed.getKey());
Long registryId = tradingClearingRegistryImdg.insert(existTradingClearingRegistry);
TradingClearingRegistryUpdateRequest tradingClearingRegistryUpdateRequest = new TradingClearingRegistryUpdateRequest();
tradingClearingRegistryUpdateRequest.setStatus(ServiceStatus.Active.getKey());
tradingClearingRegistryUpdateRequest.setId(registryId);
String jsonString = getJsonStringForUPDATE(tradingClearingRegistryUpdateRequest, 0);
//ACT
addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE,
PARTITION,
0,
jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
TradingClearingRegistry resultUpdating = tradingClearingRegistryImdg.getSingleObjectByID(registryId);
existTradingClearingRegistry.setUpdated(resultUpdating.getUpdated());
existTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey());
TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultUpdating, existTradingClearingRegistry);
tradingClearingRegistryImdg.delete(resultUpdating);
}
@Test
void tradingClearingRegistryBlock() {
TradingClearingRegistry existTradingClearingRegistry = new TradingClearingRegistry();
existTradingClearingRegistry.setStatus(ServiceStatus.Closed.getKey());
Long registryId = tradingClearingRegistryImdg.insert(existTradingClearingRegistry);
CommonDeleteRequest tradingClearingRegistryDeleteRequest = new CommonDeleteRequest();
tradingClearingRegistryDeleteRequest.setId(registryId);
String jsonString = getJsonStringForDELETE(tradingClearingRegistryDeleteRequest, 0);
//ACT
addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK,
PARTITION,
0,
jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
TradingClearingRegistry resultUpdating = tradingClearingRegistryImdg.getSingleObjectByID(registryId);
existTradingClearingRegistry.setUpdated(resultUpdating.getUpdated());
existTradingClearingRegistry.setStatus(ServiceStatus.Blocked.getKey());
TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultUpdating, existTradingClearingRegistry);
tradingClearingRegistryImdg.delete(resultUpdating);
}
}

4
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryController.java
View file

@ -10,9 +10,9 @@ import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryNewAction;
import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryUpdateAction;
import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
@ -69,7 +69,7 @@ public class TradingClearingRegistryController extends AbstractQueueController {
@PathVariable("id") Long id) throws ExecutionException, InterruptedException {
CommonDeleteAction deleteAction = new CommonDeleteAction();
deleteAction.setId(id);
return processRequest(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_DELETE, deleteAction);
return processRequest(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, deleteAction);
}
@ApiOperation(value = "get TradingClearingRegistry by id.")

4
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryControllerTest.java
View file

@ -6,9 +6,9 @@ import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryNewAction;
import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryUpdateAction;
import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
import ru.spcex.clearing.backendapi.controller.response.entity.registry.TradingClearingRegistryBackendGetById;
import ru.spcex.clearing.backendapi.controller.response.entity.registry.TradingClearingRegistryBackendGetFields;
import ru.spcex.clearing.backendapi.domain.actions.IAction;
@ -97,7 +97,7 @@ class TradingClearingRegistryControllerTest extends AbstractControllerTest {
deleteAction.setId(id);
//ACT and ASSERT
checkDeletingByRestApi(REST_URL, id);
checkSendedMessegeFromKafka(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_DELETE, deleteAction);
checkSendedMessegeFromKafka(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, deleteAction);
}
/**

1
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/registry/TradingClearingRegistry.java
View file

@ -15,6 +15,7 @@ public class TradingClearingRegistry extends BusinessObject {
private Long companyId;
private String code;
private Long moneyAccountId;
// todo fix typo
private Long depoAaccountId;
private String tradingClearingRegistryType;
private String tradingClearingRegistryLevel;

20
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/TradingClearingRegistryPurpose.java Normal file
View file

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

3
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java
View file

@ -85,9 +85,10 @@ public interface Consts {
String DESTINATION_CLIENT_CODE_DELETE = "client-code-delete";
String DESTINATION_TRADING_CLEARING_REGISTRY_NEW = "trading-clearing-registry-new";
String DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW = "trading-clearing-registry-auto-new";
String DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE = "trading-clearing-registry-update";
String DESTINATION_TRADING_CLEARING_REGISTRY_DELETE = "trading-clearing-registry-delete";
// String DESTINATION_TRADING_CLEARING_REGISTRY_REPLY = "trading-clearing-registry";
String DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK = "trading-clearing-registry-block";
String DESTINATION_SDF08_NEW = "s-df-08-new";
String DESTINATION_SDF02_NEW = "s-df-02-new";