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

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

Browse source
This commit is contained in:
ialbert 2023-05-22 17:48:27 +03:00
parent 91b7b99f86
commit bea0c96d64
8 changed files with 219 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -8,11 +8,13 @@ import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.relation.Relation;
import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
import ru.clearing.classes.statics.data.misc.STrades;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.classes.statics.data.security.Security;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.service.validation.ClrngValidationStored;
import ru.spcex.clearing.service.validation.ExecutionDepositValidationRule;
import ru.spcex.clearing.service.validation.RegistryStep3ValidationRule;
import ru.spcex.clearing.service.validation.STradesValidationRule;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.enumeration.ClearingCategory;
@ -86,4 +88,23 @@ public class ValidationConfig {
STradesValidationRule.TradingClearingRegistryPresent);
};
}
@Bean("obligationAndRequirementsAdmissionValidator")
public Function<Registry, IValidator> registryValidator() {
return rgs -> {
ImdgValidationContext<Registry> context = new ImdgValidationContext<>();
context.setValidatedObject(rgs);
addImdg.accept(context, IMDGDistributedNames.Map_Relation);
addImdg.accept(context, IMDGDistributedNames.Map_Session);
addImdg.accept(context, IMDGDistributedNames.Map_SectionDictionary);
addImdg.accept(context, IMDGDistributedNames.Map_Account);
addImdg.accept(context, IMDGDistributedNames.Map_Company);
addImdg.accept(context, IMDGDistributedNames.Map_TradingClearingRegistry);
return new ValidatorImpl<>(context,
RegistryStep3ValidationRule.ClearingAvailable,
RegistryStep3ValidationRule.AccountActive,
RegistryStep3ValidationRule.CompanyActive,
RegistryStep3ValidationRule.TradingClearingRegistryActive);
};
}
}

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

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

104
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/RegistryStep3ValidationRule.java Normal file
View file

@ -0,0 +1,104 @@
package ru.spcex.clearing.service.validation;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.relation.Relation;
import ru.clearing.classes.statics.data.misc.Session;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
import ru.clearing.platform.dictionary.SectionDictionary;
import ru.spcex.clearing.error.ClearingError;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.enumeration.ServiceStatus;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
public enum RegistryStep3ValidationRule implements IValidationRule<ImdgValidationContext<Registry>> {
ClearingAvailable() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<Registry> context) {
Registry validatedObject = context.getValidatedObject();
Supplier<String> sectionFind = () -> {
Imdg<Session> sessionImdg = context.obtainMap(IMDGDistributedNames.Map_Session, Session.class);
Imdg<SectionDictionary> sectionDictionaryImdg = context.obtainMap(IMDGDistributedNames.Map_SectionDictionary, SectionDictionary.class);
Session session = sessionImdg.getSingleObjectByID(validatedObject.getSessionId());
if (session == null) {
return "null";
} else {
SectionDictionary section = sectionDictionaryImdg.getSingleObjectBySQL("code ='" + session.getSection() + "'");
if (section == null) {
return "null";
} else {
return section.getName();
}
}
};
if (validatedObject.getCompanyId() == null) {
return of(ClearingError.ClearingUnavailableForCompany, sectionFind.get());
}
Imdg<Relation> relationImdg = context.obtainMap(IMDGDistributedNames.Map_Relation, Relation.class);
Relation relation = relationImdg.getSingleObjectByFieldValues(Map.of("consumerId", validatedObject.getCompanyId()));
if (relation == null || (!ServiceStatus.Active.equalsByKey(relation.getServiceStatus()) && !ServiceStatus.Reopened.equalsByKey(relation.getServiceStatus()))) {
return of(ClearingError.ClearingUnavailableForCompany, sectionFind.get(), validatedObject.getCompanyId());
}
context.storeObject(RegistryValidationStored.Relation, relation);
return empty();
}
},
AccountActive() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<Registry> context) {
Registry validatedObject = context.getValidatedObject();
Relation relation = context.getStoredObject(RegistryValidationStored.Relation);
Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
Account account = accountImdg.getSingleObjectBySQL("id = %d and relationId = %d".formatted(validatedObject.getAccountId(), relation.getId()));
if (account == null || (!IEnumKey.contains(account.getStatus(), ServiceStatus.Active, ServiceStatus.Reopened))) {
return of(ClearingError.AccountNotActive, validatedObject.getAccountId());
}
return empty();
}
},
CompanyActive() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<Registry> context) {
Registry validatedObject = context.getValidatedObject();
Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
if (validatedObject.getCompanyId() == null) {
return of(ClearingError.CompanyNotActive, validatedObject.getCompanyId());
}
Company company = companyImdg.getSingleObjectBySQL("id = %d".formatted(validatedObject.getCompanyId()));
if (company == null || !WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus())) {
return of(ClearingError.CompanyNotActive, validatedObject.getCompanyId());
}
return empty();
}
},
TradingClearingRegistryActive() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<Registry> context) {
Registry validatedObject = context.getValidatedObject();
if (validatedObject.getTradingClearingRegistryId() == null) {
return of(ClearingError.TradingClearingRegistryNotActive, validatedObject.getTradingClearingRegistryId());
}
Imdg<TradingClearingRegistry> tradingClearingRegistryImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
TradingClearingRegistry tcr = tradingClearingRegistryImdg.getSingleObjectBySQL("id = " + validatedObject.getTradingClearingRegistryId());
if (tcr == null || (ServiceStatus.Active.equalsByKey(tcr.getStatus()) || ServiceStatus.Reopened.equalsByKey(tcr.getStatus())))
return of(ClearingError.TradingClearingRegistryNotActive, validatedObject.getTradingClearingRegistryId());
return empty();
}
},
;
@Override
public String ruleName() {
return "STradesValidationRule." + name();
}
}

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

@ -0,0 +1,5 @@
package ru.spcex.clearing.service.validation;
public enum RegistryValidationStored {
Relation
}

4
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/TaskType.java
View file

@ -15,6 +15,10 @@ public enum TaskType {
* step 2
*/
RequirementsAndObligationsCreate,
/**
* step 3
*/
ObligationsAdmission,
/**
* step 4
*/

79
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/ObligationAdmission.java Normal file
View file

@ -0,0 +1,79 @@
package ru.spcex.clearing.session.stage.impl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.registry.Registry;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.session.stage.ISessionStage;
import ru.spcex.clearing.session.stage.StageResult;
import ru.spcex.clearing.session.stage.Task;
import ru.spcex.clearing.session.stage.TaskType;
import ru.spcex.platform.enumeration.RegistryStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.validation.IValidator;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
@Service
public class ObligationAdmission implements ISessionStage {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<Registry> registryImdg;
private final ImdgProvider imdgProvider;
private final Function<Registry, IValidator> validatorFactory;
private final IMessageResolver messageResolver;
@Autowired
public ObligationAdmission(ImdgProvider imdgProvider,
@Qualifier("obligationAndRequirementsAdmissionValidator") Function<Registry, IValidator> validatorFactory,
IMessageResolver messageResolver) {
this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.imdgProvider = imdgProvider;
this.validatorFactory = validatorFactory;
this.messageResolver = messageResolver;
}
@SuppressWarnings("unchecked")
@Override
public StageResult<?> submit(Task<?> task) {
if (task.getTaskType() == TaskType.ObligationsAdmission) {
return obligationAdmission((Long) task.getData());
}
throw new IllegalStateException("Unknown task type: " + task.getTaskType());
}
private StageResult<?> obligationAdmission(Long sessionId) {
Collection<Registry> registries = registryImdg.getCollectionObjectsBySQL("sessionId = " + sessionId);
Map<Long, List<Registry>> byGroups = registries.stream().collect(Collectors.groupingBy(Registry::getGroupId));
for (Map.Entry<Long, List<Registry>> grpEntry : byGroups.entrySet()) {
EnumMessage groupError = null;
List<Registry> rgsGroup = grpEntry.getValue();
for (Registry rgs : rgsGroup) {
IValidator validator = validatorFactory.apply(rgs);
Optional<EnumMessage> error = validator.tillFirstError();
if (error.isPresent()) {
groupError = error.get();
break;
}
}
if (groupError != null) {
log.warn("error {} for registries groupId = {}", messageResolver.resolve(groupError), grpEntry.getKey());
for (Registry rgs : rgsGroup) {
rgs.setRegistryStatus(RegistryStatus.NACK.getKey());
registryImdg.update(rgs);
}
}
}
return new StageResult<>(null, true);
}
}

4
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RequirmentsAndObligationCreation.java → clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RequirementsAndObligationCreation.java
View file

@ -32,14 +32,14 @@ import java.util.function.BiConsumer;
import java.util.function.BiFunction;
@Service
public class RequirmentsAndObligationCreation implements ISessionStage {
public class RequirementsAndObligationCreation implements ISessionStage {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<Registry> registryImdg;
private final ImdgProvider imdgProvider;
@Autowired
public RequirmentsAndObligationCreation(ImdgProvider imdgProvider) {
public RequirementsAndObligationCreation(ImdgProvider imdgProvider) {
this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.imdgProvider = imdgProvider;
}

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

@ -3,7 +3,7 @@ package ru.spcex.platform.enumeration;
import ru.spcex.platform.utils.enumeration.IEnumKey;
public enum RegistryStatus implements IEnumKey {
OK("OK"), PROC("PROC"),
OK("OK"), PROC("PROC"), NACK("NACK"),
;
private final String key;