From e46835696fb491f8236c3a7aa7dfa16b68724f2f Mon Sep 17 00:00:00 2001 From: ialbert Date: Fri, 30 Dec 2022 16:52:05 +0300 Subject: [PATCH] http://jira.mfd.msk:8088/browse/CLS-223 --- .../account/AccountBalanceController.java | 39 ++++++++ .../company/CompanyRoleSetController.java | 44 +++++++++ .../queue/company/RelationController.java | 17 ++++ .../execution/ExecutionDepositController.java | 44 +++++++++ .../journal/InDocumentJournalController.java | 44 +++++++++ .../journal/ManagementJournalController.java | 44 +++++++++ .../journal/OutDocumentJournalController.java | 44 +++++++++ .../LiabilitiesClaimsAssetController.java | 44 +++++++++ .../LiabilitiesClaimsMoneyController.java | 44 +++++++++ .../queue/misc/CurrencyController.java | 43 +++++++++ .../queue/misc/ErrorTextController.java | 43 +++++++++ .../queue/misc/MarketController.java | 43 +++++++++ .../payment/PaymentInstructionController.java | 2 +- .../AdmittedDealRegisterController.java | 44 +++++++++ .../register/BalanceRegisterController.java | 44 +++++++++ .../ClearMemberRegisterController.java | 44 +++++++++ .../register/ContractRegisterController.java | 44 +++++++++ .../CoveredDealRegisterController.java | 44 +++++++++ .../register/DealRegisterController.java | 44 +++++++++ .../register/OrderRegisterController.java | 44 +++++++++ .../register/ReportRegisterController.java | 44 +++++++++ .../UncoveredDealRegisterController.java | 44 +++++++++ .../InformationAccountController.java | 40 ++++++++ .../queue/securities/SecurityController.java | 41 ++++++++ .../queue/utilities/StatementController.java | 73 ++++++++++++++ .../entity/CommonGetByIdResponse.java | 42 ++++++++ .../backendapi/meta/GetResponseFactory.java | 21 ++++ .../backendapi/service/IStateLoader.java | 1 + .../service/impl/StateLoaderImpl.java | 6 ++ .../LiabilitiesClaimsMoneyMapStore.java | 95 +++++++++++++++++++ .../clearing/imdg/IMDGDistributedNames.java | 1 + 31 files changed, 1210 insertions(+), 1 deletion(-) create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountBalanceController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/CompanyRoleSetController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/execution/ExecutionDepositController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/InDocumentJournalController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/ManagementJournalController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/OutDocumentJournalController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsAssetController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsMoneyController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/CurrencyController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ErrorTextController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/MarketController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/AdmittedDealRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/BalanceRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ClearMemberRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ContractRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/CoveredDealRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/DealRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/OrderRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ReportRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/UncoveredDealRegisterController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/InformationAccountController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/StatementController.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetByIdResponse.java create mode 100644 clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/LiabilitiesClaimsMoneyMapStore.java 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/RelationController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/RelationController.java index 66f581399..a222c4238 100644 --- 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 @@ -8,14 +8,19 @@ 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 @@ -29,6 +34,18 @@ public class RelationController extends AbstractQueueController { 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) 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..b1cf05848 --- /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.transaction.data.execution.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/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/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/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/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/meta/GetResponseFactory.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java index e6e23ff8d..0738cb1fe 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 @@ -12,6 +12,7 @@ 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 @@ -50,6 +51,26 @@ public class GetResponseFactory { 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; 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 b5fd01105..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,5 +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/impl/StateLoaderImpl.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java index afd00a665..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,12 @@ 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, diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/LiabilitiesClaimsMoneyMapStore.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/LiabilitiesClaimsMoneyMapStore.java new file mode 100644 index 000000000..c28121186 --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/LiabilitiesClaimsMoneyMapStore.java @@ -0,0 +1,95 @@ +package ru.spcex.clearing.imdg.businessobject; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.imdg.base.TemplateMapStore; +import ru.spcex.platform.utils.time.TimeUtil; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; + +@Component +public class LiabilitiesClaimsMoneyMapStore extends TemplateMapStore { + + public LiabilitiesClaimsMoneyMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_LiabilitiesClaimsMoney; + } + + @Override + public String getTableName() { + return "LIABILITIES_CLAIMS_MONEY"; + } + + @Override + public String[] getFields() { + return new String[]{"ID", "CREATED_AT", "UPDATED_AT", + "company_id", + "account_id", + "account_type", + "account", + "liabilities_amount", + "claims_amount", + "settlement_date", + "trading_date", + "currency", + "trading_code", + "short_name", + "full_name", + "clearing_date", + }; + } + + @Override + public LiabilitiesClaimsMoney objectReader(ResultSet resultSet) throws SQLException { + LiabilitiesClaimsMoney object = new LiabilitiesClaimsMoney(); + object.setId(resultSet.getObject("ID", Long.class)); + object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT")); + object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT")); + object.setCompanyId(resultSet.getObject("COMPANY_ID", Long.class)); + object.setAccountId(resultSet.getObject("ACCOUNT_ID", Long.class)); + object.setAccountType(resultSet.getObject("ACCOUNT_TYPE", String.class)); + object.setAccount(resultSet.getObject("ACCOUNT", String.class)); + object.setLiabilitiesAmount(resultSet.getObject("LIABILITIES_AMOUNT", BigDecimal.class)); + object.setClaimsAmount(resultSet.getObject("CLAIMS_AMOUNT", BigDecimal.class)); + object.setSettlementDate(getLocalDateFromSqlDate(resultSet, "SETTLEMENT_DATE")); + object.setTradingDate(getLocalDateFromSqlDate(resultSet, "TRADING_DATE")); + object.setCurrency(resultSet.getObject("CURRENCY", String.class)); + object.setTradingCode(resultSet.getObject("TRADING_CODE", String.class)); + object.setShortName(resultSet.getObject("SHORT_NAME", String.class)); + object.setFullName(resultSet.getObject("FULL_NAME", String.class)); + object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE")); + return object; + } + + @Override + public Object[] objectToField(LiabilitiesClaimsMoney object) { + Object[] args = new Object[]{ + object.getId(), + TimeUtil.toDateFromInstant(object.getCreated()), + TimeUtil.toDateFromInstant(object.getUpdated()), + object.getCompanyId(), + object.getAccountId(), + object.getAccountType(), + object.getAccount(), + object.getLiabilitiesAmount(), + object.getClaimsAmount(), + TimeUtil.toDateFromLocalDate(object.getSettlementDate()), + TimeUtil.toDateFromLocalDate(object.getTradingDate()), + object.getCurrency(), + object.getTradingCode(), + object.getShortName(), + object.getFullName(), + TimeUtil.toDateFromLocalDate(object.getClearingDate()), + }; + return args; + } + +} \ No newline at end of file diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java index dd7db6001..80fd2eb00 100644 --- a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java +++ b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java @@ -108,6 +108,7 @@ public final class IMDGDistributedNames { public static final String Map_Session = "Map_Session"; public static final String Map_Notification = "Map_Notification"; public static final String Map_LiabilitiesClaimsAssets = "Map_LiabilitiesClaimsAssets"; + public static final String Map_LiabilitiesClaimsMoney = "Map_LiabilitiesClaimsMoney"; public static final String Map_ClearMemberRegister = "Map_ClearMemberRegister"; public static final String Map_BalanceRegister = "Map_BalanceRegister"; public static final String Map_ExecutionDeposit = "Map_ExecutionDeposit";