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

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

Browse source
This commit is contained in:
ialbert 2022-12-30 16:52:05 +03:00
parent fddb65868c
commit e46835696f
31 changed files with 1210 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountBalanceController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/CompanyRoleSetController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_CompanyRoleSet,
CompanyRoleSet.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

17
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/RelationController.java
View file

@ -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<Map<String, Object>> 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)

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/execution/ExecutionDepositController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_ExecutionDeposit,
ExecutionDeposit.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/InDocumentJournalController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_InDocumentJournal,
InDocumentJournal.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/ManagementJournalController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_ManagementJournal,
ManagementJournal.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/OutDocumentJournalController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_OutDocumentJournal,
OutDocumentJournal.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsAssetController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_LiabilitiesClaimsAssets,
LiabilitiesClaimsAssets.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsMoneyController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_LiabilitiesClaimsMoney,
LiabilitiesClaimsMoney.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

43
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/CurrencyController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_Currency, Currency.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

43
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ErrorTextController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_ErrorText, ErrorText.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

43
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/MarketController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_Market, Market.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

2
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/payment/PaymentInstructionController.java
View file

@ -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;

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/AdmittedDealRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_AdmittedDealRegister,
AdmittedDealRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/BalanceRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_BalanceRegister,
BalanceRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ClearMemberRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_ClearMemberRegister,
ClearMemberRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ContractRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_ContractRegister,
ContractRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/CoveredDealRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_CoveredDealRegister,
CoveredDealRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/DealRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_DealRegister,
DealRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/OrderRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_OrderRegister,
OrderRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ReportRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_ReportRegister,
ReportRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

44
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/UncoveredDealRegisterController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(
IMDGDistributedNames.Map_UncoveredDealRegister,
UncoveredDealRegister.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

40
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/InformationAccountController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_InformationAccount,
InformationAccount.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

41
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java Normal file
View file

@ -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<Map<String, Object>> all = stateLoader.getAllMetaTransformSpecificClass(
IMDGDistributedNames.Map_MoneyMarketSecurity,
Security.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

73
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/StatementController.java Normal file
View file

@ -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<Map<String, Object>> 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> 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<String, Object> extractedByMeta = responseMetaFactory.responseFromObject(stmt);
response.fromEntity(extractedByMeta);
return response;
}
}

42
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetByIdResponse.java Normal file
View file

@ -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<String, Object> object = new HashMap<>();
public Map<String, Object> getObject() {
return object;
}
public void setObject(Map<String, Object> object) {
this.object = object;
}
}
public GetByIdCommonPayload getPayload() {
return payload;
}
public void setPayload(GetByIdCommonPayload payload) {
this.payload = payload;
}
public void fromEntity(Map<String, Object> anyObjectFields) {
var payload = this.getPayload();
payload.setObject(anyObjectFields);
}
}

21
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java
View file

@ -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 <T> Collection<Map<String, Object>> responseFromObjectCollection(Collection<?> o, Class<T> clazz) {
return o.stream()
.map((Function<Object, Map<String, Object>>) o1 -> responseFromObject(o1, clazz))
.collect(Collectors.toList());
}
public <T> Map<String, Object> responseFromObject(Object o, Class<T> 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<String, Object> responseFromObjectExtracted(Object o, ObjectExtracted objExtr) {
Map<String, Object> r = new LinkedHashMap<>();
FieldExtracted currentField = null;

1
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java
View file

@ -13,5 +13,6 @@ public interface IStateLoader {
<T extends SpcexObjectBase> Optional<T> getById(Long id, String mapName, Class<T> clazz);
<T extends SpcexObjectBase> Collection<T> getAll(String mapName, Class<T> clazz);
<T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz);
<T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransformSpecificClass(String mapName, Class<T> clazz);
<T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz, Map<String, ? extends Comparable<?>> conditions);
}

6
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java
View file

@ -44,6 +44,12 @@ public class StateLoaderImpl implements IStateLoader {
return responseFactory.responseFromObjectCollection(all);
}
@Override
public <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransformSpecificClass(String mapName, Class<T> clazz) {
Collection<T> all = getAll(mapName, clazz);
return responseFactory.responseFromObjectCollection(all, clazz);
}
@Override
public <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName,
Class<T> clazz,

95
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/LiabilitiesClaimsMoneyMapStore.java Normal file
View file

@ -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<LiabilitiesClaimsMoney> {
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;
}
}

1
platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java
View file

@ -108,6 +108,7 @@ public final class IMDGDistributedNames {
public static final String Map_Session = "Map_Session";
public static final String Map_Notification = "Map_Notification";
public static final String Map_LiabilitiesClaimsAssets = "Map_LiabilitiesClaimsAssets";
public static final String Map_LiabilitiesClaimsMoney = "Map_LiabilitiesClaimsMoney";
public static final String Map_ClearMemberRegister = "Map_ClearMemberRegister";
public static final String Map_BalanceRegister = "Map_BalanceRegister";
public static final String Map_ExecutionDeposit = "Map_ExecutionDeposit";