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

company-service http://jira.mfd.msk:8088/browse/CLS-621

Browse source
This commit is contained in:
AKurakin 2024-04-03 16:12:56 +03:00
parent 862b7f0006
commit 867d5f928a
11 changed files with 1050 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/IdPresentRule.java
View file

@ -25,7 +25,8 @@ public record IdPresentRule<R, V extends SpcexObjectBase>(
IErrorEnumId errorEmptyRequiredValue,
IErrorEnumId errorIdNotPresent,
boolean required,
Function<V, IErrorEnumId>[] additionalChecks
Function<V, IErrorEnumId>[] additionalChecks,
Function<V, EnumMessage>[] additionalChecks2
) implements IValidationRule<ImdgValidationContext<R>> {
/**
@ -59,7 +60,29 @@ public record IdPresentRule<R, V extends SpcexObjectBase>(
errorEmptyRequiredValue,
errorIdNotPresent,
required,
additionalChecks);
additionalChecks, null);
}
@SafeVarargs
public static <R, V extends SpcexObjectBase> IdPresentRule<R, V> instance2(String fieldName,
Function<R, Long> idGetter,
String mapName,
Class<V> mapClass,
IErrorEnumId errorEmptyRequiredValue,
IErrorEnumId errorIdNotPresent,
boolean required,
Function<V, EnumMessage>... additionalChecks2) {
if (required)
Objects.requireNonNull(errorEmptyRequiredValue, "errorEmptyRequiredValue");
Objects.requireNonNull(errorIdNotPresent, "errorIdNotPresent");
return new IdPresentRule<>(fieldName,
idGetter,
mapName,
mapClass,
errorEmptyRequiredValue,
errorIdNotPresent,
required,
null, additionalChecks2);
}
/**
@ -90,7 +113,7 @@ public record IdPresentRule<R, V extends SpcexObjectBase>(
errorEmptyRequiredValue,
errorIdNotPresent,
true,
additionalChecks);
additionalChecks, null);
}
@Override
@ -103,11 +126,20 @@ public record IdPresentRule<R, V extends SpcexObjectBase>(
if (fromMap == null) {
return of(errorIdNotPresent, id, fieldName);
}
if (additionalChecks != null) {
for (Function<V, IErrorEnumId> additionalCheck : additionalChecks) {
IErrorEnumId validationError = additionalCheck.apply(fromMap);
if (validationError != null)
return of(validationError, id, fieldName);
}
}
if (additionalChecks2 != null) {
for (Function<V, EnumMessage> additionalCheck : additionalChecks2) {
EnumMessage validationError = additionalCheck.apply(fromMap);
if (validationError != null)
return Optional.of(validationError);
}
}
return empty();
}

48
clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/config/validation/CompanyRoleSetValidationConfig.java
View file

@ -13,6 +13,7 @@ import ru.spcex.clearing.company.validation.CompanySymbolOfSymbolNewRequestNotEx
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetUpdateRequest;
import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
import ru.spcex.clearing.validation.common.rules.IdPresentRule;
@ -49,14 +50,14 @@ public class CompanyRoleSetValidationConfig {
Company.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.CompanyNotFound,
false),
true),
DictionaryPresentRule.instance("companyRole",
CompanyRoleSetNewRequest::getCompanyRole,
IMDGDistributedNames.Map_CompanyRoleDictionary,
CompanyRoleDictionary.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.DictionaryNotFound,
false),
true),
DictionaryPresentRule.instance("workflowStatus",
CompanyRoleSetNewRequest::getWorkflowStatus,
IMDGDistributedNames.Map_WorkflowStatusDictionary,
@ -68,6 +69,49 @@ public class CompanyRoleSetValidationConfig {
};
}
@Bean("CompanyRoleSetUpdateRequestValidator")
public Function<CompanyRoleSetUpdateRequest, IValidator> companyRoleSetUpdateRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
return companyRoleSetNewRequest -> {
ImdgValidationContext<CompanyRoleSetUpdateRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(companyRoleSetNewRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_CompanyRoleSet);
addImdg.accept(IMDGDistributedNames.Map_CompanyRoleDictionary);
addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary);
addImdg.accept(IMDGDistributedNames.Map_Company);
return new ValidatorImpl<>(context,
IdPresentRule.instance("id",
CompanyRoleSetUpdateRequest::getId,
IMDGDistributedNames.Map_CompanyRoleSet,
CompanyRoleSet.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.RecordNotFound,
true),
IdPresentRule.instance("companyId",
CompanyRoleSetUpdateRequest::getCompanyId,
IMDGDistributedNames.Map_Company,
Company.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.CompanyNotFound,
true),
DictionaryPresentRule.instance("companyRole",
CompanyRoleSetUpdateRequest::getCompanyRole,
IMDGDistributedNames.Map_CompanyRoleDictionary,
CompanyRoleDictionary.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.DictionaryNotFound,
true),
DictionaryPresentRule.instance("workflowStatus",
CompanyRoleSetUpdateRequest::getWorkflowStatus,
IMDGDistributedNames.Map_WorkflowStatusDictionary,
WorkflowStatusDictionary.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.DictionaryNotFound,
false)
);
};
}
@Bean("CompanyRoleSetDeleteRequestValidator")
public Function<CommonDeleteRequest, IValidator> companyRoleSetDeleteRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {

240
clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/config/validation/SettlementHousePropertiesValidationConfig.java Normal file
View file

@ -0,0 +1,240 @@
package ru.spcex.clearing.company.config.validation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanyRoleSet;
import ru.clearing.classes.statics.data.company.SettlementHouseProperties;
import ru.clearing.platform.dictionary.CurrencyCodeDictionary;
import ru.spcex.clearing.company.error.CompanyErrors;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.SettlementHousePropertyNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.SettlementHousePropertyUpdateRequest;
import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
import ru.spcex.clearing.validation.common.rules.IdPresentRule;
import ru.spcex.clearing.validation.common.rules.specific.IdPresentSpecificRule;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.CompanyRole;
import ru.spcex.platform.enumeration.CurrencyCode;
import ru.spcex.platform.enumeration.Sender;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.validation.IValidationRule;
import ru.spcex.platform.utils.validation.IValidator;
import ru.spcex.platform.utils.validation.ValidatorImpl;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
@Configuration
public class SettlementHousePropertiesValidationConfig {
protected static Logger log = LoggerFactory.getLogger(SettlementHousePropertiesValidationConfig.class);
@Bean("SettlementHousePropertyNewRequestValidator")
public Function<SettlementHousePropertyNewRequest, IValidator> settlementHousePropertyNewRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
return settlementHousePropertyNewRequest -> {
ImdgValidationContext<SettlementHousePropertyNewRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(settlementHousePropertyNewRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_SettlementHouseProperties);
addImdg.accept(IMDGDistributedNames.Map_CompanyRoleDictionary);
addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary);
addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary);
addImdg.accept(IMDGDistributedNames.Map_Company);
addImdg.accept(IMDGDistributedNames.Map_CompanyRoleSet);
return new ValidatorImpl<>(context,
IdPresentRule.instance2("companyId",
SettlementHousePropertyNewRequest::getCompanyId,
IMDGDistributedNames.Map_Company,
Company.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.CompanyNotFound,
true, company -> {
Imdg<CompanyRoleSet> companyRoleSetImdg = context.obtainMap(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class);
CompanyRoleSet existRole = companyRoleSetImdg.getFirstObjectByFieldValues(Map.of(
"companyId", company.getId(),
"companyRole", CompanyRole.SETH
));
if (existRole == null || !WorkflowStatus.Active.equalsByKey(existRole.getWorkflowStatus())) {
return new EnumMessage(CompanyErrors.CompanyHasNoSETHRole, company.getShortName());
}
return null;
}),
DictionaryPresentRule.instance("currencyCode",
SettlementHousePropertyNewRequest::getCurrencyCode,
IMDGDistributedNames.Map_CurrencyCodeDictionary,
CurrencyCodeDictionary.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.DictionaryNotFound,
true),
new CheckOnDuplicateSHP<>(
SettlementHousePropertyNewRequest::getCompanyId,
SettlementHousePropertyNewRequest::getCurrencyCode),
new CheckCurrencyCodeInSHP<>(
SettlementHousePropertyNewRequest::getCompanyId,
SettlementHousePropertyNewRequest::getCurrencyCode)
);
};
}
@Bean("SettlementHousePropertyUpdateRequestValidator")
public Function<SettlementHousePropertyUpdateRequest, IValidator> settlementHousePropertyUpdateRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
return settlementHousePropertyUpdateRequest -> {
ImdgValidationContext<SettlementHousePropertyUpdateRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(settlementHousePropertyUpdateRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_SettlementHouseProperties);
addImdg.accept(IMDGDistributedNames.Map_CompanyRoleDictionary);
addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary);
addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary);
addImdg.accept(IMDGDistributedNames.Map_Company);
addImdg.accept(IMDGDistributedNames.Map_CompanyRoleSet);
return new ValidatorImpl<>(context,
IdPresentRule.instance("id",
SettlementHousePropertyUpdateRequest::getId,
IMDGDistributedNames.Map_SettlementHouseProperties,
SettlementHouseProperties.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.CompanyParametersNotFound,
true),
IdPresentRule.instance2("companyId",
SettlementHousePropertyUpdateRequest::getCompanyId,
IMDGDistributedNames.Map_Company,
Company.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.CompanyNotFound,
true, company -> {
Imdg<CompanyRoleSet> companyRoleSetImdg = context.obtainMap(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class);
CompanyRoleSet existRole = companyRoleSetImdg.getFirstObjectByFieldValues(Map.of(
"companyId", company.getId(),
"companyRole", CompanyRole.SETH
));
if (existRole == null || !WorkflowStatus.Active.equalsByKey(existRole.getWorkflowStatus())) {
return new EnumMessage(CompanyErrors.CompanyHasNoSETHRole, company.getShortName());
}
return null;
}),
DictionaryPresentRule.instance("currencyCode",
SettlementHousePropertyUpdateRequest::getCurrencyCode,
IMDGDistributedNames.Map_CurrencyCodeDictionary,
CurrencyCodeDictionary.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.DictionaryNotFound,
true),
new CheckOnDuplicateSHP<>(
SettlementHousePropertyUpdateRequest::getId,
SettlementHousePropertyUpdateRequest::getCompanyId,
SettlementHousePropertyUpdateRequest::getCurrencyCode),
new CheckCurrencyCodeInSHP<>(
SettlementHousePropertyUpdateRequest::getCompanyId,
SettlementHousePropertyUpdateRequest::getCurrencyCode)
);
};
}
@Bean("SettlementHousePropertiesDeleteRequestValidator")
public Function<CommonDeleteRequest, IValidator> settlementHousePropertiesDeleteRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
return deleteRequest -> {
ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(deleteRequest);
Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
addImdg.accept(IMDGDistributedNames.Map_SettlementHouseProperties);
addImdg.accept(IMDGDistributedNames.Map_Company);
return new ValidatorImpl<>(context,
IdPresentSpecificRule.instance("id",
CommonDeleteRequest::getId,
IMDGDistributedNames.Map_SettlementHouseProperties,
SettlementHouseProperties.class,
CompanyErrors.RequiredFieldEmpty,
CompanyErrors.CompanyNotFound,
true, shp -> {
if (shp.getCompanyId() != null) {
Company existCompany = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class)
.getSingleObjectByID(shp.getCompanyId());
if (existCompany == null)
return new EnumMessage(CompanyErrors.CompanyNotFound, shp.getCompanyId());
}
return null;
})
);
};
}
static class CheckCurrencyCodeInSHP<T> implements IValidationRule<ImdgValidationContext<T>> {
final Function<T, Long> companyIdGetter;
final Function<T, String> currencyCodeGetter;
public CheckCurrencyCodeInSHP(Function<T, Long> companyIdGetter, Function<T, String> currencyCodeGetter) {
this.companyIdGetter = companyIdGetter;
this.currencyCodeGetter = currencyCodeGetter;
}
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<T> context) {
T validatedObject = context.getValidatedObject();
Long companyId = companyIdGetter.apply(validatedObject);
String currencyCode = currencyCodeGetter.apply(validatedObject);
if (CurrencyCode.isRub(currencyCode) && !Sender.Prc.equalsById(companyId)) { // RU and companyId <> 2
return of(CompanyErrors.RuCurrencyMayOnlyNKOAOPRC, currencyCode, companyId);
}
return empty();
}
}
static class CheckOnDuplicateSHP<T> implements IValidationRule<ImdgValidationContext<T>> {
final Function<T, Long> sameObjectGetter;
final Function<T, Long> companyIdGetter;
final Function<T, String> currencyCodeGetter;
public CheckOnDuplicateSHP(Function<T, Long> companyIdGetter, Function<T, String> currencyCodeGetter) {
sameObjectGetter = null;
this.companyIdGetter = companyIdGetter;
this.currencyCodeGetter = currencyCodeGetter;
}
public CheckOnDuplicateSHP(Function<T, Long> sameObjectGetter, Function<T, Long> companyIdGetter, Function<T, String> currencyCodeGetter) {
this.sameObjectGetter = sameObjectGetter;
this.companyIdGetter = companyIdGetter;
this.currencyCodeGetter = currencyCodeGetter;
}
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<T> context) {
T validatedObject = context.getValidatedObject();
Imdg<SettlementHouseProperties> shpMap = context.obtainMap(IMDGDistributedNames.Map_SettlementHouseProperties, SettlementHouseProperties.class);
Long companyId = companyIdGetter.apply(validatedObject);
String currencyCode = currencyCodeGetter.apply(validatedObject);
if (companyId == null) {
return of(CompanyErrors.RequiredFieldEmpty, "companyId");
}
if (currencyCode == null) {
return of(CompanyErrors.RequiredFieldEmpty, "currencyCode");
}
ImdgPredicateBuilder pb = shpMap.predicateBuilder();
ImdgPredicate query = pb.and(pb.equals("companyId", companyId),
pb.equals("currencyCode", currencyCode));
Collection<SettlementHouseProperties> existSHP = shpMap.getCollectionObjectsByPredicate(query);
if (existSHP.isEmpty()) {
return empty();
} else {
return of(CompanyErrors.CurrencyAlreadyAdded, currencyCode, companyId);
}
}
}
}

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

@ -4,10 +4,7 @@ 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.ClientCode;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanyRoleSet;
import ru.clearing.classes.statics.data.company.CompanySymbols;
import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
import ru.clearing.classes.statics.data.company.*;
import ru.clearing.classes.statics.data.company.relation.Relation;
import ru.clearing.classes.statics.data.profile.Contact;
import ru.clearing.classes.statics.data.profile.ProfileDocument;
@ -58,6 +55,8 @@ public class ValidationConfig {
addImdg.accept(IMDGDistributedNames.Map_Account, Account.class);
addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
addImdg.accept(IMDGDistributedNames.Map_SettlementHouseProperties, SettlementHouseProperties.class);
addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary, CurrencyCodeDictionary.class);
return imdg;
}

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

@ -28,6 +28,10 @@ public enum CompanyErrors implements IErrorEnumId {
ClearingMemberCategoryOnMKRAlreadyExist(3024L), // Договорные отношения %s в секции МКР уже созданы.
ClearingMemberCategoryOnFONDAlreadyExist(3025L), // Договорные отношения %s на фондовой секции уже созданы.
RelationNotFound(3026L), // Запись о договорных отношениях не найдена
CurrencyAlreadyAdded(3031L), // Валюта %s уже добавлена
CompanyParametersNotFound(3032L), // Параметр компании %s не найден
RuCurrencyMayOnlyNKOAOPRC(3033L),
CompanyHasNoSETHRole(3034L), // Компания %s не является расчетной организацией
;
private final Long id;

90
clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/service/CompanyRoleSetService.java
View file

@ -16,19 +16,23 @@ 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.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetUpdateRequest;
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.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.error.ValidationException;
import ru.spcex.platform.utils.validation.IValidator;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
@Service
@ -45,6 +49,7 @@ public class CompanyRoleSetService extends QueueConsumer implements Initializing
private ValidationHelper validationHelper;
private Function<CompanyRoleSetNewRequest, IValidator> companyRoleSetNewRequestValidator;
private Function<CompanyRoleSetUpdateRequest, IValidator> companyRoleSetUpdateRequestValidator;
private Function<CommonDeleteRequest, IValidator> companyRoleSetDeleteRequestValidator;
@ -56,6 +61,8 @@ public class CompanyRoleSetService extends QueueConsumer implements Initializing
UserRoleVerification userRoleVerification,
@Qualifier("CompanyRoleSetNewRequestValidator")
Function<CompanyRoleSetNewRequest, IValidator> companyRoleSetNewRequestValidator,
@Qualifier("CompanyRoleSetUpdateRequestValidator")
Function<CompanyRoleSetUpdateRequest, IValidator> companyRoleSetUpdateRequestValidator,
@Qualifier("CompanyRoleSetDeleteRequestValidator")
Function<CommonDeleteRequest, IValidator> companyRoleSetDeleteRequestValidator
) {
@ -67,6 +74,7 @@ public class CompanyRoleSetService extends QueueConsumer implements Initializing
this.userRoleVerification = userRoleVerification;
this.validationHelper = validationHelper;
this.companyRoleSetNewRequestValidator = companyRoleSetNewRequestValidator;
this.companyRoleSetUpdateRequestValidator = companyRoleSetUpdateRequestValidator;
this.companyRoleSetDeleteRequestValidator = companyRoleSetDeleteRequestValidator;
this.requestHelper = requestHelper.setLogger(log);
}
@ -75,13 +83,13 @@ public class CompanyRoleSetService extends QueueConsumer implements Initializing
public void afterPropertiesSet() {
callback(CompanyRoleSetNewRequest.class)
.setFunction(request -> requestHelper.requestFunction(this::createCompanyRoleSet, request))
.forDestination(Consts.DESTINATION_COMPANY_ROLE_SET_NEW, callbacks::put);
// callback(CompanyRoleSetNewRequest.class)
// .setConsumer(request -> requestHelper.requestFunction(this::createCompanyRoleSet, request))
// .forDestination(Consts.DESTINATION_COMPANY_ROLE_SET_UPDATE, callbacks::put);
.forDestination(Consts.DESTINATION_COMPANY_ROLE_SETS_NEW, callbacks::put);
callback(CompanyRoleSetUpdateRequest.class)
.setConsumer(request -> requestHelper.requestFunction(this::updateCompanyRoleSet, request))
.forDestination(Consts.DESTINATION_COMPANY_ROLE_SETS_UPDATE, callbacks::put);
callback(CommonDeleteRequest.class)
.setFunction(request -> requestHelper.requestFunction(this::deleteCompanyRoleSet, request))
.forDestination(Consts.DESTINATION_COMPANY_ROLE_SET_DELETE
.forDestination(Consts.DESTINATION_COMPANY_ROLE_SETS_DELETE
, callbacks::put);
init();
}
@ -95,36 +103,72 @@ public class CompanyRoleSetService extends QueueConsumer implements Initializing
requestInfoUpdate = validationHelper.validateTillFirstError(companyRoleNewRequestBaseRequest, companyRoleSetNewRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
}
CompanyRoleSet newRole = companyRoleSetMap.getFirstObjectByFieldValues(Map.of(
{
CompanyRoleSet existRole = companyRoleSetMap.getFirstObjectByFieldValues(Map.of(
"companyId", req.getCompanyId(),
"companyRole", req.getCompanyRole()
));
if (existRole != null) {
log.debug("Update exist CompanyRoleSet[{}] for company {}. Should use UPDATE method, action was rejected.",
existRole.getId(), req.getCompanyId());
return requestHelper.makeErrorResponse(companyRoleNewRequestBaseRequest, CompanyErrors.RecordAlreadyExist, existRole.getId());
}
}
boolean isNew;
if (newRole == null) {
isNew = true;
newRole = new CompanyRoleSet();
CompanyRoleSet newRole = new CompanyRoleSet();
newRole.setId(idSequence.nextId());
newRole.setCompanyId(req.getCompanyId());
log.trace("New CompanyRoleSet[{}] for company {}", newRole.getId(), req.getCompanyId());
} else {
isNew = false;
log.trace("Update exist CompanyRoleSet[{}] for company {}", newRole.getId(), req.getCompanyId());
return requestHelper.makeErrorResponse(companyRoleNewRequestBaseRequest, CompanyErrors.RecordAlreadyExist, newRole.getId());
// if (newRole.getCompanyId() != null && req.getCompanyId() != null && !newRole.getCompanyId().equals(req.getCompanyId())) {
//// нельзя сменить компанию
// return requestHelper.makeErrorResponse(companyRoleNewRequestBaseRequest, CompanyErrors.WrongFieldValue, "companyId");
// }
}
newRole.setCompanyRole(req.getCompanyRole());
if (req.getWorkflowStatus() == null) {
newRole.setWorkflowStatus(WorkflowStatus.Active.getKey());
} else {
newRole.setWorkflowStatus(req.getWorkflowStatus());
if (isNew)
}
companyRoleSetMap.insert(newRole);
else
companyRoleSetMap.update(newRole);
log.debug("New CompanyRoleSet[{}] for company {}", newRole.getId(), req.getCompanyId());
return null;
}
private RequestInfoUpdate updateCompanyRoleSet(BaseRequest<CompanyRoleSetUpdateRequest> companyRoleUpdateRequestBaseRequest) throws ValidationException {
CompanyRoleSetUpdateRequest req = companyRoleUpdateRequestBaseRequest.getRequestPayload();
log.debug("companyroleset-update request received, BaseRequest.id = {}", companyRoleUpdateRequestBaseRequest.getId());
{ // Валидация, ValidationException
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(companyRoleUpdateRequestBaseRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(companyRoleUpdateRequestBaseRequest, companyRoleSetUpdateRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
}
CompanyRoleSet role = companyRoleSetMap.getSingleObjectByID(req.getId());
if (!Objects.equals(role.getCompanyId(), req.getCompanyId()) || !Objects.equals(role.getCompanyRole(), req.getCompanyRole())) {
log.warn("By user request [{}] want change companyId or companyRole of CompanyRoleSet[{}]",
companyRoleUpdateRequestBaseRequest.getId(), req.getId());
ImdgPredicateBuilder p = companyRoleSetMap.predicateBuilder();
CompanyRoleSet existRole = companyRoleSetMap.getFirstObjectByPredicate(p.and(
p.equals("companyId", req.getCompanyId()),
p.equals("companyRole", req.getCompanyRole()),
p.not(p.equals("id", req.getId()))
));
if (existRole != null) {
log.debug("Role \"{}\" for company {} already exist with other id={}. Action was rejected.",
req.getCompanyRole(), req.getCompanyId(), existRole.getId());
return requestHelper.makeErrorResponse(companyRoleUpdateRequestBaseRequest, CompanyErrors.RecordAlreadyExist, existRole.getId());
}
}
role.setCompanyId(req.getCompanyId());
role.setCompanyRole(req.getCompanyRole());
if (req.getWorkflowStatus() != null) {
role.setWorkflowStatus(req.getWorkflowStatus());
}
companyRoleSetMap.update(role);
log.debug("Update CompanyRoleSet[{}] for company {}", role.getId(), req.getCompanyId());
return null;
}
private RequestInfoUpdate deleteCompanyRoleSet(BaseRequest<CommonDeleteRequest> companyRoleSetDeleteRequest) throws ValidationException {
CommonDeleteRequest request = companyRoleSetDeleteRequest.getRequestPayload();

155
clearing-parent/company-service/src/main/java/ru/spcex/clearing/company/service/SettlementHousePropertiesService.java Normal file
View file

@ -0,0 +1,155 @@
package ru.spcex.clearing.company.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.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.company.SettlementHouseProperties;
import ru.spcex.clearing.company.error.CompanyErrors;
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.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.SettlementHousePropertyNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.SettlementHousePropertyUpdateRequest;
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.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.error.ValidationException;
import ru.spcex.platform.utils.validation.IValidator;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
@Service
public class SettlementHousePropertiesService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final RequestHelper requestHelper;
private final ImdgProvider imdgProvider;
// private final Imdg<Company> companyMap;
private final Imdg<SettlementHouseProperties> settlementHousePropertiesMap;
private final ImdgId idSequence;
protected UserRoleVerification userRoleVerification;
protected IMessageResolver messageResolver;
private ValidationHelper validationHelper;
private Function<SettlementHousePropertyNewRequest, IValidator> settlementHousePropertyNewRequestValidator;
private Function<SettlementHousePropertyUpdateRequest, IValidator> settlementHousePropertyUpdateRequestRequestValidator;
private Function<CommonDeleteRequest, IValidator> settlementHousePropertiesDeleteRequestValidator;
@Autowired
public SettlementHousePropertiesService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider,
RequestHelper requestHelper,
ValidationHelper validationHelper,
UserRoleVerification userRoleVerification,
@Qualifier("SettlementHousePropertyNewRequestValidator")
Function<SettlementHousePropertyNewRequest, IValidator> settlementHousePropertyNewRequestValidator,
@Qualifier("SettlementHousePropertyUpdateRequestValidator")
Function<SettlementHousePropertyUpdateRequest, IValidator> settlementHousePropertyUpdateRequestValidator,
@Qualifier("SettlementHousePropertiesDeleteRequestValidator")
Function<CommonDeleteRequest, IValidator> settlementHousePropertiesDeleteRequestValidator
) {
super(kafkaQueue, kafkaProducer);
this.imdgProvider = imdgProvider;
this.settlementHousePropertiesMap = imdgProvider.getImdg(IMDGDistributedNames.Map_SettlementHouseProperties, SettlementHouseProperties.class);
// this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.idSequence = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification;
this.validationHelper = validationHelper;
this.settlementHousePropertyNewRequestValidator = settlementHousePropertyNewRequestValidator;
this.settlementHousePropertyUpdateRequestRequestValidator = settlementHousePropertyUpdateRequestValidator;
this.settlementHousePropertiesDeleteRequestValidator = settlementHousePropertiesDeleteRequestValidator;
this.requestHelper = requestHelper.setLogger(log);
}
@Override
public void afterPropertiesSet() {
callback(SettlementHousePropertyNewRequest.class)
.setFunction(request -> requestHelper.requestFunction(this::createSettlementHouseProperty, request))
.forDestination(Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_NEW, callbacks::put);
callback(SettlementHousePropertyUpdateRequest.class)
.setConsumer(request -> requestHelper.requestFunction(this::updateSettlementHouseProperty, request))
.forDestination(Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_UPDATE, callbacks::put);
callback(CommonDeleteRequest.class)
.setFunction(request -> requestHelper.requestFunction(this::deleteSettlementHouseProperty, request))
.forDestination(Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_DELETE
, callbacks::put);
init();
}
private RequestInfoUpdate createSettlementHouseProperty(BaseRequest<SettlementHousePropertyNewRequest> settlementHousePropertyNewRequestBaseRequest) throws ValidationException {
SettlementHousePropertyNewRequest req = settlementHousePropertyNewRequestBaseRequest.getRequestPayload();
log.debug("SettlementHouseProperty-new request received, BaseRequest.id = {}", settlementHousePropertyNewRequestBaseRequest.getId());
{ // Валидация, ValidationException
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(settlementHousePropertyNewRequestBaseRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(settlementHousePropertyNewRequestBaseRequest, settlementHousePropertyNewRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
}
SettlementHouseProperties shp = new SettlementHouseProperties();
shp.setId(idSequence.nextId());
shp.setCompanyId(req.getCompanyId());
shp.setCurrencyCode(req.getCurrencyCode());
settlementHousePropertiesMap.insert(shp);
log.debug("New SettlementHouseProperties[{}] for company {}", shp.getId(), shp.getCompanyId());
return null;
}
private RequestInfoUpdate updateSettlementHouseProperty(BaseRequest<SettlementHousePropertyUpdateRequest> settlementHousePropertyUpdateRequestBaseRequest) throws ValidationException {
SettlementHousePropertyUpdateRequest req = settlementHousePropertyUpdateRequestBaseRequest.getRequestPayload();
log.debug("SettlementHouseProperty-update request received, BaseRequest.id = {}", settlementHousePropertyUpdateRequestBaseRequest.getId());
{ // Валидация, ValidationException
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(settlementHousePropertyUpdateRequestBaseRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(settlementHousePropertyUpdateRequestBaseRequest, settlementHousePropertyUpdateRequestRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
}
SettlementHouseProperties shp = settlementHousePropertiesMap.getSingleObjectByID(req.getId());
shp.setCompanyId(req.getCompanyId());
shp.setCurrencyCode(req.getCurrencyCode());
settlementHousePropertiesMap.update(shp);
log.debug("Update SettlementHouseProperty[{}] for company {}", shp.getId(), req.getCompanyId());
return null;
}
private RequestInfoUpdate deleteSettlementHouseProperty(BaseRequest<CommonDeleteRequest> settlementHousePropertyDeleteRequest) throws ValidationException {
CommonDeleteRequest request = settlementHousePropertyDeleteRequest.getRequestPayload();
log.debug("SettlementHousePropertyDeleteRequest received id = {}", request.getId());
{ // Валидация, ValidationException
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(settlementHousePropertyDeleteRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(settlementHousePropertyDeleteRequest, settlementHousePropertiesDeleteRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
}
SettlementHouseProperties settlementHouseProperty = settlementHousePropertiesMap.getSingleObjectByID(request.getId());
if (settlementHouseProperty == null) {
return requestHelper.makeErrorResponse(settlementHousePropertyDeleteRequest, CompanyErrors.RecordNotFound, request.getId());
}
settlementHousePropertiesMap.delete(settlementHouseProperty);
log.debug("SettlementHouseProperty {} for company {} delete", settlementHouseProperty.getId(), settlementHouseProperty.getCompanyId());
return null;
}
}

258
clearing-parent/company-service/src/test/java/ru/spcex/clearing/company/service/CompanyRoleSetServiceTest.java Normal file
View file

@ -0,0 +1,258 @@
package ru.spcex.clearing.company.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.Producer;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanyRoleSet;
import ru.clearing.classes.statics.data.profile.CompanyInfo;
import ru.clearing.platform.dictionary.*;
import ru.spcex.clearing.company.config.BeanConfiguration;
import ru.spcex.clearing.company.config.validation.*;
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.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyInfoUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetUpdateRequest;
import ru.spcex.clearing.test.MatcherFactory;
import ru.spcex.clearing.test.config.ImdgTestConfig;
import ru.spcex.clearing.test.config.KafkaTestConfig;
import ru.spcex.platform.enumeration.CompanyRole;
import ru.spcex.platform.enumeration.CompanySymbol;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import javax.annotation.PostConstruct;
import java.time.Instant;
import java.util.Map;
import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.test.TestUtils.*;
import static ru.spcex.clearing.test.config.ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
CompanyRoleSetService.class,
CompanyRoleSetValidationConfig.class,
ValidationConfig.class,
BeanConfiguration.class,
KafkaTestConfig.class,
ImdgTestConfig.class})
class CompanyRoleSetServiceTest {
public static final MatcherFactory.Matcher<CompanyRoleSet> COMPANY_ROLE_SET_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final Long COMPANY_ID = 105L;
@Autowired
CompanyRoleSetService companyRoleSetService;
@Autowired
@Qualifier("hazelcastServiceTest")
private ImdgProvider hazelcastServiceTest;
private Imdg<Company> companyImdg;
private Imdg<CompanyRoleSet> companyRoleSetImdg;
@Autowired
@Qualifier("mockProducer")
protected Producer<String, Object> mockProducer;
@PostConstruct
private void init() {
waitAvailableImdgProviderAndAddAdminWithDefaultId();
companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
companyRoleSetImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class);
// Словари для теста, применяются в ValidationConfig
putToDictionary(IMDGDistributedNames.Map_WorkflowStatusDictionary, new WorkflowStatusDictionary(), "ACTV");
putToDictionary(IMDGDistributedNames.Map_CompanySymbolDictionary, new CompanySymbolDictionary(), "CLRC");
putToDictionary(IMDGDistributedNames.Map_AllowedDictionary, new AllowedDictionary(), "ALWD");
putToDictionary(IMDGDistributedNames.Map_CompanyRoleDictionary, new CompanyRoleDictionary(), "RPRT");
putToDictionary(IMDGDistributedNames.Map_CompanyRoleDictionary, new CompanyRoleDictionary(), "SETH");
Company comp = new Company();
comp.setId(COMPANY_ID);
comp.setCreated(Instant.now());
comp.setFullName("Test LLC inc");
comp.setShortName("Test LLC");
comp.setProfile(new CompanyInfo());
comp.setWorkflowStatus(WorkflowStatus.Active.getKey());
companyImdg.insert(comp);
}
private <D extends AbstractDictionary /*SpcexObjectBase & Dictionary*/> void putToDictionary(String mapName, D object, String code) {
Imdg<D> dMap = (Imdg<D>) hazelcastServiceTest.getImdg(mapName, object.getClass());
object.setId(1000L + code.hashCode() % 1000);
object.setCode(code);
object.setName("name of " + code);
// assert dMap.getSingleObjectByID(object.getId()) == null;
dMap.insert(object);
}
/**
* {@link CompanyRoleSetService#createCompanyRoleSet(BaseRequest)}<br>
* * Тест проверяет создание сущности {@link CompanyRoleSet} в IMDG при передаче из Apache Kafka.<br>
* * Входной запрос {@link CompanyRoleSetNewRequest}:<br>
* * {@link CompanyRoleSetNewRequest#companyId} - COMPANY_ID (105)<br>
* * {@link CompanyRoleSetNewRequest#companyRole} - SETH<br>
* * {@link CompanyRoleSetNewRequest#workflowStatus} - ACTV<br>
*/
@Test
void companyRoleSetNew1() {
//ARRANGE
final Long ID = 102L;
final String DESTINATION_NEW = Consts.DESTINATION_COMPANY_ROLE_SETS_NEW;
companyImdg.size();
CompanyRoleSetNewRequest newRequest = new CompanyRoleSetNewRequest();
newRequest.setCompanyId(COMPANY_ID);
newRequest.setCompanyRole(CompanyRole.SETH.getKey());
newRequest.setWorkflowStatus(WorkflowStatus.Active.getKey());
//ACT
String jsonString = getJsonStringForNew(newRequest, ID);
addRecordToKafka((MockConsumer) companyRoleSetService.getConsumer(), DESTINATION_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingSendAndCheckRecord(ID, mockProducer);
CompanyRoleSet resultNew = companyRoleSetImdg.getFirstObjectByFieldValues(Map.of("companyId", COMPANY_ID));
Assertions.assertNotNull(resultNew);
Assertions.assertEquals("SETH", resultNew.getCompanyRole());
Assertions.assertEquals(WorkflowStatus.Active.getKey(), resultNew.getWorkflowStatus());
// CLEAN UP
companyRoleSetImdg.delete(resultNew);
}
/**
* {@link CompanyRoleSetService#createCompanyRoleSet(BaseRequest)}<br>
* * Тест проверяет создание сущности {@link CompanyRoleSet} в IMDG при передаче из Apache Kafka.<br>
* * Входной запрос {@link CompanyRoleSetNewRequest}:<br>
* * {@link CompanyRoleSetNewRequest#companyId} - COMPANY_ID (105)<br>
* * {@link CompanyRoleSetNewRequest#companyRole} - SETH<br>
* * {@link CompanyRoleSetNewRequest#workflowStatus} - null<br>
*/
@Disabled
@Test
void companyRoleSetNew2() {
//ARRANGE
final Long ID = 103L;
final String DESTINATION_NEW = Consts.DESTINATION_COMPANY_ROLE_SETS_NEW;
companyImdg.size();
CompanyRoleSetNewRequest newRequest = new CompanyRoleSetNewRequest();
newRequest.setCompanyId(COMPANY_ID);
newRequest.setCompanyRole(CompanyRole.SETH.getKey());
newRequest.setWorkflowStatus(null);
//ACT
String jsonString = getJsonStringForNew(newRequest, ID);
addRecordToKafka((MockConsumer) companyRoleSetService.getConsumer(), DESTINATION_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingSendAndCheckRecord(ID, mockProducer);
CompanyRoleSet resultNew = companyRoleSetImdg.getFirstObjectByFieldValues(Map.of("companyId", COMPANY_ID));
Assertions.assertNotNull(resultNew);
Assertions.assertEquals("SETH", resultNew.getCompanyRole());
Assertions.assertEquals(WorkflowStatus.Active.getKey(), resultNew.getWorkflowStatus());
// CLEAN UP
companyRoleSetImdg.delete(resultNew);
}
/**
* {@link CompanyRoleSetService#updateCompanyRoleSet(BaseRequest)}<br>
* * Тест проверяет обновление сущности {@link CompanyRoleSet} в IMDG при передаче из Apache Kafka.<br>
* * Входной запрос {@link CompanyRoleSetUpdateRequest}:<br>
* * {@link CompanyRoleSetUpdateRequest#id} - ID<br>
* * {@link CompanyRoleSetUpdateRequest#companyId} - COMPANY_ID<br>
* * {@link CompanyRoleSetUpdateRequest#companyRole} - SETH<br>
* * {@link CompanyRoleSetUpdateRequest#workflowStatus} - null<br>
*/
@Test
void companyRoleSetUpdate() {
final Long ID = 104L;
final String DESTINATION_UPDATE = Consts.DESTINATION_COMPANY_ROLE_SETS_UPDATE;
//ARRANGE
CompanyRoleSet existsCompanyRoleSet = new CompanyRoleSet();
existsCompanyRoleSet.setId(ID);
existsCompanyRoleSet.setCompanyId(COMPANY_ID);
existsCompanyRoleSet.setCompanyRole("ODEP");
companyRoleSetImdg.insert(existsCompanyRoleSet);
CompanyRoleSetUpdateRequest companyRoleSetUpdateRequest = new CompanyRoleSetUpdateRequest();
companyRoleSetUpdateRequest.setId(ID);
companyRoleSetUpdateRequest.setCompanyId(COMPANY_ID);
companyRoleSetUpdateRequest.setCompanyRole("SETH");
companyRoleSetUpdateRequest.setWorkflowStatus(WorkflowStatus.Active.getKey());
CompanyRoleSet predictableCompanyRS = new CompanyRoleSet();
predictableCompanyRS.setId(ID);
predictableCompanyRS.setCompanyId(COMPANY_ID);
predictableCompanyRS.setCompanyRole("SETH");
predictableCompanyRS.setWorkflowStatus("ACTV");
//ACT
String jsonString = getJsonStringForUpdate(companyRoleSetUpdateRequest, ID);
addRecordToKafka((MockConsumer) companyRoleSetService.getConsumer(), DESTINATION_UPDATE, PARTITION, 0, jsonString);
//ASSERT
waitingSendAndCheckRecord(ID, mockProducer);
CompanyRoleSet resultUpdating = companyRoleSetImdg.getSingleObjectByID(ID);
COMPANY_ROLE_SET_MATCHER.assertMatch(resultUpdating, predictableCompanyRS);
// CLEAN UP
companyRoleSetImdg.delete(existsCompanyRoleSet);
}
/**
* {@link CompanyRoleSetService#deleteCompanyRoleSet(BaseRequest)}<br>
* Тест проверяет удаление сущности {@link CompanyRoleSet} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link CommonDeleteRequest}:<br>
* {@link CommonDeleteRequest#id} - Идентификатор записи<br>
*/
@Test
void deleteCRS() {
//ARRANGE
final Long ID = 101L;
CompanyRoleSet existsCompanyRoleSet = new CompanyRoleSet();
existsCompanyRoleSet.setId(ID);
existsCompanyRoleSet.setCompanyId(COMPANY_ID);
existsCompanyRoleSet.setCompanyRole("ODEP");
companyRoleSetImdg.insert(existsCompanyRoleSet);
CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
commonDeleteRequest.setId(ID);
//ACT
String jsonString = getJsonStringForDelete(commonDeleteRequest, ID);
addRecordToKafka((MockConsumer) companyRoleSetService.getConsumer(), Consts.DESTINATION_COMPANY_ROLE_SETS_DELETE, PARTITION, 0, jsonString);
//ASSERT
waitingSendAndCheckRecord(ID, mockProducer);
CompanyRoleSet resultDeleting = companyRoleSetImdg.getFirstObjectBySQL("id=" + ID);
Assertions.assertNull(resultDeleting);
// Assertions.assertEquals(WorkflowStatus.Blocked.getKey(), resultDeleting.getWorkflowStatus());
// companyRoleSetImdg.delete(existsCompanyRoleSet);
}
}

227
clearing-parent/company-service/src/test/java/ru/spcex/clearing/company/service/SettlementHousePropertiesServiceTest.java Normal file
View file

@ -0,0 +1,227 @@
package ru.spcex.clearing.company.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.Producer;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanyRoleSet;
import ru.clearing.classes.statics.data.company.SettlementHouseProperties;
import ru.clearing.classes.statics.data.profile.CompanyInfo;
import ru.clearing.platform.dictionary.*;
import ru.spcex.clearing.company.config.BeanConfiguration;
import ru.spcex.clearing.company.config.validation.CompanyRoleSetValidationConfig;
import ru.spcex.clearing.company.config.validation.CompanySymbolValidationConfig;
import ru.spcex.clearing.company.config.validation.SettlementHousePropertiesValidationConfig;
import ru.spcex.clearing.company.config.validation.ValidationConfig;
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.CommonDeleteRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.SettlementHousePropertyNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.company.SettlementHousePropertyUpdateRequest;
import ru.spcex.clearing.test.MatcherFactory;
import ru.spcex.clearing.test.config.ImdgTestConfig;
import ru.spcex.clearing.test.config.KafkaTestConfig;
import ru.spcex.platform.enumeration.CompanyRole;
import ru.spcex.platform.enumeration.CurrencyCode;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import javax.annotation.PostConstruct;
import java.time.Instant;
import java.util.Map;
import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.test.TestUtils.*;
import static ru.spcex.clearing.test.config.ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
SettlementHousePropertiesService.class,
SettlementHousePropertiesValidationConfig.class,
CompanySymbolValidationConfig.class,
ValidationConfig.class,
BeanConfiguration.class,
KafkaTestConfig.class,
ImdgTestConfig.class})
class SettlementHousePropertiesServiceTest {
public static final MatcherFactory.Matcher<SettlementHouseProperties> SETTLEMENT_HOUSE_PROPERTIES_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final Long ID = 10L;
private static final Long COMPANY_ID = 105L;
@Autowired
SettlementHousePropertiesService settlementHousePropertiesService;
@Autowired
@Qualifier("hazelcastServiceTest")
private ImdgProvider hazelcastServiceTest;
private Imdg<Company> companyImdg;
private Imdg<CompanyRoleSet> companyRoleSetImdg;
private Imdg<SettlementHouseProperties> settlementHousePropertiesImdg;
@Autowired
@Qualifier("mockProducer")
protected Producer<String, Object> mockProducer;
@PostConstruct
private void init() {
waitAvailableImdgProviderAndAddAdminWithDefaultId();
companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
companyRoleSetImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class);
settlementHousePropertiesImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_SettlementHouseProperties, SettlementHouseProperties.class);
// Словари для теста, применяются в ValidationConfig
putToDictionary(IMDGDistributedNames.Map_WorkflowStatusDictionary, new WorkflowStatusDictionary(), "ACTV");
putToDictionary(IMDGDistributedNames.Map_CompanySymbolDictionary, new CompanySymbolDictionary(), "CLRC");
putToDictionary(IMDGDistributedNames.Map_AllowedDictionary, new AllowedDictionary(), "ALWD");
putToDictionary(IMDGDistributedNames.Map_CompanyRoleDictionary, new CompanyRoleDictionary(), "RPRT");
putToDictionary(IMDGDistributedNames.Map_CompanyRoleDictionary, new CompanyRoleDictionary(), "SETH");
putToDictionary(IMDGDistributedNames.Map_CurrencyCodeDictionary, new AllowedDictionary(), "RUB");
putToDictionary(IMDGDistributedNames.Map_CurrencyCodeDictionary, new AllowedDictionary(), "AED");
putToDictionary(IMDGDistributedNames.Map_CurrencyCodeDictionary, new AllowedDictionary(), "INR");
Company comp = new Company();
comp.setId(COMPANY_ID);
comp.setCreated(Instant.now());
comp.setFullName("Test LLC inc");
comp.setShortName("Test LLC");
comp.setProfile(new CompanyInfo());
comp.setWorkflowStatus(WorkflowStatus.Active.getKey());
companyImdg.insert(comp);
CompanyRoleSet crs = new CompanyRoleSet();
crs.setId(COMPANY_ID);
crs.setCompanyId(COMPANY_ID);
crs.setCompanyRole(CompanyRole.SETH.getKey());
crs.setWorkflowStatus(WorkflowStatus.Active.getKey());
companyRoleSetImdg.insert(crs);
}
private <D extends AbstractDictionary /*SpcexObjectBase & Dictionary*/> void putToDictionary(String mapName, D object, String code) {
Imdg<D> dMap = (Imdg<D>) hazelcastServiceTest.getImdg(mapName, object.getClass());
object.setId(1000L + code.hashCode() % 1000);
object.setCode(code);
object.setName("name of " + code);
// assert dMap.getSingleObjectByID(object.getId()) == null;
dMap.insert(object);
}
/**
* {@link SettlementHousePropertiesService#createSettlementHouseProperty(BaseRequest)}<br>
* * Тест проверяет создание сущности {@link SettlementHouseProperties} в IMDG при передаче из Apache Kafka.<br>
* * Входной запрос {@link SettlementHousePropertyNewRequest}:<br>
* * {@link SettlementHousePropertyNewRequest#companyId} - COMPANY_ID<br>
* * {@link SettlementHousePropertyNewRequest#currencyCode} - AED<br>
*/
@Test
void settlementHousePropertiesNew1() {
//ARRANGE
final String DESTINATION_NEW = Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_NEW;
companyImdg.size();
SettlementHousePropertyNewRequest newRequest = new SettlementHousePropertyNewRequest();
newRequest.setCompanyId(COMPANY_ID);
newRequest.setCurrencyCode("AED"); // RUB разрешён только для COMPANY_ID=2.
//ACT
String jsonString = getJsonStringForNew(newRequest, ID);
addRecordToKafka((MockConsumer) settlementHousePropertiesService.getConsumer(), DESTINATION_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingSendAndCheckRecord(ID, mockProducer);
SettlementHouseProperties resultNew = settlementHousePropertiesImdg.getFirstObjectByFieldValues(Map.of("companyId", COMPANY_ID));
Assertions.assertNotNull(resultNew);
Assertions.assertEquals("AED", resultNew.getCurrencyCode());
Assertions.assertEquals(COMPANY_ID, resultNew.getCompanyId());
// CLEAN UP
settlementHousePropertiesImdg.delete(resultNew);
}
/**
* {@link SettlementHousePropertiesService#updateSettlementHouseProperty(BaseRequest)}<br>
* * Тест проверяет обновление сущности {@link SettlementHouseProperties} в IMDG при передаче из Apache Kafka.<br>
* * Входной запрос {@link SettlementHousePropertyUpdateRequest}:<br>
* * {@link SettlementHousePropertyUpdateRequest#id} - ID<br>
* * {@link SettlementHousePropertyUpdateRequest#companyId} - COMPANY_ID<br>
* * {@link SettlementHousePropertyUpdateRequest#currencyCode} - AED<br>
*/
@Test
void companyRoleSetUpdate() {
final String DESTINATION_UPDATE = Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_UPDATE;
//ARRANGE
SettlementHouseProperties existsSettlementHouseProperties = new SettlementHouseProperties();
existsSettlementHouseProperties.setId(ID);
existsSettlementHouseProperties.setCompanyId(COMPANY_ID);
existsSettlementHouseProperties.setCurrencyCode("INR"); // Индийская рупия
settlementHousePropertiesImdg.insert(existsSettlementHouseProperties);
SettlementHousePropertyUpdateRequest settlementHousePropertyUpdateRequest = new SettlementHousePropertyUpdateRequest();
settlementHousePropertyUpdateRequest.setId(ID);
settlementHousePropertyUpdateRequest.setCompanyId(COMPANY_ID);
settlementHousePropertyUpdateRequest.setCurrencyCode("AED");
SettlementHouseProperties predictableSHP = new SettlementHouseProperties();
predictableSHP.setId(ID);
predictableSHP.setCompanyId(COMPANY_ID);
predictableSHP.setCurrencyCode("AED");
//ACT
String jsonString = getJsonStringForUpdate(settlementHousePropertyUpdateRequest, ID);
addRecordToKafka((MockConsumer) settlementHousePropertiesService.getConsumer(), DESTINATION_UPDATE, PARTITION, 0, jsonString);
//ASSERT
waitingSendAndCheckRecord(ID, mockProducer);
SettlementHouseProperties resultUpdating = settlementHousePropertiesImdg.getSingleObjectByID(ID);
SETTLEMENT_HOUSE_PROPERTIES_MATCHER.assertMatch(resultUpdating, predictableSHP);
// CLEAN UP
settlementHousePropertiesImdg.delete(resultUpdating);
}
/**
* {@link SettlementHousePropertiesService#deleteSettlementHouseProperty(BaseRequest)} (BaseRequest)}<br>
* Тест проверяет удаление сущности {@link SettlementHouseProperties} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link CommonDeleteRequest}:<br>
* {@link CommonDeleteRequest#id} - Идентификатор записи<br>
*/
@Test
void deleteSHP() throws InterruptedException {
//ARRANGE
final Long ID = 101L;
SettlementHouseProperties existsSettlementHouseProperties = new SettlementHouseProperties();
existsSettlementHouseProperties.setId(ID);
existsSettlementHouseProperties.setCompanyId(COMPANY_ID);
existsSettlementHouseProperties.setCurrencyCode(CurrencyCode.RUR.getKey());
settlementHousePropertiesImdg.insert(existsSettlementHouseProperties);
CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
commonDeleteRequest.setId(ID);
//ACT
String jsonString = getJsonStringForDelete(commonDeleteRequest, ID);
addRecordToKafka((MockConsumer) settlementHousePropertiesService.getConsumer(), Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_DELETE, PARTITION, 0, jsonString);
//ASSERT
waitingSendAndCheckRecord(ID, mockProducer);
//Company resultDeleting = companyImdg.getSingleObjectByID(ID);
SettlementHouseProperties resultDeleting = settlementHousePropertiesImdg.getFirstObjectBySQL("id=" + ID);
Assertions.assertNull(resultDeleting);
}
}

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

@ -3,7 +3,8 @@ package ru.spcex.platform.enumeration;
import ru.spcex.platform.utils.enumeration.IEnumKey;
public enum CompanyRole implements IEnumKey {
ODEP("ODEP")
ODEP("ODEP"),
SETH("SETH")
;
private final String key;

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

@ -57,9 +57,9 @@ public interface Consts {
String DESTINATION_COMPANY_SYMBOL_NEW = "company-symbol-new";
String DESTINATION_COMPANY_SYMBOL_UPDATE = "company-symbol-update";
String DESTINATION_COMPANY_SYMBOL_DELETE = "company-symbol-delete";
String DESTINATION_COMPANY_ROLE_SET_NEW = "companyroleset-new";
String DESTINATION_COMPANY_ROLE_SET_DELETE = "companyroleset-delete";
String DESTINATION_COMPANY_ROLE_SET_UPDATE = "companyroleset-update";
String DESTINATION_COMPANY_ROLE_SETS_NEW = "company-role-sets-new";
String DESTINATION_COMPANY_ROLE_SETS_UPDATE = "company-role-sets-update";
String DESTINATION_COMPANY_ROLE_SETS_DELETE = "company-role-sets-delete";
String DESTINATION_CONTACT_NEW = "contact-new";
String DESTINATION_CONTACT_UPDATE = "contact-update";
String DESTINATION_CONTACT_DELETE = "contact-delete";
@ -193,9 +193,6 @@ public interface Consts {
String DESTINATION_SETTLEMENT_HOUSE_PROPERTY_NEW = "settlement-house-properties-new";
String DESTINATION_SETTLEMENT_HOUSE_PROPERTY_UPDATE = "settlement-house-properties-update";
String DESTINATION_SETTLEMENT_HOUSE_PROPERTY_DELETE = "settlement-house-properties-delete";
String DESTINATION_COMPANY_ROLE_SETS_NEW = "company-role-sets-new";
String DESTINATION_COMPANY_ROLE_SETS_UPDATE = "company-role-sets-update";
String DESTINATION_COMPANY_ROLE_SETS_DELETE = "company-role-sets-delete";
//TODO IS IT NEEDED RIGHT HERE?
String REGISTRY_CONTRACT_REGISTER_NEW = "registry-contract-register-new";