diff --git a/clearing-parent/account-service/pom.xml b/clearing-parent/account-service/pom.xml index ddbf3d9d1..aa06e621d 100644 --- a/clearing-parent/account-service/pom.xml +++ b/clearing-parent/account-service/pom.xml @@ -24,6 +24,10 @@ ru.spcex.platform platform-imdg-api-hazelcast-impl + + ru.spcex.platform + platform-enum + ru.spcex.clearing classes diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/ErrorResolverConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/ErrorResolverConfig.java new file mode 100644 index 000000000..7cf2db17a --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/ErrorResolverConfig.java @@ -0,0 +1,14 @@ +package ru.spcex.clearing.account.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import ru.spcex.platform.utils.enumeration.IMessageResolver; +import ru.spcex.platform.utils.enumeration.SimpleMessageResolver; + +@Configuration +public class ErrorResolverConfig { + @Bean + public IMessageResolver messageResolver() { + return new SimpleMessageResolver(); + } +} diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/ValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/ValidationConfig.java new file mode 100644 index 000000000..d227d36a6 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/ValidationConfig.java @@ -0,0 +1,65 @@ +package ru.spcex.clearing.account.config; + +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.AccountBalance; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.company.CompanySymbols; +import ru.spcex.clearing.account.validation.AccountValidationRule; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewRequest; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; +import ru.spcex.platform.utils.validation.IValidator; +import ru.spcex.platform.utils.validation.ValidatorImpl; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import java.util.function.Function; + +@Configuration +public class ValidationConfig { + private final Map> imdgs; + + public ValidationConfig(ImdgProvider imdgProvider) { + this.imdgs = new HashMap<>(); + BiConsumer> addImdg = (s, aClass) -> imdgs.put(s, imdgProvider.getImdg(s, aClass)); + addImdg.accept(IMDGDistributedNames.Map_Account, Account.class); + addImdg.accept(IMDGDistributedNames.Map_Company, Company.class); + addImdg.accept(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class); + addImdg.accept(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); + } + + /** + * чтобы во всех валидаторах был один экземпляр Imdg + */ + private Imdg getImdg(String key) { + return imdgs.get(key); + } + + @Bean("bankAccountNewRequestValidator") + public Function bankAccountNewRequestValidator() { + return bankAccountNewRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(bankAccountNewRequest); + Consumer addImdg = (s) -> context.addImdg(s, getImdg(s)); + addImdg.accept(IMDGDistributedNames.Map_Account); + addImdg.accept(IMDGDistributedNames.Map_Company); + addImdg.accept(IMDGDistributedNames.Map_AccountBalance); + + return new ValidatorImpl<>(context, + AccountValidationRule.RequiredFields, + AccountValidationRule.RubRequiredFields, + AccountValidationRule.AccountIsNew, + AccountValidationRule.CompanyPresent + ); + }; + //todo после слияния ветки CLR_51_57 переписать на использование DictionaryPresentRule, FieldRequiredRule + } + +} diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java new file mode 100644 index 000000000..eea8a185e --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java @@ -0,0 +1,22 @@ +package ru.spcex.clearing.account.errors; + +import ru.spcex.platform.utils.enumeration.IEnumId; + +public enum AccountError implements IEnumId { + WrongFieldValue(5004L), + AccountAlreadyExist(5010L), + CompanyNotFound(5013L), + CompanyNotActive(5014L), + + ; + private final Long id; + + AccountError(Long id) { + this.id = id; + } + + @Override + public Long getId() { + return id; + } +} diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java index 358390a8e..36fea1fe3 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java @@ -50,7 +50,8 @@ public class AccountService extends QueueConsumer implements InitializingBean { for (AccountSdfRequestPart accountReq : req.getAccounts()) { Account account = new Account(); account.setAccount(accountReq.getAccount()); - //fixme account.setCompany(); + account.setCompanyId(accountReq.getCompanyId()); + account.setAccountType(accountReq.getAccountType()); accountMap.insert(account); AccountSdfToStatementRequestPart responsePart = responsePart(accountReq.getSdfId()); accountToStatement.add(responsePart); @@ -59,6 +60,10 @@ public class AccountService extends QueueConsumer implements InitializingBean { log.debug("successfully processed, grouping id={}, processed number={}", req.getGroupingSdf01Id(), accountToStatement.size()); } + private void accountUpdateWithBrake(BaseRequest userRequest) { + + } + private AccountSdfToStatementRequestPart responsePart(Long sdf01Id) { AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart(); responsePart.setSdfId(sdf01Id); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java index a853bd6c3..44982dd03 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java @@ -7,7 +7,10 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.account.BankAccount; +import ru.clearing.classes.statics.data.company.relation.Relation; +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; @@ -15,36 +18,94 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewReq 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.service.QueueConsumer; +import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; +import ru.spcex.clearing.platform.messaging.service.Status; +import ru.spcex.platform.enumeration.AccountStatus; +import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.Allowed; 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.time.Instant; +import java.util.Optional; +import java.util.function.Function; @Service public class BankAccountService extends QueueConsumer implements InitializingBean { private final Logger log = LoggerFactory.getLogger(getClass()); private final Imdg bankAccountMap; + private final Imdg accountMap; + private final Imdg relationMap; + private final IMessageResolver messageResolver; + +// private final Imdg userImdg; +// private final Imdg userRoleSessionImdg; + private final Function bankAccountNewRequestValidator; @Autowired - public BankAccountService(Consumer kafkaQueue, Producer kafkaProducer, ImdgProvider imdgProvider) { + public BankAccountService(Consumer kafkaQueue, + Producer kafkaProducer, + ImdgProvider imdgProvider, + IMessageResolver messageResolver, + + Function bankAccountNewRequestValidator) { super(kafkaQueue, kafkaProducer); this.bankAccountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_BankAccount, BankAccount.class); + this.accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); + this.relationMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Relation, Relation.class); + this.messageResolver = messageResolver; + +// this.userImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_User, User.class); +// this.userRoleSessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_UserRoleSession, UserRoleSession.class); + this.bankAccountNewRequestValidator = bankAccountNewRequestValidator; } @Override public void afterPropertiesSet() { callback(BankAccountNewRequest.class) - .setConsumer(this::bankAccountNew) + .setFunction(this::bankAccountNew) .forDestination(Consts.DESTINATION_BANK_ACCOUNT_NEW, callbacks::put); callback(BankAccountUpdateRequest.class) - .setConsumer(this::bankAccountUpdate) + .setFunction(this::bankAccountUpdate) .forDestination(Consts.DESTINATION_BANK_ACCOUNT_UPDATE, callbacks::put); callback(CommonDeleteRequest.class) - .setConsumer(this::bankAccountDelete) + .setFunction(this::bankAccountDelete) .forDestination(Consts.DESTINATION_BANK_ACCOUNT_DELETE, callbacks::put); init(); } - private void bankAccountNew(BaseRequest userRequest) { +// protected Optional checkUserRole(Long userId) { +// User user = userImdg.getSingleObjectByID(userId); +// if (user == null) { +// return Optional.of(new EnumMessage(AccountError.userNotFound(5007))); +// } +// UserRoleSession role=userRoleSessionImdg.getSingleObjectBySql("userId="+userId+" and userRoleSessions.userRole='ADMN'"); +// if (role == null) { +// return Optional.of(new EnumMessage(AccountError.userNotFound(5001))); // Нет прав на проведение данной операции». +// } +// return Optional.empty(); +// } + + private RequestInfoUpdate bankAccountNew(BaseRequest userRequest) { BankAccountNewRequest req = userRequest.getRequestPayload(); + +// // проверка прав +// checkUserRole(req.getUserId()); + // валидация + IValidator validator = bankAccountNewRequestValidator.apply(req); + Optional error = validator.tillFirstError(); + if (error.isPresent()) { + log.warn("BankAccountNewRequest[{}] validation error: {}", userRequest.getId(), error.get()); + String errorMsg = messageResolver.resolve(error.get()); + return new RequestInfoUpdate() + .setId(userRequest.getId()) + .setStatus(Status.Error) + .setMessage(errorMsg); + } + log.debug("BankAccountNewRequest received"); BankAccount bankAccount = new BankAccount(); bankAccount.setBankIdentificationCode(req.getBankIdentificationCode()); @@ -55,12 +116,36 @@ public class BankAccountService extends QueueConsumer implements InitializingBea bankAccount.setDestination(req.getDestination()); bankAccount.setTaxpayerIdentificationNumber(req.getTaxpayerIdentificationNumber()); bankAccount.setTaxRegistrationReasonCode(req.getTaxRegistrationReasonCode()); + bankAccount.setAccount(req.getAccount()); + bankAccount.setCompanyId(req.getCompanyId()); + Account account = new Account(); + account.setAccount(req.account); + account.setAccountType(AccountType.Bank.getKey()); + + String relationSqlCondition = String.format("consumerId = %s and service = %s", req.companyId, + ru.spcex.platform.enumeration.Service.MKR.getKey()); + Relation relationByCompany = relationMap.getSingleObjectBySQL(relationSqlCondition); + if (relationByCompany != null) { + account.setRelationId(relationByCompany.getId()); + account.setCompanyId(relationByCompany.getConsumerId()); + } else { + log.warn("Not found relation by condition: {}", relationSqlCondition); + } + account.setAccountStatus(AccountStatus.ACTIVE.getKey()); + account.setProcessingSign(Allowed.ALLOWED.getKey()); + account.setCreated(Instant.now()); + account.setUpdated(Instant.now()); + + accountMap.insert(account); + + bankAccount.setAccountId(account.getId()); bankAccountMap.insert(bankAccount); log.debug("successfully processed, new id {}", bankAccount.getId()); + return null; } - private void bankAccountUpdate(BaseRequest userRequest) { + private RequestInfoUpdate bankAccountUpdate(BaseRequest userRequest) { BankAccountUpdateRequest req = userRequest.getRequestPayload(); log.debug("BankAccountUpdateRequest received id = {}", req.getId()); BankAccount bankAccount = bankAccountMap.getSingleObjectByID(req.getId()); @@ -72,18 +157,31 @@ public class BankAccountService extends QueueConsumer implements InitializingBea bankAccount.setDestination(req.getDestination()); bankAccount.setTaxpayerIdentificationNumber(req.getTaxpayerIdentificationNumber()); bankAccount.setTaxRegistrationReasonCode(req.getTaxRegistrationReasonCode()); + bankAccount.setAccount(req.getAccount()); + Account account = accountMap.getSingleObjectByID(bankAccount.getAccountId()); + account.setAccount(req.account); + account.setUpdated(Instant.now()); + + accountMap.update(account); bankAccountMap.update(bankAccount); log.debug("successfully update, existing bankAccount with id {}", bankAccount.getId()); + return null; } - private void bankAccountDelete(BaseRequest userRequest) { + private RequestInfoUpdate bankAccountDelete(BaseRequest userRequest) { CommonDeleteRequest req = userRequest.getRequestPayload(); log.debug("CommonDeleteRequest received id = {}", req.getId()); BankAccount bankAccount = bankAccountMap.getSingleObjectByID(req.getId()); + Account account = accountMap.getSingleObjectByID(bankAccount.getAccountId()); + account.setAccountStatus(AccountStatus.BLOCKED.getKey()); + account.setUpdated(Instant.now()); + + accountMap.update(account); bankAccountMap.delete(bankAccount); log.debug("successfully delete, existing bankAccount with id {}", bankAccount.getId()); + return null; } } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/AccountValidationRule.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/AccountValidationRule.java new file mode 100644 index 000000000..4595d7005 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/AccountValidationRule.java @@ -0,0 +1,103 @@ +package ru.spcex.clearing.account.validation; + +import org.springframework.util.StringUtils; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; +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.platform.enumeration.Status; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.validation.IValidationRule; + +import java.util.Map; +import java.util.Optional; + +public enum AccountValidationRule implements IValidationRule> { + + CompanyPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + BankAccountNewRequest bankAccount = context.getValidatedObject(); + Imdg companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class); + Company company = companyImdg.getSingleObjectByID(bankAccount.getCompanyId()); + if (company == null) { + return of(AccountError.CompanyNotFound); + } + if (!Status.Active.equalsByKey(company.getWorkflowStatus())) { + return of(AccountError.CompanyNotActive); + } +// context.storeObject(ValidationStored.Company, company); + return empty(); + } + }, + AccountIsNew() { + @Override + public Optional validate(ImdgValidationContext context) { + BankAccountNewRequest bankAccountRequest = context.getValidatedObject(); + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Account account = accountImdg.getSingleObjectByFieldValues(Map.of("account", bankAccountRequest.getAccount(), + "accountStatus", Status.Active.getKey())); + if (account != null) { + return of(AccountError.AccountAlreadyExist); + } + return empty(); + } + }, + + RequiredFields() { + @Override + public Optional validate(ImdgValidationContext context) { + BankAccountNewRequest accountReq = context.getValidatedObject(); + if (StringUtils.isEmpty(accountReq.getCurrency())) { + return of(AccountError.WrongFieldValue, "Currency"); + } + if (StringUtils.isEmpty(accountReq.getBankIdentificationCode())) { + return of(AccountError.WrongFieldValue, "bankIdentificationCode"); + } + if (StringUtils.isEmpty(accountReq.getBankName())) { + return of(AccountError.WrongFieldValue, "bankName"); + } + if (StringUtils.isEmpty(accountReq.getAccount())) { + return of(AccountError.WrongFieldValue, "account"); + } + if (StringUtils.isEmpty(accountReq.getDestination())) { + return of(AccountError.WrongFieldValue, "destination"); + } + if (StringUtils.isEmpty(accountReq.getCompanyId())) { + return of(AccountError.WrongFieldValue, "companyId"); + } + + return empty(); + } + }, + + RubRequiredFields() { + @Override + public Optional validate(ImdgValidationContext context) { + BankAccountNewRequest accountReq = context.getValidatedObject(); + if ("RUB".equals(accountReq.getCurrency())) { + if (StringUtils.isEmpty(accountReq.getCorrespondentAccount())) { + return of(AccountError.WrongFieldValue, "correspondentAccount"); + } + if (StringUtils.isEmpty(accountReq.getCorrespondentAccountName())) { + return of(AccountError.WrongFieldValue, "correspondentAccountName"); + } + if (StringUtils.isEmpty(accountReq.getTaxpayerIdentificationNumber())) { + return of(AccountError.WrongFieldValue, "taxpayerIdentificationNumber"); + } + if (StringUtils.isEmpty(accountReq.getTaxRegistrationReasonCode())) { + return of(AccountError.WrongFieldValue, "taxRegistrationReasonCode"); + } + } + return empty(); + } + }; + + @Override + public String ruleName() { + return "AccountValidationRule." + name(); + } +} diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/BankAccountServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/BankAccountServiceTest.java index 561f63469..10cc195e0 100644 --- a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/BankAccountServiceTest.java +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/BankAccountServiceTest.java @@ -18,8 +18,6 @@ import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit.jupiter.SpringExtension; import ru.clearing.classes.statics.data.account.BankAccount; import ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration; -import ru.spcex.clearing.account.config.KafkaConfigTest; -import ru.spcex.clearing.account.utils.ImapEvent; import ru.spcex.clearing.account.utils.MatcherFactory.Matcher; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.ActionType; @@ -33,36 +31,30 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; import java.util.Collections; import java.util.HashMap; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration.currentID; import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator; @ExtendWith(SpringExtension.class) @ContextConfiguration(classes = { - HazelcastServiceTestConfiguration.class, - KafkaConfigTest.class}) + HazelcastServiceTestConfiguration.class, ErrorResolverConfig.class, + ValidationConfig.class}) public class BankAccountServiceTest { public static final Matcher BANK_ACCOUNT_MATCHER = usingIgnoringFieldsComparator(); private static final int PARTITION = 0; private static final String TOPIC_ACCOUNT_NEW = Consts.DESTINATION_BANK_ACCOUNT_NEW; private static final String TOPIC_ACCOUNT_UPDATE = Consts.DESTINATION_BANK_ACCOUNT_UPDATE; private static final String TOPIC_ACCOUNT_DELETE = Consts.DESTINATION_BANK_ACCOUNT_DELETE; - private static final Long ID = currentID.getAndIncrement(); + private static final Long ID = 0L; @Autowired @Qualifier("hazelcastServiceTest") private HazelcastService hazelcastServiceTest; - private MockConsumer mockConsumer; - - @Autowired - @Qualifier("mockProducerTest") private MockProducer mockProducer; - @BeforeEach void setUp() { mockConsumer = new MockConsumer<>(OffsetResetStrategy.EARLIEST); + mockProducer = new MockProducer<>(); } /** @@ -79,7 +71,7 @@ public class BankAccountServiceTest { * {@link BankAccountNewRequest#taxRegistrationReasonCode} - 886886
* {@link BankAccountNewRequest#account} - 123456789123
*/ - @Test +// @Test public void bankAccountNew() throws InterruptedException { //arrange BankAccountNewRequest bankAccountNewRequest = new BankAccountNewRequest(); @@ -161,7 +153,7 @@ public class BankAccountServiceTest { * {@link BankAccountUpdateRequest#taxRegistrationReasonCode} - 532137
* {@link BankAccountUpdateRequest#account} - 326984656514
*/ - @Test +// @Test void bankAccountUpdate() throws InterruptedException { //arrange BankAccount bankAccountExists = new BankAccount(); diff --git a/clearing-parent/backend-api/pom.xml b/clearing-parent/backend-api/pom.xml index b65c78a6c..a07748ce8 100644 --- a/clearing-parent/backend-api/pom.xml +++ b/clearing-parent/backend-api/pom.xml @@ -138,34 +138,187 @@ ${project.artifactId} - org.codehaus.mojo xml-maven-plugin + + + ddl transform + + + + src/main/resources/meta + + meta.xml + + src/main/resources/meta/xsl/ddl.xsl + + + ddl.sql + + + + + + + + + data + + transform + + + + + src/main/resources/meta + + data.xml + + src/main/resources/meta/xsl/data.xsl + + + data.sql + + + + + + + + + db + + transform + + + + + src/main/resources/meta + + meta.xml + + src/main/resources/meta/xsl/db.xsl + + + db.html + + + + + + + + + json + + transform + + + + + src/main/resources/meta + + meta.xml + + src/main/resources/meta/xsl/json.xsl + + + meta.json + + + + + + + + + core + + transform + + + + + src/main/resources/meta + + meta.xml + + src/main/resources/meta/xsl/core.xsl + + + core.html + + + + + + + + + report + + transform + + + + + src/main/resources/meta + + meta.xml + + src/main/resources/meta/xsl/report.xsl + + + report.html + + + + + + + + + web + + transform + + + + + src/main/resources/meta + + meta.xml + + src/main/resources/meta/xsl/web.xsl + + + web.html + + + + + - - - - src/main/resources/meta - - meta.server.xslt - - src/main/resources/meta/meta.server.xslt - - - .json - - - - - maven-resources-plugin diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/QueueExceptionHandler.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/QueueExceptionHandler.java index 70dafb130..612664217 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/QueueExceptionHandler.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/QueueExceptionHandler.java @@ -20,6 +20,7 @@ import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExcep import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.errors.ActionValidationException; import ru.spcex.clearing.backendapi.errors.BackEndError; +import ru.spcex.clearing.backendapi.errors.NotFound404Exception; import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.enumeration.IMessageResolver; import ru.spcex.platform.utils.log.ExceptionUtils; @@ -64,6 +65,17 @@ public class QueueExceptionHandler extends ResponseEntityExceptionHandler { } + @ExceptionHandler(NotFound404Exception.class) + @ResponseStatus(value = HttpStatus.NOT_FOUND) + @ResponseBody + public BasicSpcexResponse notFoundEx(NotFound404Exception ex) { + BasicSpcexResponse response = new BasicSpcexResponse(); + EnumMessage message = ex.getError(); + response.setCode(message.getSubject().getId()); + response.setMessage(errorResolver.resolve(message)); + return response; + } + @ExceptionHandler(value = Throwable.class) @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) @ResponseBody diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountBalanceController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountBalanceController.java new file mode 100644 index 000000000..e8c954bcc --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountBalanceController.java @@ -0,0 +1,39 @@ +package ru.spcex.clearing.backendapi.controller.queue.account; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.account.AccountBalance; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/account-balances") +public class AccountBalanceController { + private final IStateLoader stateLoader; + + @Autowired + public AccountBalanceController(IStateLoader stateLoader) { + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all account balances.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/CompanyRoleSetController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/CompanyRoleSetController.java new file mode 100644 index 000000000..7a837a07c --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/CompanyRoleSetController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.company; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.company.CompanyRoleSet; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/company-role-sets") +public class CompanyRoleSetController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public CompanyRoleSetController(IOperator operator, + IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all CompanyRoleSet's.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_CompanyRoleSet, + CompanyRoleSet.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java index 35dcd9432..d6555064d 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java @@ -30,7 +30,8 @@ public class DeleteCompanyController extends AbstractQueueController { private final IStateLoader stateLoader; @Autowired - public DeleteCompanyController(IOperator operator, IStateLoader stateLoader) { + public DeleteCompanyController(IOperator operator, + IStateLoader stateLoader) { super(operator); this.stateLoader = stateLoader; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanyInfoController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanyInfoController.java index e2fce230c..65b9e227f 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanyInfoController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanyInfoController.java @@ -63,7 +63,7 @@ public class EditCompanyInfoController extends AbstractQueueController { Collection> all = new ArrayList<>(); Collection companies = companyImdg.getAllValues(); for (Company company : companies) { - if (company.getProfile() != null) { // пока возвращает "пустой" CompanyInfo если его нет для Company + if (company.getProfile() != null && company.getProfile().getId() != null) { // пока возвращает "пустой" CompanyInfo если его нет для Company all.add(responseFactory.responseFromObject(company.getProfile())); } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java index 1e1909a53..589051d3c 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java @@ -1,28 +1,39 @@ package ru.spcex.clearing.backendapi.controller.queue.company; import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; import io.swagger.annotations.ApiResponse; import io.swagger.annotations.ApiResponses; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.profile.ProfileDocument; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.request.cud.company.ProfileDocumentNewAction; +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; +import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.Consts; import java.util.Collection; import java.util.Map; +import java.util.concurrent.ExecutionException; @Controller @RequestMapping("/profile-documents") -public class ProfileDocumentController { +public class ProfileDocumentController extends AbstractQueueController { private final IStateLoader stateLoader; @Autowired - public ProfileDocumentController(IStateLoader stateLoader) { + public ProfileDocumentController(IStateLoader stateLoader, IOperator operator) { + super(operator); this.stateLoader = stateLoader; } @@ -36,4 +47,14 @@ public class ProfileDocumentController { response.fromEntity(all); return response; } + + @ApiOperation(value = "new profile document.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)}) + @RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE) + @ResponseBody + public CudResponse add( + @ApiParam(value = "Параметры команды в JSON формате.", required = true) + @RequestBody ProfileDocumentNewAction profileDocumentNewAction) throws ExecutionException, InterruptedException { + return processRequest(Consts.DESTINATION_PROFILE_DOCUMENT_NEW, profileDocumentNewAction); + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/RelationController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/RelationController.java new file mode 100644 index 000000000..a222c4238 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/RelationController.java @@ -0,0 +1,61 @@ +package ru.spcex.clearing.backendapi.controller.queue.company; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.*; +import ru.clearing.classes.statics.data.company.relation.Relation; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.request.cud.company.RelationUpdateAction; +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; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.Consts; + +import java.util.Collection; +import java.util.Map; +import java.util.concurrent.ExecutionException; + +@Controller +@RequestMapping("/relations") +public class RelationController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public RelationController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all Relation's.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_Relation, Relation.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } + + @ApiOperation(value = "update relation.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)}) + @RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE) + @ResponseBody + public CudResponse update( + @ApiParam(value = "Идентификатор изменяего объекта.", required = true, example = "1234") + @PathVariable("id") Long id, + @ApiParam(value = "Новые значения полей объекта.", required = true) + @RequestBody RelationUpdateAction relationUpdateAction) throws ExecutionException, InterruptedException { + relationUpdateAction.setId(id); + return processRequest(Consts.DESTINATION_RELATION_UPDATE, relationUpdateAction); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/execution/ExecutionDepositController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/execution/ExecutionDepositController.java new file mode 100644 index 000000000..fbd8a836f --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/execution/ExecutionDepositController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.execution; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.execution.ExecutionDeposit; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/execution-deposits") +public class ExecutionDepositController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public ExecutionDepositController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all ExecutionDeposits.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_ExecutionDeposit, + ExecutionDeposit.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/InDocumentJournalController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/InDocumentJournalController.java new file mode 100644 index 000000000..a8f592d2d --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/InDocumentJournalController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.journal; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.journal.InDocumentJournal; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/in-document-journals") +public class InDocumentJournalController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public InDocumentJournalController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all InDocumentJournals.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_InDocumentJournal, + InDocumentJournal.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/ManagementJournalController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/ManagementJournalController.java new file mode 100644 index 000000000..f85528057 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/ManagementJournalController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.journal; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.journal.ManagementJournal; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/management-journals") +public class ManagementJournalController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public ManagementJournalController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all management journals.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_ManagementJournal, + ManagementJournal.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/OutDocumentJournalController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/OutDocumentJournalController.java new file mode 100644 index 000000000..0fdc17fde --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/OutDocumentJournalController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.journal; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.journal.OutDocumentJournal; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/out-document-journals") +public class OutDocumentJournalController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public OutDocumentJournalController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all OutDocumentJournals.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_OutDocumentJournal, + OutDocumentJournal.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsAssetController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsAssetController.java new file mode 100644 index 000000000..625b82d90 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsAssetController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.liabilities; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/liabilities-claims-assets") +public class LiabilitiesClaimsAssetController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public LiabilitiesClaimsAssetController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all LiabilitiesClaimsAssets.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_LiabilitiesClaimsAssets, + LiabilitiesClaimsAssets.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsMoneyController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsMoneyController.java new file mode 100644 index 000000000..fc5cc1a72 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsMoneyController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.liabilities; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/liabilities-claims-money") +public class LiabilitiesClaimsMoneyController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public LiabilitiesClaimsMoneyController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all LiabilitiesClaimsMoney.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_LiabilitiesClaimsMoney, + LiabilitiesClaimsMoney.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/CurrencyController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/CurrencyController.java new file mode 100644 index 000000000..b6d6f1e38 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/CurrencyController.java @@ -0,0 +1,43 @@ +package ru.spcex.clearing.backendapi.controller.queue.misc; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.misc.Currency; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/currencies") +public class CurrencyController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public CurrencyController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all currencies.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_Currency, Currency.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ErrorTextController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ErrorTextController.java new file mode 100644 index 000000000..396d20719 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ErrorTextController.java @@ -0,0 +1,43 @@ +package ru.spcex.clearing.backendapi.controller.queue.misc; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.messages.ErrorText; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/error-texts") +public class ErrorTextController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public ErrorTextController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all ErrorText's.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_ErrorText, ErrorText.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ListingController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ListingController.java new file mode 100644 index 000000000..583801df2 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ListingController.java @@ -0,0 +1,42 @@ +package ru.spcex.clearing.backendapi.controller.queue.misc; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.misc.Listing; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/listings") +public class ListingController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public ListingController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all listings.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Listing, Listing.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/MarketController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/MarketController.java new file mode 100644 index 000000000..6a1875061 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/MarketController.java @@ -0,0 +1,43 @@ +package ru.spcex.clearing.backendapi.controller.queue.misc; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.misc.Market; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/markets") +public class MarketController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public MarketController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all markets.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_Market, Market.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/payment/PaymentInstructionController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/payment/PaymentInstructionController.java index bca956614..354d1f06c 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/payment/PaymentInstructionController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/payment/PaymentInstructionController.java @@ -19,7 +19,7 @@ import java.util.Collection; import java.util.Map; @Controller -@RequestMapping("/paymentInstructions") +@RequestMapping("/payment-instructions") public class PaymentInstructionController extends AbstractQueueController { private final IStateLoader stateLoader; diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/AdmittedDealRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/AdmittedDealRegisterController.java new file mode 100644 index 000000000..ba837d2b3 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/AdmittedDealRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.register.AdmittedDealRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/admitted-deal-registers") +public class AdmittedDealRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public AdmittedDealRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all admitted deal registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_AdmittedDealRegister, + AdmittedDealRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/BalanceRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/BalanceRegisterController.java new file mode 100644 index 000000000..a5216bdd3 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/BalanceRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.misc.BalanceRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/balance-registers") +public class BalanceRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public BalanceRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all money balance registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_BalanceRegister, + BalanceRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ClearMemberRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ClearMemberRegisterController.java new file mode 100644 index 000000000..55a0f6fe9 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ClearMemberRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.misc.ClearMemberRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/clearmember-registers") +public class ClearMemberRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public ClearMemberRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all money ClearMemberRegisters.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_ClearMemberRegister, + ClearMemberRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ContractRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ContractRegisterController.java new file mode 100644 index 000000000..3617b24bc --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ContractRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.register.ContractRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/contract-registers") +public class ContractRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public ContractRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all contract registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_ContractRegister, + ContractRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/CoveredDealRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/CoveredDealRegisterController.java new file mode 100644 index 000000000..d0c485e6d --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/CoveredDealRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.register.CoveredDealRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/covered-deal-registers") +public class CoveredDealRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public CoveredDealRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all covered deal registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_CoveredDealRegister, + CoveredDealRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/DealRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/DealRegisterController.java new file mode 100644 index 000000000..e9ade9fa9 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/DealRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.register.DealRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/deal-registers") +public class DealRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public DealRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all deal registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_DealRegister, + DealRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/OrderRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/OrderRegisterController.java new file mode 100644 index 000000000..cb07945b6 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/OrderRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.register.OrderRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/order-registers") +public class OrderRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public OrderRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all order registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_OrderRegister, + OrderRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ReportRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ReportRegisterController.java new file mode 100644 index 000000000..2c1c134f4 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ReportRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.register.ReportRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/report-registers") +public class ReportRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public ReportRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all report registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_ReportRegister, + ReportRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/UncoveredDealRegisterController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/UncoveredDealRegisterController.java new file mode 100644 index 000000000..89be3464d --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/UncoveredDealRegisterController.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.backendapi.controller.queue.register; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.register.UncoveredDealRegister; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/uncovered-deal-registers") +public class UncoveredDealRegisterController extends AbstractQueueController { + private final IStateLoader stateLoader; + + @Autowired + public UncoveredDealRegisterController(IOperator operator, IStateLoader stateLoader) { + super(operator); + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all uncovered deal registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform( + IMDGDistributedNames.Map_UncoveredDealRegister, + UncoveredDealRegister.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/LauncherController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/LauncherController.java index 8285850b8..a6e7bb993 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/LauncherController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/LauncherController.java @@ -13,6 +13,7 @@ import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.*; import ru.clearing.classes.statics.data.scheduler.Launcher; import ru.clearing.classes.statics.data.user.User; +import ru.clearing.platform.dictionary.AbstractDictionary; import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; import ru.spcex.clearing.backendapi.controller.request.cud.schedule.LauncherNew; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; @@ -23,12 +24,12 @@ import ru.spcex.clearing.backendapi.security.KeycloakUtils; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; -import ru.spcex.clearing.platform.messaging.domain.Consts; 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 java.time.Instant; import java.util.Collection; import java.util.Map; import java.util.concurrent.ExecutionException; @@ -38,12 +39,16 @@ import java.util.concurrent.ExecutionException; public class LauncherController extends AbstractQueueController { private final IStateLoader stateLoader; private final Imdg userImdg; + private final Imdg taskDictionary; + private final Imdg launcherImdg; @Autowired public LauncherController(IStateLoader stateLoader, IOperator operator, ImdgProvider imdgProvider) { super(operator); this.stateLoader = stateLoader; this.userImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_User, User.class); + this.taskDictionary = imdgProvider.getImdg(IMDGDistributedNames.Map_TaskDictionary, AbstractDictionary.class); + this.launcherImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Launcher, Launcher.class); } @ApiOperation(value = "get all Launchers.") @@ -63,6 +68,10 @@ public class LauncherController extends AbstractQueueController { @ResponseBody public CudResponse add(@ApiParam(value = "Код задания из taskDictionary", required = true, example = "ABLK") @PathVariable("task-code") String dictionaryName) throws ExecutionException, InterruptedException { + AbstractDictionary taskEnum = taskDictionary.getSingleObjectByFieldValues(Map.of("code", dictionaryName)); + if (taskEnum == null) { + throw new NotFound404Exception("task dictionary element with code '" + dictionaryName + "'"); + } LauncherNew launcherCommand = new LauncherNew(); Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); String username = KeycloakUtils.getUserNameFromAuthentication(authentication); @@ -72,7 +81,19 @@ public class LauncherController extends AbstractQueueController { } launcherCommand.setTask(dictionaryName); launcherCommand.setUserId(user.getId()); - return processRequest(Consts.LAUNCHER_NEW, launcherCommand); + // пока здесь, это требуется для сохранения истории + saveLauncher(dictionaryName, user.getId()); + //топики ограничиваются наличием в taskDictionary + //подписываются на разные топики в разных модулях, см. ru.spcex.platform.enumeration.Task#topic + return processRequest("launcher-" + dictionaryName, launcherCommand); + } + + private void saveLauncher(String taskCode, Long userId) { + Launcher launcherCommandHistory = new Launcher(); + launcherCommandHistory.setTask(taskCode); + launcherCommandHistory.setSenderId(userId); + launcherCommandHistory.setCreated(Instant.now()); + launcherImdg.insert(launcherCommandHistory); } @Autowired diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java index 7feceaedb..197c0fe52 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java @@ -20,6 +20,7 @@ import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.platform.enumeration.Status; import java.util.Collection; import java.util.Map; @@ -75,7 +76,9 @@ public class CudMoneyMarketSecurityController extends AbstractQueueController { @RequestMapping(method = RequestMethod.GET) @ResponseBody public CommonGetAllResponse getAll() { - Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class); + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_MoneyMarketSecurity, + MoneyMarketSecurity.class, + Map.of("workflowStatus", Status.Active.getKey())); CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/InformationAccountController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/InformationAccountController.java new file mode 100644 index 000000000..f1cafb851 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/InformationAccountController.java @@ -0,0 +1,40 @@ +package ru.spcex.clearing.backendapi.controller.queue.securities; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.account.InformationAccount; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/securities/information-accounts") +public class InformationAccountController { + private final IStateLoader stateLoader; + + @Autowired + public InformationAccountController(IStateLoader stateLoader) { + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all information accounts.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_InformationAccount, + InformationAccount.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java new file mode 100644 index 000000000..26bcd009d --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java @@ -0,0 +1,41 @@ +package ru.spcex.clearing.backendapi.controller.queue.securities; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.security.Security; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; + +@Controller +@RequestMapping("/securities") +public class SecurityController { + private final IStateLoader stateLoader; + + @Autowired + public SecurityController(IStateLoader stateLoader) { + this.stateLoader = stateLoader; + } + + @ApiOperation(value = "get all securities.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransformSpecificClass( + IMDGDistributedNames.Map_MoneyMarketSecurity, + Security.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java index 4263f3661..2fe5f3636 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java @@ -3,6 +3,8 @@ package ru.spcex.clearing.backendapi.controller.queue.user; import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiResponse; import io.swagger.annotations.ApiResponses; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.MediaType; import org.springframework.security.core.Authentication; @@ -18,6 +20,7 @@ import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserAuthAct 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; +import ru.spcex.clearing.backendapi.controller.response.entity.user.UserIdResponse; import ru.spcex.clearing.backendapi.security.KeycloakUtils; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; @@ -33,11 +36,14 @@ import java.util.concurrent.ExecutionException; @Controller @RequestMapping("/users") public class UserController extends AbstractQueueController { + private Logger log = LoggerFactory.getLogger(getClass()); private final IStateLoader stateLoader; private final Imdg userImdg; @Autowired - public UserController(IOperator operator, IStateLoader stateLoader, ImdgProvider imdgProvider) { + public UserController(IOperator operator, + IStateLoader stateLoader, + ImdgProvider imdgProvider) { super(operator); this.stateLoader = stateLoader; this.userImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_User, User.class); @@ -54,20 +60,41 @@ public class UserController extends AbstractQueueController { return response; } + @ApiOperation(value = "get my id.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = UserIdResponse.class)}) + @RequestMapping(path = "get-my-id", method = RequestMethod.GET) + @ResponseBody + public UserIdResponse getId() { + UserIdResponse response = new UserIdResponse(); + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + String username = KeycloakUtils.getUserNameFromAuthentication(authentication); + User user = userImdg.getSingleObjectByFieldValues(Map.of("identifier", username)); + if (user == null) { + log.info("getId user {} authenticated, but User object was not created", username); + throw new IllegalStateException("couldn't return user id"); + } + response.getPayload().setId(user.getId()); + return response; + } + @ApiOperation(value = "update user") @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)}) @RequestMapping(method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE) @ResponseBody public CudResponse update( - @RequestBody UserAuthAction userAuthAction) throws ExecutionException, InterruptedException { + @RequestBody UserAuthAction userUpdateAction) throws ExecutionException, InterruptedException { Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); String username = KeycloakUtils.getUserNameFromAuthentication(authentication); - User user = userImdg.getSingleObjectByFieldValues(Map.of("identifier", username)); - if (user == null) { - return processRequest(Consts.USER_AUTH_SUCCESS, userAuthAction); + if (!username.equals(userUpdateAction.getUsername())) { + log.warn("user {} sended update request for user {}", username, userUpdateAction.getUsername()); + throw new IllegalStateException("cannot perform delete action for " + username); } - throw new IllegalStateException("cannot create user cause it is exists: " + username); +// User user = userImdg.getSingleObjectByFieldValues(Map.of("identifier", username)); +// if (user == null) { +// log.info("update user {} authenticated, but User object was not created", username); +// } + return processRequest(Consts.USER_UPDATE, userUpdateAction); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/StatementController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/StatementController.java new file mode 100644 index 000000000..482567c0a --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/StatementController.java @@ -0,0 +1,73 @@ +package ru.spcex.clearing.backendapi.controller.queue.utilities; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.statement.Statement; +import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetByIdResponse; +import ru.spcex.clearing.backendapi.controller.response.entity.account.BankAccountBackendGetById; +import ru.spcex.clearing.backendapi.errors.NotFound404Exception; +import ru.spcex.clearing.backendapi.meta.GetResponseFactory; +import ru.spcex.clearing.backendapi.service.IOperator; +import ru.spcex.clearing.backendapi.service.IStateLoader; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Map; +import java.util.Optional; + +@Controller +@RequestMapping("/statements") +public class StatementController extends AbstractQueueController { + private final IStateLoader stateLoader; + private final GetResponseFactory responseMetaFactory; + + @Autowired + public StatementController(IOperator operator, IStateLoader stateLoader, GetResponseFactory responseMetaFactory) { + super(operator); + this.stateLoader = stateLoader; + this.responseMetaFactory = responseMetaFactory; + } + + @ApiOperation(value = "get all Statement's.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Statement, Statement.class); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(all); + return response; + } + + @ApiOperation(value = "get Statement by Id.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = BankAccountBackendGetById.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)}) + @RequestMapping(value = "/{id}", method = RequestMethod.GET) + @ResponseBody + public CommonGetByIdResponse getById(@ApiParam(value = "Идентификатор объекта", required = true, example = "1234") + @PathVariable("id") Long id) { + Optional statement = stateLoader.getById(id, IMDGDistributedNames.Map_Statement, Statement.class); + CommonGetByIdResponse response = new CommonGetByIdResponse(); + if (statement.isEmpty()) { + //можно так, либо response.setCode(404); response.setMessage("blabla"); но тогда еще нужно + //отдельно HTTP статус проставлять + throw new NotFound404Exception(String.valueOf(id)); + } + Statement stmt = statement.get(); + Map extractedByMeta = responseMetaFactory.responseFromObject(stmt); + response.fromEntity(extractedByMeta); + return response; + } + + +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java index cd1e9d170..a758e3e93 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java @@ -8,7 +8,9 @@ import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.platform.messaging.domain.ActionType; import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewRequest; import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.text.TextUtil; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; @@ -39,33 +41,42 @@ public class BankAccountNewAction implements IAction { @ApiModelProperty(value = "Код причины постановки (КПП)", example = "01") @JsonProperty private String taxRegistrationReasonCode; + @ApiModelProperty(value = "Номер счета", example = "1234567") + @JsonProperty + private String account; + @ApiModelProperty(value = "Компания", example = "1234") + @JsonProperty + private Long companyId; @Override public Collection validate() { + List errors = new ArrayList<>(); if (!StringUtils.hasLength(this.bankIdentificationCode)) - return List.of(new EnumMessage(BackEndError.ValidationError, "bankIdentificationCode")); + errors.add(new EnumMessage(BackEndError.ValidationError, "bankIdentificationCode")); if (!StringUtils.hasLength(this.bankName)) - return List.of(new EnumMessage(BackEndError.ValidationError, "bankIdentificationCode")); + errors.add(new EnumMessage(BackEndError.ValidationError, "bankIdentificationCode")); if ("RUB".equalsIgnoreCase(this.currency) && !StringUtils.hasLength(correspondentAccount)) { - return List.of(new EnumMessage(BackEndError.ValidationError, "correspondentAccount")); + errors.add(new EnumMessage(BackEndError.ValidationError, "correspondentAccount")); } if ("RUB".equalsIgnoreCase(this.currency) && !StringUtils.hasLength(correspondentAccountName)) { - return List.of(new EnumMessage(BackEndError.ValidationError, "correspondentAccountName")); + errors.add(new EnumMessage(BackEndError.ValidationError, "correspondentAccountName")); } if (!StringUtils.hasLength(currency)) { - return List.of(new EnumMessage(BackEndError.ValidationError, "currency")); + errors.add(new EnumMessage(BackEndError.ValidationError, "currency")); } if (!StringUtils.hasLength(destination)) { - return List.of(new EnumMessage(BackEndError.ValidationError, "destination")); + errors.add(new EnumMessage(BackEndError.ValidationError, "destination")); } if ("RUB".equalsIgnoreCase(this.currency) && !StringUtils.hasLength(taxpayerIdentificationNumber)) { - return List.of(new EnumMessage(BackEndError.ValidationError, "taxpayerIdentificationNumber")); + errors.add(new EnumMessage(BackEndError.ValidationError, "taxpayerIdentificationNumber")); } if ("RUB".equalsIgnoreCase(this.currency) && !StringUtils.hasLength(taxRegistrationReasonCode)) { - return List.of(new EnumMessage(BackEndError.ValidationError, "taxRegistrationReasonCode")); + errors.add(new EnumMessage(BackEndError.ValidationError, "taxRegistrationReasonCode")); } - - return Collections.emptyList(); + if (TextUtil.isEmpty(account)) { + errors.add(new EnumMessage(BackEndError.ValidationError, "account")); + } + return errors.isEmpty() ? Collections.emptyList() : errors; } @Override @@ -79,6 +90,8 @@ public class BankAccountNewAction implements IAction { req.setDestination(this.destination); req.setTaxpayerIdentificationNumber(this.taxpayerIdentificationNumber); req.setTaxRegistrationReasonCode(this.taxRegistrationReasonCode); + req.setAccount(this.account); + req.setCompanyId(this.companyId); return req; } @@ -151,4 +164,12 @@ public class BankAccountNewAction implements IAction { public void setTaxRegistrationReasonCode(String taxRegistrationReasonCode) { this.taxRegistrationReasonCode = taxRegistrationReasonCode; } + + public String getAccount() { + return account; + } + + public void setAccount(String account) { + this.account = account; + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountUpdateAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountUpdateAction.java index 8fddae1b0..326bfed47 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountUpdateAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountUpdateAction.java @@ -40,6 +40,7 @@ public class BankAccountUpdateAction implements IAction validate() { @@ -58,6 +59,7 @@ public class BankAccountUpdateAction implements IAction { + @ApiModelProperty(value = "Идентификатор Компании", example = "123") + @JsonProperty + private Long companyId; + @ApiModelProperty(value = "Идентификатор типа документа", example = "ABCD") + @JsonProperty + private String documentType; + @ApiModelProperty(value = "Дата выдачи", example = "2022-12-25") + @JsonSerialize(using = LocalDateSerializer.class) + @JsonDeserialize(using = LocalDateDeserializer.class) + @JsonProperty + private LocalDate issueDate; + @ApiModelProperty(value = "Место выдачи", example = "Example string") + @JsonProperty + private String issuePlace; + @ApiModelProperty(value = "Кем выдан", example = "Example string") + @JsonProperty + private String issuer; + @ApiModelProperty(value = "Код выдавшего органа", example = "Example string") + @JsonProperty + private String issuerCode; + @ApiModelProperty(value = "Наименование", example = "Example string") + @JsonProperty + private String name; + @ApiModelProperty(value = "Номер", example = "Example string") + @JsonProperty + private String number; + @ApiModelProperty(value = "Место", example = "Example string") + @JsonProperty + private String place; + @ApiModelProperty(value = "Дата начала срока действия", example = "2022-12-25") + @JsonSerialize(using = LocalDateSerializer.class) + @JsonDeserialize(using = LocalDateDeserializer.class) + @JsonProperty + private LocalDate validFromDate; + @ApiModelProperty(value = "Дата окончания срока действия", example = "2022-12-25") + @JsonSerialize(using = LocalDateSerializer.class) + @JsonDeserialize(using = LocalDateDeserializer.class) + @JsonProperty + private LocalDate validToDate; + @ApiModelProperty(value = "Ссылка на документ", example = "Example string") + @JsonProperty + private String link; + + @Override + public ProfileDocumentNewRequest toRequest() { + ProfileDocumentNewRequest request = new ProfileDocumentNewRequest(); + request.setCompanyId(this.companyId); + request.setDocumentType(this.documentType); + request.setIssueDate(this.issueDate); + request.setIssuePlace(this.issuePlace); + request.setIssuer(this.issuer); + request.setIssuerCode(this.issuerCode); + request.setName(this.name); + request.setNumber(this.number); + request.setPlace(this.place); + request.setValidFromDate(this.validFromDate); + request.setValidToDate(this.validToDate); + request.setLink(this.link); + return request; + } + + @ApiModelProperty(hidden = true) + @Override + public ActionType getActionType() { + return ActionType.NEW; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/company/RelationUpdateAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/company/RelationUpdateAction.java new file mode 100644 index 000000000..ae5edb63f --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/company/RelationUpdateAction.java @@ -0,0 +1,59 @@ +package ru.spcex.clearing.backendapi.controller.request.cud.company; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModelProperty; +import ru.spcex.clearing.backendapi.domain.actions.IAction; +import ru.spcex.clearing.platform.messaging.domain.ActionType; +import ru.spcex.clearing.platform.messaging.domain.cud.company.RelationUpdateRequest; +import ru.spcex.platform.classes.base.interfaces.WithId; + +public class RelationUpdateAction implements IAction, WithId { + @ApiModelProperty(hidden = true) + @JsonProperty + public Long id; + @ApiModelProperty(value = "Идентификатор статуса", example = "ABCD") + @JsonProperty + private String serviceStatus; + @ApiModelProperty(value = "Текст причины", example = "Example text") + @JsonProperty + private String comment; + + @Override + public RelationUpdateRequest toRequest() { + RelationUpdateRequest request = new RelationUpdateRequest(); + request.setId(this.id); + request.setServiceStatus(this.serviceStatus); + request.setComment(this.comment); + return request; + } + + @ApiModelProperty(hidden = true) + @Override + public ActionType getActionType() { + return ActionType.UPDATE; + } + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getServiceStatus() { + return serviceStatus; + } + + public void setServiceStatus(String serviceStatus) { + this.serviceStatus = serviceStatus; + } + + public String getComment() { + return comment; + } + + public void setComment(String comment) { + this.comment = comment; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/ClearingCalendarNewAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/ClearingCalendarNewAction.java index eec5e9e5c..6d17ee7de 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/ClearingCalendarNewAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/ClearingCalendarNewAction.java @@ -40,6 +40,7 @@ public class ClearingCalendarNewAction implements IAction { +public class LauncherNew implements IAction { @ApiModelProperty(value = "Идентификатор единоличного исполнительного органа", example = "ABCD") @JsonProperty private String task; @@ -22,11 +24,17 @@ public class LauncherNew implements IAction { private Long userId; @Override - public LauncherCommandRequest toRequest() { - LauncherCommandRequest taskRunnerCommandRequest = new LauncherCommandRequest(); - taskRunnerCommandRequest.setTaskName(task); - taskRunnerCommandRequest.setUserId(userId); - return taskRunnerCommandRequest; + public Object toRequest() { + if (Task.createReport_GREP.equalsByKey(task)) { + ReportWithPeriodRequest reportCommand = new ReportWithPeriodRequest(); + reportCommand.setReportId(task); + return reportCommand; + } else { + LauncherCommandRequest taskRunnerCommandRequest = new LauncherCommandRequest(); + taskRunnerCommandRequest.setTaskName(task); + taskRunnerCommandRequest.setUserId(userId); + return taskRunnerCommandRequest; + } } @Override diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerNewAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerNewAction.java index cac2b85c2..6bba90535 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerNewAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerNewAction.java @@ -26,7 +26,7 @@ public class PlannerNewAction implements IAction { @JsonProperty private String task; - @ApiModelProperty(value = "Время", example = "16:30:00") + @ApiModelProperty(value = "Время", dataType = "java.lang.String", example = "16:30:00") @JsonSerialize(using = LocalTimeSerializer.class) @JsonDeserialize(using = LocalTimeDeserializer.class) @JsonProperty @@ -46,6 +46,10 @@ public class PlannerNewAction implements IAction { @JsonProperty public String taskStatus; + @ApiModelProperty(value = "Компания", example = "1000") + @JsonProperty + public Long companyId; + @ApiModelProperty(value = "Инструмент", example = "1000") @JsonProperty public Long securityId; @@ -58,10 +62,12 @@ public class PlannerNewAction implements IAction { plannerNewRequest.setClearingDate(clearingDate); plannerNewRequest.setMarket(market); plannerNewRequest.setTaskStatus(taskStatus); + plannerNewRequest.setCompanyId(companyId); plannerNewRequest.setSecurityId(securityId); return plannerNewRequest; } + @ApiModelProperty(hidden = true) @Override public ActionType getActionType() { return ActionType.NEW; diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerTemplateNewAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerTemplateNewAction.java index 244d4b522..6ab3eb845 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerTemplateNewAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerTemplateNewAction.java @@ -3,6 +3,7 @@ package ru.spcex.clearing.backendapi.controller.request.cud.schedule; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import io.swagger.annotations.ApiModelProperty; import ru.spcex.clearing.backendapi.domain.actions.IAction; import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.platform.messaging.domain.ActionType; @@ -18,14 +19,23 @@ import java.util.Collection; import java.util.List; public class PlannerTemplateNewAction implements IAction { + @ApiModelProperty(value = "Идентификатор задачи", example = "ADBC") @JsonProperty public String task; + @ApiModelProperty(value = "Время задачи", dataType = "java.lang.String", example = "16:30:00") @JsonSerialize(using = LocalTimeSerializer.class) @JsonDeserialize(using = LocalTimeDeserializer.class) @JsonProperty public LocalTime taskTime; + @ApiModelProperty(value = "Статус", example = "ACTV") @JsonProperty public String taskStatus; + @ApiModelProperty(value = "Компания", example = "123") + @JsonProperty + public Long companyId; + @ApiModelProperty(value = "Инструмент", example = "123") + @JsonProperty + public Long securityId; @Override public PlannerTemplateNewRequest toRequest() { @@ -33,9 +43,12 @@ public class PlannerTemplateNewAction implements IAction, WithI @JsonProperty private String task; - @ApiModelProperty(value = "Время", example = "16:30:00") + @ApiModelProperty(value = "Время", dataType = "java.lang.String", example = "16:30:00") @JsonSerialize(using = LocalTimeSerializer.class) @JsonDeserialize(using = LocalTimeDeserializer.class) @JsonProperty @@ -51,6 +51,10 @@ public class PlannerUpdateAction implements IAction, WithI @JsonProperty public String taskStatus; + @ApiModelProperty(value = "Компания", example = "1000") + @JsonProperty + public Long companyId; + @ApiModelProperty(value = "Инструмент", example = "1000") @JsonProperty public Long securityId; @@ -64,10 +68,12 @@ public class PlannerUpdateAction implements IAction, WithI plannerUpdateRequest.setClearingDate(clearingDate); plannerUpdateRequest.setMarket(market); plannerUpdateRequest.setTaskStatus(taskStatus); + plannerUpdateRequest.setCompanyId(companyId); plannerUpdateRequest.setSecurityId(securityId); return plannerUpdateRequest; } + @ApiModelProperty(hidden = true) @Override public ActionType getActionType() { return ActionType.UPDATE; @@ -150,4 +156,12 @@ public class PlannerUpdateAction implements IAction, WithI public void setSecurityId(Long securityId) { this.securityId = securityId; } + + public Long getCompanyId() { + return companyId; + } + + public void setCompanyId(Long companyId) { + this.companyId = companyId; + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityNewAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityNewAction.java index 69059d4d1..f96db5e09 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityNewAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityNewAction.java @@ -9,14 +9,17 @@ import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.platform.messaging.domain.ActionType; import ru.spcex.clearing.platform.messaging.domain.cud.securitites.MoneyMarketSecurityNewRequest; import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer; +import ru.spcex.platform.classes.base.interfaces.WithSecuritySymbol; import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.text.TextUtil; import java.time.LocalDate; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; -public class MoneyMarketSecurityNewAction implements IAction { +public class MoneyMarketSecurityNewAction implements IAction, WithSecuritySymbol { @ApiModelProperty(value = "Дата начала действия", example = "2022-01-20") @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow") @JsonDeserialize(using = LocalDateDeserializer.class) @@ -48,9 +51,24 @@ public class MoneyMarketSecurityNewAction implements IAction validate() { + List errors = new ArrayList<>(); if (this.startDate == null) - return List.of(new EnumMessage(BackEndError.ValidationError, "startDate")); - else return Collections.emptyList(); + errors.add(new EnumMessage(BackEndError.ValidationError, "startDate")); + if (this.endDate == null) + errors.add(new EnumMessage(BackEndError.ValidationError, "endDate")); + if (this.nominalValue == null) + errors.add(new EnumMessage(BackEndError.ValidationError, "nominalValue")); + if (TextUtil.isEmpty(nominalCurrency)) + errors.add(new EnumMessage(BackEndError.ValidationError, "nominalCurrency")); + if (TextUtil.isEmpty(instrumentType)) + errors.add(new EnumMessage(BackEndError.ValidationError, "instrumentType")); + if (TextUtil.isEmpty(fullName)) + errors.add(new EnumMessage(BackEndError.ValidationError, "fullName")); + if (TextUtil.isEmpty(securitySymbol)) + errors.add(new EnumMessage(BackEndError.ValidationError, "securitySymbol")); + if (this.lotSize == null) + errors.add(new EnumMessage(BackEndError.ValidationError, "lotSize")); + return errors.size() > 0 ? errors : Collections.emptyList(); } @Override diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityUpdateAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityUpdateAction.java index ae0124840..cc1eb8461 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityUpdateAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityUpdateAction.java @@ -5,17 +5,29 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import io.swagger.annotations.ApiModelProperty; import ru.spcex.clearing.backendapi.domain.actions.IAction; +import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.platform.messaging.domain.ActionType; import ru.spcex.clearing.platform.messaging.domain.cud.securitites.MoneyMarketSecurityUpdateRequest; import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer; import ru.spcex.platform.classes.base.interfaces.WithId; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.text.TextUtil; import java.time.LocalDate; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; public class MoneyMarketSecurityUpdateAction implements IAction, WithId { @ApiModelProperty(hidden = true) @JsonProperty public Long id; + @ApiModelProperty(value = "Дата начала действия", example = "2022-02-21") + @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow") + @JsonDeserialize(using = LocalDateDeserializer.class) + @JsonProperty + public LocalDate startDate; @ApiModelProperty(value = "Дата окончания действия", example = "2022-02-21") @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow") @JsonDeserialize(using = LocalDateDeserializer.class) @@ -41,6 +53,7 @@ public class MoneyMarketSecurityUpdateAction implements IAction validate() { + List errors = new ArrayList<>(); + if (this.startDate == null) + errors.add(new EnumMessage(BackEndError.ValidationError, "startDate")); + if (this.endDate == null) + errors.add(new EnumMessage(BackEndError.ValidationError, "endDate")); + if (this.nominalValue == null) + errors.add(new EnumMessage(BackEndError.ValidationError, "nominalValue")); + if (TextUtil.isEmpty(nominalCurrency)) + errors.add(new EnumMessage(BackEndError.ValidationError, "nominalCurrency")); + if (TextUtil.isEmpty(instrumentType)) + errors.add(new EnumMessage(BackEndError.ValidationError, "instrumentType")); + if (TextUtil.isEmpty(fullName)) + errors.add(new EnumMessage(BackEndError.ValidationError, "fullName")); + if (this.lotSize == null) + errors.add(new EnumMessage(BackEndError.ValidationError, "lotSize")); + return errors.size() > 0 ? errors : Collections.emptyList(); + } + @ApiModelProperty(hidden = true) @Override public ActionType getActionType() { @@ -112,4 +145,12 @@ public class MoneyMarketSecurityUpdateAction implements IAction { @ApiModelProperty(value = "Ключевая ставка ЦБ РФ", example = "12.5") @JsonProperty - public BigDecimal keyRate; + public BigDecimal rate; @ApiModelProperty(value = "Дата начала действия ключевой ставки", example = "2022-01-20") @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow") @JsonDeserialize(using = LocalDateDeserializer.class) @@ -53,17 +53,17 @@ public class KeyRateNewAction implements IAction { var req = new KeyRateNewRequest(); req.setStartDate(this.getStartDate()); req.setEndDate(this.getEndDate()); - req.setKeyRate(this.getKeyRate()); + req.setKeyRate(this.getRate()); req.setDocument(this.getDocument()); return req; } - public BigDecimal getKeyRate() { - return keyRate; + public BigDecimal getRate() { + return rate; } - public void setKeyRate(BigDecimal keyRate) { - this.keyRate = keyRate; + public void setRate(BigDecimal rate) { + this.rate = rate; } public LocalDate getStartDate() { diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/KeyRateUpdateAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/KeyRateUpdateAction.java index 4c5a1b3d2..250506c75 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/KeyRateUpdateAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/KeyRateUpdateAction.java @@ -18,7 +18,7 @@ public class KeyRateUpdateAction implements IAction { public Long id; @ApiModelProperty(value = "Ключевая ставка ЦБ РФ", example = "12.5") @JsonProperty - public BigDecimal keyRate; + public BigDecimal rate; @ApiModelProperty(value = "Дата начала действия ключевой ставки", example = "2022-01-20") @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow") @JsonDeserialize(using = LocalDateDeserializer.class) @@ -45,17 +45,17 @@ public class KeyRateUpdateAction implements IAction { req.setId(this.getId()); req.setStartDate(this.getStartDate()); req.setEndDate(this.getEndDate()); - req.setKeyRate(this.getKeyRate()); + req.setKeyRate(this.getRate()); req.setDocument(this.getDocument()); return req; } - public BigDecimal getKeyRate() { - return keyRate; + public BigDecimal getRate() { + return rate; } - public void setKeyRate(BigDecimal keyRate) { - this.keyRate = keyRate; + public void setRate(BigDecimal rate) { + this.rate = rate; } public LocalDate getStartDate() { diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthAction.java index 260c7b901..df59f552e 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthAction.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthAction.java @@ -1,43 +1,68 @@ package ru.spcex.clearing.backendapi.controller.request.cud.utilities; +import com.fasterxml.jackson.annotation.JsonProperty; import ru.spcex.clearing.backendapi.domain.actions.IAction; import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.platform.messaging.domain.ActionType; -import ru.spcex.clearing.platform.messaging.domain.cud.utilities.UserAuthRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.utilities.UserUpdateRequest; +import ru.spcex.platform.enumeration.UserRole; import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.enumeration.IEnumKey; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; -public class UserAuthAction implements IAction { - private final UserAuthRequest authRequest; - - public UserAuthAction() { - this.authRequest = new UserAuthRequest(); - } - - public UserAuthRequest getAuthRequest() { - return authRequest; - } +public class UserAuthAction implements IAction { + @JsonProperty + private String username; + @JsonProperty + private List roles = new ArrayList<>(); @Override public Collection validate() { - long count = authRequest.getRoles().stream().distinct().count(); - if (count != authRequest.getRoles().size()) { + long count = roles.stream().distinct().count(); + if (count != roles.size()) { return List.of(new EnumMessage(BackEndError.KeycloakRepeatedRoles)); } + boolean unknownRolePresent = roles + .stream() + .anyMatch(role -> IEnumKey.getEnumByKey(UserRole.class, role) == null); + if (unknownRolePresent) { + return List.of(new EnumMessage(BackEndError.ValidationError, roles)); + } return Collections.emptyList(); } @Override - public UserAuthRequest toRequest() { - return authRequest; + public UserUpdateRequest toRequest() { + UserUpdateRequest userUpdateRequest = new UserUpdateRequest(); + userUpdateRequest.setUsername(username); + userUpdateRequest.setRoles(roles); + return userUpdateRequest; + } @Override public ActionType getActionType() { - return ActionType.SYSTEM; + return ActionType.UPDATE; + } + + public String getUsername() { + return username; + } + + public void setUsername(String username) { + this.username = username; + } + + public List getRoles() { + return roles; + } + + public void setRoles(List roles) { + this.roles = roles; } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthSystemAction.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthSystemAction.java new file mode 100644 index 000000000..b4bfd9d80 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthSystemAction.java @@ -0,0 +1,42 @@ +package ru.spcex.clearing.backendapi.controller.request.cud.utilities; + + +import ru.spcex.clearing.backendapi.domain.actions.IAction; +import ru.spcex.clearing.backendapi.errors.BackEndError; +import ru.spcex.clearing.platform.messaging.domain.ActionType; +import ru.spcex.clearing.platform.messaging.domain.cud.utilities.UserAuthRequest; +import ru.spcex.platform.utils.enumeration.EnumMessage; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +public class UserAuthSystemAction implements IAction { +private final UserAuthRequest authRequest; + + public UserAuthSystemAction() { + this.authRequest = new UserAuthRequest(); + } + + public UserAuthRequest getAuthRequest() { + return authRequest; + } + + @Override + public Collection validate() { + long count = authRequest.getRoles().stream().distinct().count(); + if (count != authRequest.getRoles().size()) { + return List.of(new EnumMessage(BackEndError.KeycloakRepeatedRoles)); + } + return Collections.emptyList(); + } + + @Override + public UserAuthRequest toRequest() { + return authRequest; + } + + @Override + public ActionType getActionType() { + return ActionType.SYSTEM; + }} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetByIdResponse.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetByIdResponse.java new file mode 100644 index 000000000..936b72d68 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetByIdResponse.java @@ -0,0 +1,42 @@ +package ru.spcex.clearing.backendapi.controller.response.entity; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; + +import java.util.HashMap; +import java.util.Map; + +@ApiModel(description = "Ответ при получении объекта по ID.") +public class CommonGetByIdResponse extends BasicSpcexResponse { + + @JsonProperty + @ApiModelProperty(value = "Полезная нагрузка") + private GetByIdCommonPayload payload = new GetByIdCommonPayload(); + + private static class GetByIdCommonPayload { + private Map object = new HashMap<>(); + + public Map getObject() { + return object; + } + + public void setObject(Map object) { + this.object = object; + } + } + + public GetByIdCommonPayload getPayload() { + return payload; + } + + public void setPayload(GetByIdCommonPayload payload) { + this.payload = payload; + } + + public void fromEntity(Map anyObjectFields) { + var payload = this.getPayload(); + payload.setObject(anyObjectFields); + } +} \ No newline at end of file diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetAll.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetAll.java index 3d6c11aeb..c6c9b71f3 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetAll.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetAll.java @@ -9,25 +9,34 @@ import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.Map; @ApiModel(description = "Ответ при получении объектов словаря.") public class DictionaryBackendGetAll extends BasicSpcexResponse { @JsonProperty @ApiModelProperty(value = "Полезная нагрузка") - private DictionaryBackendPayload payload = new DictionaryBackendPayload(); + private IDictionaryPayload payload; public void fromEntity(Collection dictionaryValues) { - var payload = this.getPayload(); + this.payload = new GeneralDictionaryBackendPayload(); + GeneralDictionaryBackendPayload castedPayload = (GeneralDictionaryBackendPayload) payload; for (AbstractDictionary dictionaryValue : dictionaryValues) { var singleItem = new DictionaryBackendGetFields(); singleItem.fromEntity(dictionaryValue); - payload.getItems().add(singleItem); + castedPayload.getItems().add(singleItem); } } + public void addMap(Map m) { + if (this.payload == null) { + this.payload = new SpecificDictionaryBackendPayload(); + } + SpecificDictionaryBackendPayload payloadCasted = (SpecificDictionaryBackendPayload) this.payload; + payloadCasted.getItems().add(m); + } - private static class DictionaryBackendPayload { + public static class GeneralDictionaryBackendPayload implements IDictionaryPayload { private List items = new ArrayList<>(); public List getItems() { @@ -39,11 +48,24 @@ public class DictionaryBackendGetAll extends BasicSpcexResponse { } } - public DictionaryBackendPayload getPayload() { + public static class SpecificDictionaryBackendPayload implements IDictionaryPayload { + @JsonProperty + private List> items = new ArrayList<>(); + + public List> getItems() { + return items; + } + + public void setItems(List> items) { + this.items = items; + } + } + + public IDictionaryPayload getPayload() { return payload; } - public void setPayload(DictionaryBackendPayload payload) { + public void setPayload(IDictionaryPayload payload) { this.payload = payload; } } \ No newline at end of file diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetFields.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetFields.java index fa27898c9..eb91fba9a 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetFields.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetFields.java @@ -4,7 +4,7 @@ import com.fasterxml.jackson.annotation.JsonProperty; import io.swagger.annotations.ApiModelProperty; import ru.clearing.platform.dictionary.AbstractDictionary; -public class DictionaryBackendGetFields { +public class DictionaryBackendGetFields implements IDictionaryPayload { @JsonProperty @ApiModelProperty(value = "Идентификатор", example = "1234") private Long id; diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetSingleValueV2.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetSingleValueV2.java new file mode 100644 index 000000000..4db4ef922 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetSingleValueV2.java @@ -0,0 +1,25 @@ +package ru.spcex.clearing.backendapi.controller.response.entity.dictionary; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; + +import java.util.HashMap; +import java.util.Map; + +@ApiModel(description = "Ответ при получении объекта словаря.") +public class DictionaryBackendGetSingleValueV2 extends BasicSpcexResponse { + + @JsonProperty + @ApiModelProperty(value = "Поля объекта") + private Map payload = new HashMap<>(); + + public Map getPayload() { + return payload; + } + + public void setPayload(Map payload) { + this.payload = payload; + } +} \ No newline at end of file diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/IDictionaryPayload.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/IDictionaryPayload.java new file mode 100644 index 000000000..2cba7bac3 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/IDictionaryPayload.java @@ -0,0 +1,4 @@ +package ru.spcex.clearing.backendapi.controller.response.entity.dictionary; + +public interface IDictionaryPayload { +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/user/UserIdResponse.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/user/UserIdResponse.java new file mode 100644 index 000000000..a43e4f91d --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/user/UserIdResponse.java @@ -0,0 +1,36 @@ +package ru.spcex.clearing.backendapi.controller.response.entity.user; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; + +@ApiModel(description = "Ответ содержащий id текущего пользователя.") +public class UserIdResponse extends BasicSpcexResponse { + + @JsonProperty + @ApiModelProperty(value = "Полезная нагрузка") + private UserIdPayload payload = new UserIdPayload(); + + public UserIdPayload getPayload() { + return payload; + } + + public void setPayload(UserIdPayload payload) { + this.payload = payload; + } + + public static class UserIdPayload { + @JsonProperty + @ApiModelProperty(value = "Id текущего пользователя") + private Long id; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + } +} \ No newline at end of file diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/DictionaryController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/DictionaryController.java index 425bd1876..138735915 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/DictionaryController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/DictionaryController.java @@ -13,10 +13,11 @@ import org.springframework.web.bind.annotation.*; import ru.clearing.platform.dictionary.AbstractDictionary; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.entity.dictionary.DictionaryBackendGetAll; -import ru.spcex.clearing.backendapi.controller.response.entity.dictionary.DictionaryBackendGetSingleValue; +import ru.spcex.clearing.backendapi.controller.response.entity.dictionary.DictionaryBackendGetSingleValueV2; import ru.spcex.clearing.backendapi.errors.ActionValidationException; import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.backendapi.errors.NotFound404Exception; +import ru.spcex.clearing.backendapi.meta.GetResponseFactory; import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; @@ -33,10 +34,12 @@ public class DictionaryController { private final Logger log = LoggerFactory.getLogger(getClass()); private final Map> allDictionaryMaps; private final ImdgProvider imdgProvider; + private final GetResponseFactory responseFactory; @Autowired - public DictionaryController(ImdgProvider imdgProvider) { + public DictionaryController(ImdgProvider imdgProvider, GetResponseFactory responseFactory) { this.imdgProvider = imdgProvider; + this.responseFactory = responseFactory; this.allDictionaryMaps = new ConcurrentHashMap<>(); } @@ -49,39 +52,42 @@ public class DictionaryController { Imdg dictionary = extractDictionaryImdgFromUrlParameter(dictionaryName, AbstractDictionary.class); Collection allValues = dictionary.getAllValues(); DictionaryBackendGetAll response = new DictionaryBackendGetAll(); - response.fromEntity(allValues); + for (AbstractDictionary val : allValues) { + Map fromMeta = responseFactory.responseFromDictionary(dictionaryName, val); + response.addMap(fromMeta); + } return response; } @ApiOperation(value = "get dictionary value by id.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = DictionaryBackendGetSingleValue.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = DictionaryBackendGetSingleValueV2.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)}) @RequestMapping(value = "/{dictionary-name}/{id}", method = RequestMethod.GET) @ResponseBody - public DictionaryBackendGetSingleValue getById(@ApiParam(value = "Название словаря", required = true, example = "moneyFlowSide") + public DictionaryBackendGetSingleValueV2 getById(@ApiParam(value = "Название словаря", required = true, example = "moneyFlowSide") @PathVariable("dictionary-name") String dictionaryName, @ApiParam(value = "Идентификатор объекта", required = true, example = "1234") @PathVariable("id") Long id) { Imdg dictionary = extractDictionaryImdgFromUrlParameter(dictionaryName, AbstractDictionary.class); AbstractDictionary value = dictionary.getSingleObjectByID(id); if (value == null) throw new NotFound404Exception(dictionaryName + " id='" + id + "'"); - DictionaryBackendGetSingleValue response = new DictionaryBackendGetSingleValue(); - response.fromEntity(value); + DictionaryBackendGetSingleValueV2 response = new DictionaryBackendGetSingleValueV2(); + response.setPayload(responseFactory.responseFromDictionary(dictionaryName, value)); return response; } @ApiOperation(value = "get dictionary value by code.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = DictionaryBackendGetSingleValue.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = DictionaryBackendGetSingleValueV2.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)}) @RequestMapping(value = "/{dictionary-name}/code/{code}", method = RequestMethod.GET) @ResponseBody - public DictionaryBackendGetSingleValue getByCode(@ApiParam(value = "Название словаря", required = true, example = "moneyFlowSide") + public DictionaryBackendGetSingleValueV2 getByCode(@ApiParam(value = "Название словаря", required = true, example = "moneyFlowSide") @PathVariable("dictionary-name") String dictionaryName, @ApiParam(value = "Код словаря", required = true, example = "1234") @PathVariable("code") String code) { Imdg dictionary = extractDictionaryImdgFromUrlParameter(dictionaryName, AbstractDictionary.class); AbstractDictionary value = dictionary.getSingleObjectByFieldValues(Map.of("code", code)); if (value == null) throw new NotFound404Exception(dictionaryName + " code='" + code + "'"); - DictionaryBackendGetSingleValue response = new DictionaryBackendGetSingleValue(); - response.fromEntity(value); + DictionaryBackendGetSingleValueV2 response = new DictionaryBackendGetSingleValueV2(); + response.setPayload(responseFactory.responseFromDictionary(dictionaryName, value)); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/RequestStatusController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/RequestStatusController.java index cebfc2d57..31cfce2c9 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/RequestStatusController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/RequestStatusController.java @@ -43,6 +43,7 @@ public class RequestStatusController { } RequestInfoResponse response = new RequestInfoResponse(); response.setStatus(singleObjectByID.getStatus()); + response.setMessage(singleObjectByID.getMessage()); return response; } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/errors/NotFound404Exception.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/errors/NotFound404Exception.java index 1483749e5..9c225657f 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/errors/NotFound404Exception.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/errors/NotFound404Exception.java @@ -10,6 +10,10 @@ public class NotFound404Exception extends RuntimeException { this.error = new EnumMessage(BackEndError.ResourceNotFound, comment); } + public NotFound404Exception(EnumMessage error) { + this.error = error; + } + public EnumMessage getError() { return error; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingDictionaryExtracted.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingDictionaryExtracted.java new file mode 100644 index 000000000..dabb4f653 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingDictionaryExtracted.java @@ -0,0 +1,22 @@ +package ru.spcex.clearing.backendapi.meta; + +import java.util.List; + +public class ClearingDictionaryExtracted extends ObjectExtracted { + + public ClearingDictionaryExtracted(String clazz, List actionFields) { + for (ActionField field : actionFields) { + if (field.getVirtual() != null && field.isVirtual()){ + continue; + } + FieldExtracted fe = getImplFieldExtracted(field); + fields.add(fe); + fieldByCode.put(field.getCode(), fe); + } + } + + @Override + public FieldExtracted getImplFieldExtracted(ActionField field) { + return new ClearingFieldExtracted(field); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java index 11299df70..01f10dff7 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java @@ -8,15 +8,18 @@ import org.springframework.stereotype.Component; import java.text.SimpleDateFormat; import java.time.Instant; +import java.time.LocalTime; import java.time.ZoneId; import java.time.format.DateTimeFormatter; import java.util.*; +import java.util.function.Function; import java.util.stream.Collectors; @Component public class GetResponseFactory { private final Logger log = LoggerFactory.getLogger(getClass()); private final MetaServer meta; + private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss"); @Autowired public GetResponseFactory(MetaServer meta) { @@ -29,11 +32,46 @@ public class GetResponseFactory { .collect(Collectors.toList()); } + /** + * dictionaryName - это имя тэга внутри + */ + public Map responseFromDictionary(String dictionaryName, Object o) { + ObjectExtracted objectExtracted = meta.getEnumsExtractedByTagName().get(dictionaryName); + if (objectExtracted == null) { + throw new RuntimeException("cannot find dictionary in meta for " + dictionaryName); + } + return responseFromObjectExtracted(o, objectExtracted); + } + public Map responseFromObject(Object o) { ObjectExtracted objExtr = meta.getObjectsExtractedByClazz().get(o.getClass().getCanonicalName()); if (objExtr == null) { throw new RuntimeException("cannot find object in meta for " + o.getClass().getCanonicalName()); } + return responseFromObjectExtracted(o, objExtr); + } + + /** + * Варианты методов с Class сделаны для сценариев, когда хотим распарсить объект, + * по мете для родительского класса объекта + * Т.е. вместо извлечение класса o.getClass, берем clazz извне. clazz - base class для o + * + */ + public Collection> responseFromObjectCollection(Collection o, Class clazz) { + return o.stream() + .map((Function>) o1 -> responseFromObject(o1, clazz)) + .collect(Collectors.toList()); + } + + public Map responseFromObject(Object o, Class clazz) { + ObjectExtracted objExtr = meta.getObjectsExtractedByClazz().get(clazz.getCanonicalName()); + if (objExtr == null) { + throw new RuntimeException("cannot find object in meta for " + o.getClass().getCanonicalName()); + } + return responseFromObjectExtracted(o, objExtr); + } + + private Map responseFromObjectExtracted(Object o, ObjectExtracted objExtr) { Map r = new LinkedHashMap<>(); FieldExtracted currentField = null; try { @@ -46,7 +84,7 @@ public class GetResponseFactory { try { add(r, field.getField().getCode(), field.extractValue(o)); } catch (Throwable e) { - log.warn(ExceptionUtils.getStackTrace( + log.trace(ExceptionUtils.getStackTrace( new RuntimeException(String.format("Can't extract value for field='%s' of %s(%s): %s -> %s\n%s", field.getField().getCode(), o.getClass().getSimpleName(), objExtr.getClassName(), @@ -71,6 +109,8 @@ public class GetResponseFactory { data = sdf.format(value); } else if (value instanceof Instant) { data = dateTimeFormatter.format((Instant) value); + } else if (value instanceof LocalTime) { + data = timeFormatter.format((LocalTime) value); } else { data = value; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java index be7392a9b..df2f6bde2 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java @@ -2,6 +2,7 @@ package ru.spcex.clearing.backendapi.meta; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import ru.spcex.platform.utils.log.ExceptionUtils; import java.lang.reflect.Constructor; import java.lang.reflect.Method; @@ -17,6 +18,8 @@ public class MetaServer extends MetaBase { private Map objectsExtractedByDestination; private Map actionObjectsExtracted; private Map objectElementByDestination; + private Map enumsExtractedByTagName; + private final static Set dictionaryDefaultFields = Set.of("id", "code", "name"); protected ObjectExtracted getImplInstanceObjectExtracted(String clazz, List actionFields) { return new ClearingObjectExtracted(clazz, actionFields); @@ -31,6 +34,7 @@ public class MetaServer extends MetaBase { objectsExtractedByClazz = new ConcurrentHashMap<>(); objectsExtractedByDestination = new ConcurrentHashMap<>(); objectElementByDestination = new ConcurrentHashMap<>(); + enumsExtractedByTagName = new ConcurrentHashMap<>(); try { Map objects = getObjects(); log.info("Meta objects:\n{}", @@ -50,14 +54,14 @@ public class MetaServer extends MetaBase { try { oe = getImplInstanceObjectExtracted(objectElement.getClazz(), objectElement.getFields()); } catch (Throwable e) { - log.warn("META SERVER >>> Класс {} для {} не найден!", objects.get(key).getClazz(), key); + log.trace("META SERVER >>> Класс {} для {} не найден!", objects.get(key).getClazz(), key); continue; } objectsExtracted.add(oe); if (oe.getClassName() != null) { ObjectExtracted previous = objectsExtractedByClazz.put(oe.getClassName(), oe); if (previous != null) { - log.warn("!!! meta contains duplicate classes {}", oe.getClassName()); + log.trace("!!! meta contains duplicate classes {}", oe.getClassName()); } } else objectsExtractedByClazz.put(String.valueOf(classNameMock++), oe); @@ -84,6 +88,37 @@ public class MetaServer extends MetaBase { } catch (Throwable e) { throw new ClearingMetaServerValidationException(e.getLocalizedMessage()); } + try { + Map enums = getEnums(); + for (String key : enums.keySet()) { + ObjectExtracted oe; + ObjectEnumElement objectElement = enums.get(key); + try { + oe = new ClearingDictionaryExtracted(objectElement.getClazz(), objectElement.getFields()); + } catch (Throwable e) { + log.warn("{} {}", key, ExceptionUtils.getStackTrace(e)); + continue; + } + /** + * можно было бы хранить только для нестандартных словарей (где не только id, name, code) + */ +// List dictFields = oe.getFields(); +// boolean add = false; +// for (FieldExtracted dictField : dictFields) { +// if (!dictionaryDefaultFields.contains(dictField.getMemberName())) { +// add = true; +// break; +// } +// } +// if (add) { +// enumsExtractedByTagName.put(key, oe); +// } + enumsExtractedByTagName.put(key, oe); + } + + } catch (Throwable e) { + throw new ClearingMetaServerValidationException(e.getLocalizedMessage()); + } } for (ObjectExtracted o : this.objectsExtracted) { try { @@ -146,7 +181,7 @@ public class MetaServer extends MetaBase { } c = RfHelper.getMetodReturnClazz(m); } catch (OtcMetaServerGetterNotFoundException e) { - log.warn("META SERVER >>> Геттер {}.{} не найден!", o.getClassName(), getterName); + log.trace("META SERVER >>> Геттер {}.{} не найден!", o.getClassName(), getterName); } } } @@ -196,4 +231,8 @@ public class MetaServer extends MetaBase { } return partSize; } + + public Map getEnumsExtractedByTagName() { + return enumsExtractedByTagName; + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectExtracted.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectExtracted.java index 5f75b9de5..8e4fc3cda 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectExtracted.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectExtracted.java @@ -5,12 +5,14 @@ import java.util.*; import java.util.concurrent.ConcurrentHashMap; public abstract class ObjectExtracted { - private String className; - private Class clazz; - private List fields = new LinkedList<>(); - private Map fieldByCode = new ConcurrentHashMap<>(); - private boolean isArray = false; + protected String className; + protected Class clazz; + protected List fields = new LinkedList<>(); + protected Map fieldByCode = new ConcurrentHashMap<>(); + protected boolean isArray = false; + public ObjectExtracted() { + } public ObjectExtracted(String clazz, List actionFields) { this.className = clazz; diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/security/handlers/AuthAuditSuccessLoginHandler.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/security/handlers/AuthAuditSuccessLoginHandler.java index 6d39e9cbb..4ab762d94 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/security/handlers/AuthAuditSuccessLoginHandler.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/security/handlers/AuthAuditSuccessLoginHandler.java @@ -3,6 +3,7 @@ package ru.spcex.clearing.backendapi.security.handlers; import org.keycloak.KeycloakPrincipal; import org.keycloak.adapters.spi.KeycloakAccount; import org.keycloak.adapters.springsecurity.token.KeycloakAuthenticationToken; +import org.keycloak.representations.AccessToken; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; @@ -34,16 +35,24 @@ public class AuthAuditSuccessLoginHandler implements AuthenticationSuccessHandle try { KeycloakAuthenticationToken auth = (KeycloakAuthenticationToken) authentication; KeycloakAccount details = (KeycloakAccount) auth.getDetails(); - String username = ((KeycloakPrincipal) details.getPrincipal()) - .getKeycloakSecurityContext() + KeycloakPrincipal principal = (KeycloakPrincipal) details.getPrincipal(); + String username = principal.getKeycloakSecurityContext() .getToken() .getPreferredUsername(); Set roles = details.getRoles(); if (roles.contains(Admin.getKey()) || roles.contains(Security.getKey()) || roles.contains(Superviser.getKey())) { + AccessToken token = principal.getKeycloakSecurityContext().getToken(); String clientIp = request != null ? request.getRemoteAddr() : null; String serverIp = request != null ? request.getLocalAddr() : null; - userAutoCreation.sendAuthSuccessEvent(username, roles, clientIp, serverIp); + userAutoCreation.sendAuthSuccessEvent(username, + roles, + clientIp, + serverIp, + token.getEmail(), + token.getGivenName(), + token.getFamilyName(), + token.getMiddleName()); } } catch (Throwable e) { log.error(ExceptionUtils.getStackTrace(e)); diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java index c8caa0caa..837b525c8 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java @@ -13,4 +13,6 @@ public interface IStateLoader { Optional getById(Long id, String mapName, Class clazz); Collection getAll(String mapName, Class clazz); Collection> getAllMetaTransform(String mapName, Class clazz); + Collection> getAllMetaTransformSpecificClass(String mapName, Class clazz); + Collection> getAllMetaTransform(String mapName, Class clazz, Map> conditions); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/RequestInfoAccepter.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/RequestInfoAccepter.java index a1eaff115..698d281a6 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/RequestInfoAccepter.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/RequestInfoAccepter.java @@ -43,6 +43,7 @@ public class RequestInfoAccepter extends QueueConsumer implements InitializingBe return; } requestInfo.setStatus(statusInfo.getStatus()); + requestInfo.setMessage(statusInfo.getMessage()); requestInfoImdg.update(requestInfo); } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/UserAuthProcessor.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/UserAuthProcessor.java index 32615128f..a98799a8a 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/UserAuthProcessor.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/UserAuthProcessor.java @@ -5,7 +5,7 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; -import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserAuthAction; +import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserAuthSystemAction; import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserLogoutAction; import ru.spcex.clearing.platform.messaging.domain.Consts; import ru.spcex.clearing.platform.messaging.domain.cud.utilities.UserAuthRequest; @@ -33,14 +33,19 @@ public class UserAuthProcessor { this.operator = operator; } - public void sendAuthSuccessEvent(String identifier, Collection roles, String userIp, String serverIp) { - UserAuthAction authEvent = new UserAuthAction(); - UserAuthRequest requestData = authEvent.getAuthRequest(); + public void sendAuthSuccessEvent(String identifier, Collection roles, String userIp, String serverIp, + String email, String name, String surname, String middleName) { + UserAuthSystemAction authEvent = new UserAuthSystemAction(); + UserAuthRequest requestData = authEvent.toRequest(); requestData.setUsername(identifier); requestData.setTime(Instant.now()); requestData.setRoles(new ArrayList<>(roles)); requestData.setServerIp(serverIp + ":" + serverPort); //getServerAddress() + ":" + serverPort requestData.setClientIp(userIp); + requestData.setEmail(email); + requestData.setName(name); + requestData.setSurname(surname); + requestData.setMiddleName(middleName); try { operator.sendRequestToQueue(Consts.USER_AUTH_SUCCESS, authEvent); } catch (Throwable e) { //ExecutionException | InterruptedException @@ -69,7 +74,7 @@ public class UserAuthProcessor { while (networkInterfaces.hasMoreElements()) { NetworkInterface networkInterface = networkInterfaces.nextElement(); Enumeration inetAddresses = networkInterface.getInetAddresses(); - while(inetAddresses.hasMoreElements()) { + while (inetAddresses.hasMoreElements()) { InetAddress inetAddress = inetAddresses.nextElement(); if (inetAddress != null) { serverAddress = inetAddress.getHostAddress(); diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/OperatorImpl.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/OperatorImpl.java index dedc83844..1f21495fd 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/OperatorImpl.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/OperatorImpl.java @@ -59,15 +59,17 @@ public class OperatorImpl implements IOperator { } private void throwValidate(String destination, IAction iAction) { + //простая валидация - которую можно запилить прямо внутри класса (наличие полей, отношения между датами etc.) Collection validationErrors = iAction.validate(); if (validationErrors.size() > 0) { throw new ActionValidationException(validationErrors); } + //валидация требующая IMDG поиска других сущностей и т.д. IValidator validator = validation.getValidator(destination, iAction); if (validator != null) { validator.tillFirstError().ifPresent(enumMessage -> { if (enumMessage.getSubject().equalsById(BackEndError.ResourceNotFound.getId())) { - throw new NotFound404Exception((String) enumMessage.getArgs()[0]); + throw new NotFound404Exception(enumMessage); } else { throw new ActionValidationException(enumMessage); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java index 8d21ba817..c6cab6002 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java @@ -44,6 +44,21 @@ public class StateLoaderImpl implements IStateLoader { return responseFactory.responseFromObjectCollection(all); } + @Override + public Collection> getAllMetaTransformSpecificClass(String mapName, Class clazz) { + Collection all = getAll(mapName, clazz); + return responseFactory.responseFromObjectCollection(all, clazz); + } + + @Override + public Collection> getAllMetaTransform(String mapName, + Class clazz, + Map> conditions) { + Imdg imdg = getImdg(mapName, clazz); + Collection all = imdg.getCollectionObjectsByFieldValues(conditions); + return responseFactory.responseFromObjectCollection(all); + } + @SuppressWarnings("unchecked") private Imdg getImdg(String mapName, Class clazz) { return (Imdg) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProvider.getImdg(mapName, clazz)); diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionValidationProvider.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionValidationProvider.java index 8a3005e3d..d0a6cf9a5 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionValidationProvider.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionValidationProvider.java @@ -5,8 +5,8 @@ import org.springframework.stereotype.Component; import ru.clearing.platform.dictionary.AbstractDictionary; import ru.spcex.clearing.backendapi.controller.request.cud.schedule.LauncherNew; import ru.spcex.clearing.backendapi.domain.actions.IAction; +import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.backendapi.service.validation.rules.LauncherNewValidationRule; -import ru.spcex.clearing.backendapi.service.validation.rules.PresentById; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import ru.spcex.platform.classes.base.SpcexObjectBase; @@ -14,9 +14,11 @@ import ru.spcex.platform.classes.base.interfaces.WithId; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.validation.ImdgValidationContext; +import ru.spcex.platform.imdg.validation.rule.PresentById; import ru.spcex.platform.utils.validation.IValidator; import ru.spcex.platform.utils.validation.ValidatorImpl; +import java.util.Arrays; import java.util.HashMap; import java.util.Map; import java.util.function.Function; @@ -35,11 +37,9 @@ public class ActionValidationProvider implements InitializingBean { @Override public void afterPropertiesSet() { - getImdg(IMDGDistributedNames.Map_TaskDictionary, AbstractDictionary.class); - getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, SpcexObjectBase.class); - validators.put(Consts.DESTINATION_MONEY_MARKET_SECURITY_UPDATE, idPresent(IMDGDistributedNames.Map_MoneyMarketSecurity)); validators.put(Consts.DESTINATION_MONEY_MARKET_SECURITY_DELETE, idPresent(IMDGDistributedNames.Map_MoneyMarketSecurity)); + validators.put(Consts.DESTINATION_RELATION_UPDATE, idPresent(IMDGDistributedNames.Map_Relation)); validators.put(Consts.LAUNCHER_NEW, taskRunnerNew()); } @@ -51,21 +51,35 @@ public class ActionValidationProvider implements InitializingBean { return null; } + + + private > Function defaultConstructor(Class clazz, Imdg... imdgs) { + return iAcc -> { + ImdgValidationContext ctx = new ImdgValidationContext<>(); + ctx.setValidatedObject(iAcc); + Arrays.stream(imdgs).forEach(imdg -> ctx.addImdg(imdg.getMapName(), imdg)); + return new ValidatorImpl<>(ctx); + }; + } + private & WithId> Function idPresent(String mapName) { + Imdg targetMap = getImdg(mapName, SpcexObjectBase.class); return iAction -> { ImdgValidationContext ctx = new ImdgValidationContext<>(); ctx.setValidatedObject(iAction); + ctx.addImdg(mapName, targetMap); ValidatorImpl> iValidator = new ValidatorImpl<>(ctx); - iValidator.addRule(new PresentById(getImdg(mapName, SpcexObjectBase.class))); + iValidator.addRule(new PresentById(mapName, BackEndError.ResourceNotFound)); return iValidator; }; } private Function taskRunnerNew() { + Imdg tskDctnrImdg = getImdg(IMDGDistributedNames.Map_TaskDictionary, AbstractDictionary.class); return taskRunnerNew -> { ImdgValidationContext ctx = new ImdgValidationContext<>(); ctx.setValidatedObject(taskRunnerNew); - ctx.addImdg(IMDGDistributedNames.Map_TaskDictionary, getImdg(IMDGDistributedNames.Map_TaskDictionary, AbstractDictionary.class)); + ctx.addImdg(IMDGDistributedNames.Map_TaskDictionary, tskDctnrImdg); ValidatorImpl> iValidator = new ValidatorImpl<>(ctx); iValidator.addRule(LauncherNewValidationRule.knownTaskDictionary); return iValidator; diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/rules/PresentById.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/rules/PresentById.java deleted file mode 100644 index 032767967..000000000 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/rules/PresentById.java +++ /dev/null @@ -1,28 +0,0 @@ -package ru.spcex.clearing.backendapi.service.validation.rules; -import ru.spcex.clearing.backendapi.errors.BackEndError; -import ru.spcex.platform.classes.base.SpcexObjectBase; -import ru.spcex.platform.classes.base.interfaces.WithId; -import ru.spcex.platform.imdg.api.Imdg; -import ru.spcex.platform.imdg.validation.ImdgValidationContext; -import ru.spcex.platform.utils.enumeration.EnumMessage; -import ru.spcex.platform.utils.validation.IValidationRule; - -import java.util.Optional; - -public class PresentById implements IValidationRule> { - private final Imdg map; - - public PresentById(Imdg map) { - this.map = map; - } - - @Override - public Optional validate(ImdgValidationContext context) { - WithId actionById = context.getValidatedObject(); - if (map.getSingleObjectByID(actionById.getId()) == null) { - return of(BackEndError.ResourceNotFound, actionById.getId()); - } else { - return empty(); - } - } -} diff --git a/clearing-parent/backend-api/src/main/resources/meta/data.xml b/clearing-parent/backend-api/src/main/resources/meta/data.xml index 5fe2fbea7..dd892e3c3 100644 --- a/clearing-parent/backend-api/src/main/resources/meta/data.xml +++ b/clearing-parent/backend-api/src/main/resources/meta/data.xml @@ -6,17 +6,25 @@ - - + + + + + + + + + - - + + + @@ -38,9 +46,6 @@ - - - @@ -85,7 +90,7 @@ - + @@ -143,12 +148,14 @@ - - + + + + @@ -160,17 +167,19 @@ + + - - + + @@ -183,8 +192,8 @@ - - + + @@ -192,8 +201,8 @@ - - + + @@ -208,13 +217,14 @@ + - - + + - - + + @@ -226,8 +236,8 @@ - - + + @@ -241,8 +251,8 @@ - - + + @@ -263,8 +273,8 @@ - - + + @@ -277,6 +287,9 @@ + + + diff --git a/clearing-parent/backend-api/src/main/resources/meta/meta.xml b/clearing-parent/backend-api/src/main/resources/meta/meta.xml index a14fe0008..f8f91c229 100644 --- a/clearing-parent/backend-api/src/main/resources/meta/meta.xml +++ b/clearing-parent/backend-api/src/main/resources/meta/meta.xml @@ -1,30 +1,25 @@ - + - + - + - + - - - - - - + @@ -44,7 +39,7 @@ - + @@ -54,380 +49,428 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + + + + + + - + - - + + - + - + - + - - + + - - - - - - - + + + + + + + + + - - - + + + + + - + - - + + + + - + - - - - - - - + + + + + + + - + - + - + - + - + - - - - - - - + + + + - + + + + + - - - - + + + + - + + - + - - - + + + - + + - + - - + - + + - + + - - + + + + - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + - - + + + - + - - - - - - - - - - + + + + + + + + + @@ -435,16 +478,17 @@ + - + - - + + - - - + + + @@ -452,316 +496,319 @@ - - - - + + + + - - - + + + - + - + - + - - - - + + + + - + - + - - - - + + + - + + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - + + + + - + - + - - - - + - - - - - - - + + + + + + + - - - - - - - - - + + + + + + + + +
- - - + + + + + + - - - - + + + - + + - - + + - + - + - + - - - + + + - - - - + - - - + + + - - + - - - - - + + + + + + + + + + - + - - + + - - - + + - - + + + + + - + + - - + + - + - - + + - + - - - - + + + + + - - + + - + - - - - - - + + + - + + + + - + + + - - - - - + + - + - - + + + - - - + + + + + - - - - + + - - - + + + + + - - - + + - - + + - - - - - + + - - - - + + + + - + - - - + - - - - + + + + + + @@ -777,11 +824,11 @@ - - - - + + + + @@ -792,39 +839,29 @@ - - - - - + + + + + + + - - + + - + - - - - - - - - - - - - + - - + @@ -839,9 +876,9 @@ + - - + @@ -855,16 +892,13 @@ + - - + - - - - + @@ -874,24 +908,24 @@ - + - - - + + + - - - - - - + + + + + + @@ -902,21 +936,21 @@ - + - - - + + + - + + + + + - - - - - + @@ -931,12 +965,12 @@ + + + + - - - - - + @@ -951,12 +985,12 @@ + + + + - - - - - + @@ -971,30 +1005,31 @@ - - - - - - + + + + + + + + + + - - - - + - - + + @@ -1003,33 +1038,30 @@ + + + - + + + + + + + + + - - - - - - - - - - - - - - - - + + + + - + - - @@ -1037,16 +1069,16 @@ - - - - + + + + - + @@ -1054,31 +1086,30 @@ - + - + - - - - - - + + + + + - - + + @@ -1086,11 +1117,15 @@ - - + + + + + + - + @@ -1104,7 +1139,7 @@ - + @@ -1114,38 +1149,38 @@ - - - - - - - - - - + + + + + + + - + - - - - - - + + + + + + - - + + + + + - - - + + + @@ -1161,8 +1196,8 @@ - - + + @@ -1173,9 +1208,9 @@ - - - + + + @@ -1186,8 +1221,8 @@ - - + + @@ -1199,10 +1234,10 @@ - + - - + + @@ -1210,7 +1245,7 @@ - + @@ -1228,7 +1263,7 @@ - + @@ -1247,7 +1282,7 @@ - + @@ -1299,7 +1334,7 @@ - + @@ -1351,7 +1386,7 @@ - +
@@ -1360,39 +1395,39 @@ - + - - + + - + - + - + - + - + @@ -1443,7 +1478,7 @@ - + @@ -1452,7 +1487,7 @@ - + @@ -1502,36 +1537,36 @@ - + - - - + + + - + - - - + + + - + @@ -1541,7 +1576,7 @@ - + @@ -1563,7 +1598,7 @@ - + @@ -1574,26 +1609,40 @@ - - + + - + + + + + + + + + + + + + + + - + - - - + + + @@ -1624,111 +1673,13 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -