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/user/UserController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java index 1ab83b5c6..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 @@ -20,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; @@ -59,6 +60,23 @@ 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)}) @@ -72,10 +90,10 @@ public class UserController extends AbstractQueueController { log.warn("user {} sended update request for user {}", username, userUpdateAction.getUsername()); throw new IllegalStateException("cannot perform delete action for " + username); } - User user = userImdg.getSingleObjectByFieldValues(Map.of("identifier", username)); - if (user == null) { - log.info("user {} authenticated, but User object was not created", 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/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/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/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/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 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/UserAuthProcessor.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/UserAuthProcessor.java index e160f761a..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 @@ -33,7 +33,8 @@ public class UserAuthProcessor { this.operator = operator; } - public void sendAuthSuccessEvent(String identifier, Collection roles, String userIp, String serverIp) { + 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); @@ -41,6 +42,10 @@ public class UserAuthProcessor { 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 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/clearing-service/src/main/java/ru/spcex/clearing/service/ClearingService.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/ClearingService.java index a2c9487a8..1204c835c 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/ClearingService.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/ClearingService.java @@ -2,6 +2,7 @@ package ru.spcex.clearing.service; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.Scheduled; @@ -12,16 +13,19 @@ import java.util.concurrent.Executors; @Service @EnableScheduling -public class ClearingService { +public class ClearingService implements DisposableBean { private final Logger log = LoggerFactory.getLogger(getClass()); private final ExecutorService executor; private final SdfCreatorBySTLDPayment sdfCreator; private final PaymentUpdateBySdf04 paymentUpdater; + private final VerificationResultComponent verificationResultComponent; @Autowired - public ClearingService(SdfCreatorBySTLDPayment sdfCreator, PaymentUpdateBySdf04 paymentUpdater) { + public ClearingService(SdfCreatorBySTLDPayment sdfCreator, PaymentUpdateBySdf04 paymentUpdater, + VerificationResultComponent verificationResultComponent) { this.sdfCreator = sdfCreator; this.paymentUpdater = paymentUpdater; + this.verificationResultComponent = verificationResultComponent; this.executor = Executors.newSingleThreadExecutor(); } @@ -35,4 +39,15 @@ public class ClearingService { log.info("updating payment.transactionStatus by sdf04 task added to queue"); executor.execute(() -> paymentUpdater.updatePayments(sdf04GroupId)); } + + public void executeVerification() { + log.info("execute verification"); + executor.execute(() -> verificationResultComponent.executeRevision()); + } + + @Override + public void destroy() throws Exception { + log.debug("Shutdown {}", getClass().getSimpleName()); + executor.shutdown(); + } } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/EventsReceiver.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/EventsReceiver.java index bd4bfef11..f7911379f 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/EventsReceiver.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/EventsReceiver.java @@ -28,6 +28,9 @@ public class EventsReceiver extends QueueConsumer implements InitializingBean { callback(LauncherCommandRequest.class) .setConsumer(event -> clearingService.sdfCreate()) .forDestination(Task.createOrder.topic(), callbacks::put); + callback(LauncherCommandRequest.class) + .setConsumer(event -> clearingService.executeVerification()) + .forDestination(Task.getVerification.topic(), callbacks::put); init(); } } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/VerificationResultComponent.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/VerificationResultComponent.java new file mode 100644 index 000000000..4a23d7045 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/VerificationResultComponent.java @@ -0,0 +1,299 @@ +package ru.spcex.clearing.service; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.DisposableBean; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.scheduling.annotation.EnableScheduling; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Component; +import org.springframework.stereotype.Service; +import org.springframework.util.StringUtils; +import ru.clearing.classes.objects.BusinessObject; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.sdf.SDf01; +import ru.clearing.classes.statics.data.account.AccountBalance; +import ru.clearing.classes.statics.data.sdf.SDf03; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.classes.base.interfaces.WithId; +import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ResultStatuses; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +import java.math.BigDecimal; +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; + +/** + * 1.70. verificationResult - Результаты сверки + * Раздел I - Функционал сверок + */ +@Component +public class VerificationResultComponent { + private final Logger log = LoggerFactory.getLogger(getClass()); + + // private final ImdgProvider imdgProvider; + private Imdg sdf01Imdg; + private Imdg accountBalanceImdg; + private Imdg accountImdg; + + + @Autowired + public VerificationResultComponent(ImdgProvider imdgProvider + ) { +// this.imdgProvider = imdgProvider; + this.sdf01Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class); + this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); + this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); + + //this.idGenerator = imdgProvider.getImdgIdGenerator(); + //this.kafkaSender = KafkaSender kafkaSender + } + + protected void executeRevision() { + Collection allSDf01 = sdf01Imdg.getAllValues(); + Collection allAccountBalance = accountBalanceImdg.getAllValues(); + Collection allAccount = accountImdg.getAllValues(); + executeRevision(allSDf01, allAccountBalance, allAccount); + + //todo результат logic... см. как было в корпе? + } + + protected void executeRevision(Collection allSDf01, Collection allAccountBalance, Collection allAccount) { + // 1. Сумму по остаткам + List vResLst = new ArrayList<>(); + /* todo use: + + + + + + + + + + + + + + + */ + { + Map indexSDf01 = index(allSDf01, SDf01::getAccount); + for (AccountBalance account : allAccountBalance) { + VerificationResult vResult = new VerificationResult(); + vResult.setAccountId(account.getAccountId()); + + SDf01 document = indexSDf01.get(account.getAccount()); + if (document == null) { + log.warn("s_df01 not found by AccountBalance[{}].account=\"{}\"", account.getId(), account.getAccount()); + } else { + BigDecimal remainder = BigDecimal.ZERO; + if (document.getRemainder() != null) { + try { + remainder = new BigDecimal(document.getRemainder()); + } catch (NumberFormatException nfe) { + log.warn("SDf01[{}].remainder=\"{}\" is not parseable: {}", + document.getId(), document.getRemainder(), nfe.getMessage()); + } + } + BigDecimal balance = account.getCloseBalanceAmount() == null ? BigDecimal.ZERO : account.getCloseBalanceAmount(); + //todo сравнить правильно, remainder там без точек. remainder==balance + BigDecimal diff = balance.subtract(remainder).abs(); + vResult.setDiffSum(diff); + if (BigDecimal.ZERO.compareTo(diff) == 0) { + vResult.setResultStatus(ResultStatuses.success.getKey()); + } else { + vResult.setResultStatus(ResultStatuses.notSuccess.getKey()); + } + } + } + } + + // 2.1 Номера торговых/клиринговых счетов, соответствующие загруженным в КС + // -sDf01.deal = account.account & accountType=CLRN & accountStatus=UNBL + { +// Map indexSDf01 = index(allSDf01, SDf01::getDeal); + Set sDf01Keys = allSDf01.stream() + .filter(sdf01 -> sdf01.getDeal() != null) + .map(sdf01 -> sdf01.getDeal()) + .collect(Collectors.toSet()); + Set accountKeys = allAccount.stream() + .filter(account -> AccountType.Clrn.equalsByKey(account.getAccountType()) && "UNBL".equals(account.getAccountStatus())) + .map(sdf01 -> sdf01.getAccount()) + .collect(Collectors.toSet()); + boolean isOk = sDf01Keys.size() == accountKeys.size() && + sDf01Keys.containsAll(accountKeys) && accountKeys.containsAll(sDf01Keys); +// for (Account account:allAccount) { +// if (AccountType.Clrn.equalsByKey(account.getAccountType()) & "UNBL".equals(account.getAccountStatus())) { +// // todo use enum/const ? +// SDf01 document = indexSDf01.get(account.getAccount()); +// if (document == null) { +// //todo найдено несоответствие. +// } else { +// } +// } +// } + } + + // 2.2 Количество торговых/клиринговых счетов, соответствующие загруженным в КС - COUNT[sDf01.deal] = COUNT [account.account] + { + long countSDf01 = allSDf01.stream().filter(sDf01 -> sDf01.getDeal() != null).count(); + long countAccount = allAccount.stream().filter(account -> account.getAccount() != null).count(); + log.info("countSDf01={}, countAccount={}", countSDf01 ,countAccount); + //todo countSDf01 != countAccount + } + + // 2.3 Суммарный остаток по счетам + { + //todo не понял условия [sDf01.account = accountBalance.account] + long summSDf01 = 0; + for (SDf01 document : allSDf01) { + if (StringUtils.isEmpty(document.getRemainder())) { + try { + long value = Long.parseLong(document.getRemainder()); + summSDf01 += value; + } catch (NumberFormatException nfe) { + log.warn("SDf01[{}].remainder=\"{}\" is not parseable: {}", + document.getId(), document.getRemainder(), nfe.getMessage()); + } + } else { + log.debug("SDf01[{}].remainder is null or empty", document.getId()); + } + } + long summAccount = 0; + for (AccountBalance account : allAccountBalance) { + if (account.getCloseBalanceAmount() != null) { + long value = account.getCloseBalanceAmount().longValue(); + summAccount += value; + } + } + // todo summSDf01==summAccount теперь с точностью и погрешностью сравнений проблема. + } + + // 3. Сверка остатков по клиринговым счетам СПВБ + { + //todo не понял [sDf01.account = accountBalance.account & accountType=INFO] + } + } + + + protected void onSuccessRevisionResult() { + //todo 17.1 - Сообщение пользователю об успешной сверке + } + + protected void onDetectDiffRevisionResult() { + //todo 17.2 - Сообщение пользователю в случае выявления расхождений + } + + /* + Сумму по остаткам в бизнес-объекте accountBalance - sDf01.remainder = accountBalance.closeBalanceAmount [sDf01.account = accountBalance.account] + 2. Расчет контрольных сумм: + 2.1 Номера торговых/клиринговых счетов, соответствующие загруженным в КС -sDf01.deal = account.account & accountType=CLRN & accountStatus=UNBL + 2.2 Количество торговых/клиринговых счетов, соответствующие загруженным в КС - COUNT[sDf01.deal] = COUNT [account.account] + 2.3 Суммарный остаток по счетам - ∑sDf01.remainder = ∑accountBalance.closeBalanceAmount[sDf01.account = accountBalance.account] + 3. Сверка остатков по клиринговым счетам СПВБ в бизнес-объекте accountBalance - sDf01.remainder = accountBalance.closeBalanceAmount [sDf01.account = accountBalance.account & accountType=INFO] + */ + + + Map index(Collection from, Function indexFieldExtractor) { + Map index = new HashMap<>(); + for (V obj : from) { + K key = indexFieldExtractor.apply(obj); + V exist = index.put(key, obj); + if (exist != null) { + log.warn("{} with id={},{} has duplicate Account=\"{}\"", + exist.getClass().getSimpleName(), exist.getId(), obj.getId(), key); + } + } + return index; + } + + //todo to classes: VerificationResult! + static class VerificationResult extends BusinessObject { + private String clearingCode; // type="2" + private Long accountId; // type="1" + private BigDecimal inSum; // type="11" + private BigDecimal outIntSum; // type="11" + private BigDecimal outExtSum; // type="11" + private BigDecimal diffSum; // type="11" + private Long generationId; // type="1" + private String generationStatus; // type="12" + private String resultStatus; // type="12" + + public String getClearingCode() { + return clearingCode; + } + + public void setClearingCode(String clearingCode) { + this.clearingCode = clearingCode; + } + + public Long getAccountId() { + return accountId; + } + + public void setAccountId(Long accountId) { + this.accountId = accountId; + } + + public BigDecimal getInSum() { + return inSum; + } + + public void setInSum(BigDecimal inSum) { + this.inSum = inSum; + } + + public BigDecimal getOutIntSum() { + return outIntSum; + } + + public void setOutIntSum(BigDecimal outIntSum) { + this.outIntSum = outIntSum; + } + + public BigDecimal getOutExtSum() { + return outExtSum; + } + + public void setOutExtSum(BigDecimal outExtSum) { + this.outExtSum = outExtSum; + } + + public BigDecimal getDiffSum() { + return diffSum; + } + + public void setDiffSum(BigDecimal diffSum) { + this.diffSum = diffSum; + } + + public Long getGenerationId() { + return generationId; + } + + public void setGenerationId(Long generationId) { + this.generationId = generationId; + } + + public String getGenerationStatus() { + return generationStatus; + } + + public void setGenerationStatus(String generationStatus) { + this.generationStatus = generationStatus; + } + + public String getResultStatus() { + return resultStatus; + } + + public void setResultStatus(String resultStatus) { + this.resultStatus = resultStatus; + } + } + +} diff --git a/clearing-parent/dbf-exporter/src/main/java/ru/spcex/clearing/dbf/exporter/services/converters/S_DF08_Converter.java b/clearing-parent/dbf-exporter/src/main/java/ru/spcex/clearing/dbf/exporter/services/converters/S_DF08_Converter.java index 48bfbd4f9..62db8cea1 100644 --- a/clearing-parent/dbf-exporter/src/main/java/ru/spcex/clearing/dbf/exporter/services/converters/S_DF08_Converter.java +++ b/clearing-parent/dbf-exporter/src/main/java/ru/spcex/clearing/dbf/exporter/services/converters/S_DF08_Converter.java @@ -13,17 +13,21 @@ public class S_DF08_Converter extends DFConverter { @Override public Object[] toObjectArray(SDf08 entity) { List values = new LinkedList<>(); - values.add(typeMatch(entity.getNumber())); - values.add(typeMatch(entity.getDatetime())); + values.add(convertStrToLong(entity.getNumber())); + values.add(convertStrToLong(entity.getDatetime())); return values.toArray(Object[]::new); } @Override public DBFField[] getDBFHeaders() { List dbfFields = new LinkedList<>(); - dbfFields.add(new DBFField("NUMBER", DBFDataType.NUMERIC, 32, 18)); - dbfFields.add(new DBFField("DATETIME", DBFDataType.DATE)); + dbfFields.add(new DBFField("NUMBER", DBFDataType.NUMERIC, 10)); + dbfFields.add(new DBFField("DATETIME", DBFDataType.NUMERIC, 13)); return dbfFields.toArray(DBFField[]::new); } + private Long convertStrToLong(String s) { + if (s == null) return null; + return Long.valueOf(s); + } } 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/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/services/AbstractHazelcastLifecycleSupport.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/services/AbstractHazelcastLifecycleSupport.java index e55d066a8..53a6dd15a 100644 --- a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/services/AbstractHazelcastLifecycleSupport.java +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/services/AbstractHazelcastLifecycleSupport.java @@ -83,16 +83,20 @@ public abstract class AbstractHazelcastLifecycleSupport implements InitializingB return maxKey; }); } + long maxKey = 0L; int threadCount = Runtime.getRuntime().availableProcessors();// todo config * Config.get().getRoot().getSettings().getInitHazelcastThreadMultiplier(); log.info("Initializing threads count = {}", threadCount); ExecutorService executor = Executors.newWorkStealingPool(threadCount); - List> results = executor.invokeAll(tasks); - long maxKey = 0L; - for (Future result : results) { - Long maxKeyResult = result.get(); - if (maxKeyResult != null) { - maxKey = Math.max(maxKey, maxKeyResult); + try { + List> results = executor.invokeAll(tasks); + for (Future result : results) { + Long maxKeyResult = result.get(); + if (maxKeyResult != null) { + maxKey = Math.max(maxKey, maxKeyResult); + } } + } finally { + executor.shutdown(); } IdGenerator generator = hazelcastServerInstance.getIdGenerator(IMDGDistributedNames.MAP_SEQUENCE_NAME); diff --git a/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/UserService.java b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/UserService.java index 5f7c95189..000a4f36e 100644 --- a/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/UserService.java +++ b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/UserService.java @@ -28,6 +28,7 @@ import java.time.LocalDate; import java.util.Collection; import java.util.Collections; import java.util.Map; +import java.util.Objects; import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -121,10 +122,28 @@ public class UserService extends QueueConsumer implements InitializingBean { UserAuthRequest authInfo = authEvent.getRequestPayload(); log.debug("user name={} authenticated", authInfo.getUsername()); UserInfo userInfo = createUserIfNeeded(authInfo.getUsername()); + updatePersonalInfoIfNeeded(userInfo, authInfo.getEmail(), authInfo.getName(), authInfo.getSurname(), authInfo.getMiddleName()); changeRoles(userInfo.userId, userInfo.isNew, authInfo.getRoles()); connected(userInfo.userId, authInfo.getTime(), authInfo.getClientIp(), authInfo.getServerIp()); } + private void updatePersonalInfoIfNeeded(UserInfo userInfo, String email, String name, String surname, String middleName) { + User user = userInfo.user; + if (!Objects.equals(user.getEmail(), email) + || !Objects.equals(user.getName(), name) + || !Objects.equals(user.getLastName(), surname) + || !Objects.equals(user.getMiddleName(), middleName)) { + user.setEmail(email); + user.setName(name); + user.setLastName(surname); + user.setMiddleName(middleName); + if (!userInfo.isNew) { + user.setUpdated(Instant.now()); + } + userMap.update(user); + } + } + private void usersLogoutSuccess(BaseRequest logoutEvent) { UserLogoutRequest logoutInfo = logoutEvent.getRequestPayload(); log.debug("user name={} logout", logoutInfo.getUsername()); @@ -152,9 +171,9 @@ public class UserService extends QueueConsumer implements InitializingBean { user.setCreated(Instant.now()); user.setIdentifier(username); userMap.insert(user); - return new UserInfo(true, user.getId()); + return new UserInfo(true, user.getId(), user); } else { - return new UserInfo(false, user.getId()); + return new UserInfo(false, user.getId(), user); } } @@ -223,10 +242,12 @@ public class UserService extends QueueConsumer implements InitializingBean { private static class UserInfo { boolean isNew; Long userId; + User user; - public UserInfo(boolean isNew, Long userId) { + public UserInfo(boolean isNew, Long userId, User user) { this.isNew = isNew; this.userId = userId; + this.user = user; } } } diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/ResultStatuses.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/ResultStatuses.java new file mode 100644 index 000000000..54660b5ce --- /dev/null +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/ResultStatuses.java @@ -0,0 +1,22 @@ +package ru.spcex.platform.enumeration; + +import ru.spcex.platform.utils.enumeration.IEnumKey; + +/** + * ResultStatusDictionary + */ +public enum ResultStatuses implements IEnumKey { + notSuccess("NACK"), // Неуспешно + success("ACK"); // Успешно + + private final String key; + + ResultStatuses(String key) { + this.key = key; + } + + @Override + public String getKey() { + return key; + } +} 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 80fd2eb00..055c72b9b 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 @@ -59,7 +59,7 @@ public final class IMDGDistributedNames { public static final String Map_SDf12 = "Map_SDf12"; public static final String Map_SDf18 = "Map_SDf18"; public static final String Map_AllowedDictionary = "Map_AllowedDictionary"; - public static final String Map_ClearingCategoryDictionary = "Map_ClearingMemberCategoryDictionary"; + public static final String Map_ClearingCategoryDictionary = "Map_ClearingCategoryDictionary"; public static final String Map_CompanyRoleDictionary = "Map_CompanyRoleDictionary"; public static final String Map_CompanySymbolDictionary = "Map_CompanySymbolDictionary"; public static final String Map_ContactTypeDictionary = "Map_ContactTypeDictionary"; diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/utilities/UserAuthRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/utilities/UserAuthRequest.java index 9cbd07989..1b0754f13 100644 --- a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/utilities/UserAuthRequest.java +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/utilities/UserAuthRequest.java @@ -23,6 +23,15 @@ public class UserAuthRequest { private String serverIp; @JsonProperty private String clientIp; + @JsonProperty + private String email; + @JsonProperty + private String name; + @JsonProperty + private String surname; + @JsonProperty + private String middleName; + public String getUsername() { return username; @@ -63,4 +72,36 @@ public class UserAuthRequest { public void setClientIp(String clientIp) { this.clientIp = clientIp; } + + public String getEmail() { + return email; + } + + public void setEmail(String email) { + this.email = email; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getSurname() { + return surname; + } + + public void setSurname(String surname) { + this.surname = surname; + } + + public String getMiddleName() { + return middleName; + } + + public void setMiddleName(String middleName) { + this.middleName = middleName; + } } diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/service/QueueConsumer.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/service/QueueConsumer.java index 1ecdd1625..2730b70a5 100644 --- a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/service/QueueConsumer.java +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/service/QueueConsumer.java @@ -157,8 +157,11 @@ public class QueueConsumer implements AutoCloseable { @Override public void close() { + log.debug("Closing queue consumer {}", getClass().getSimpleName()); closed.set(true); consumer.wakeup(); + inputExecutor.shutdown(); + outputExecutor.shutdown(); }