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

Merge branch 'dev' into report_25_26_29

Browse source
This commit is contained in:
AKurakin 2023-01-10 19:08:12 +03:00
commit 324a1546c4
44 changed files with 1713 additions and 25 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;
}
}

26
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java
View file

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

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);
}
}

36
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/user/UserIdResponse.java Normal file
View file

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

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;

15
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/security/handlers/AuthAuditSuccessLoginHandler.java
View file

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

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);
}

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

@ -33,7 +33,8 @@ public class UserAuthProcessor {
this.operator = operator;
}
public void sendAuthSuccessEvent(String identifier, Collection<String> roles, String userIp, String serverIp) {
public void sendAuthSuccessEvent(String identifier, Collection<String> 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

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,

19
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/ClearingService.java
View file

@ -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();
}
}

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

@ -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();
}
}

299
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/VerificationResultComponent.java Normal file
View file

@ -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<SDf01> sdf01Imdg;
private Imdg<AccountBalance> accountBalanceImdg;
private Imdg<Account> 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<SDf01> allSDf01 = sdf01Imdg.getAllValues();
Collection<AccountBalance> allAccountBalance = accountBalanceImdg.getAllValues();
Collection<Account> allAccount = accountImdg.getAllValues();
executeRevision(allSDf01, allAccountBalance, allAccount);
//todo результат logic... см. как было в корпе?
}
protected void executeRevision(Collection<SDf01> allSDf01, Collection<AccountBalance> allAccountBalance, Collection<Account> allAccount) {
// 1. Сумму по остаткам
List<Object/*verificationResult*/> vResLst = new ArrayList<>();
/* todo use:
<verificationResult name="Результаты сверки" destination="verification-results" class="com.spicex.Static." table="verification_result">
<clearingCode type="2" length="255" name="Код участника клиринга" shortname="Клиринговый код" searchable="true" sortable="true" visible="true"/>
<accountId type="1" name="Счет УК, по которому проводится сверка" shortname="Счет УК" searchable="true" sortable="true"/>
<inSum type="11" name="Входящая сумма остатков" shortname="Остатки" visible="true" searchable="true" sortable="true"/>
<outIntSum type="11" name="Исходящая сумма остатков, полученная в КС" shortname="Остатки, полученные в КС" visible="true" searchable="true" sortable="true"/>
<outExtSum type="11" name="Исходящая сумма остатков из отчета ПРЦ" shortname="Остатки, полученные из ПРЦ" visible="true" searchable="true" sortable="true"/>
<diffSum type="11" name="Сумма расхождений" shortname="Сумма расхождений" visible="true" searchable="true" sortable="true"/>
<generationId type="1" name="Идентификатор взаимодействия" shortname="ID взаимодействия" searchable="true" sortable="true"/>
<generationStatus type="12" name="Общий статус сверки" shortname="Статус" searchable="true" sortable="true" visible="true" link="resultStatus"/>
<resultStatus type="12" name="Статус сверки" shortname="Статус" searchable="true" sortable="true" visible="true" link="resultStatus"/>
<id type="1" name="Идентификатор записи" shortname="ID" searchable="true" sortable="true"/>
<createdAt type="4" name="Дата и время создания записи" shortname="Создано" searchable="true" sortable="true" ignore="true"/>
<updatedAt type="4" name="Дата и время изменения записи" shortname="Изменено" searchable="true" sortable="true" ignore="true"/>
</verificationResult>
*/
{
Map<String, SDf01> 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<String, SDf01> indexSDf01 = index(allSDf01, SDf01::getDeal);
Set<String> sDf01Keys = allSDf01.stream()
.filter(sdf01 -> sdf01.getDeal() != null)
.map(sdf01 -> sdf01.getDeal())
.collect(Collectors.toSet());
Set<String> 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]
*/
<K, V extends WithId> Map<K, V> index(Collection<V> from, Function<V, K> indexFieldExtractor) {
Map<K, V> 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;
}
}
}

12
clearing-parent/dbf-exporter/src/main/java/ru/spcex/clearing/dbf/exporter/services/converters/S_DF08_Converter.java
View file

@ -13,17 +13,21 @@ public class S_DF08_Converter extends DFConverter<SDf08> {
@Override
public Object[] toObjectArray(SDf08 entity) {
List<Object> 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<DBFField> 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);
}
}

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

16
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/services/AbstractHazelcastLifecycleSupport.java
View file

@ -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<Future<Long>> results = executor.invokeAll(tasks);
long maxKey = 0L;
for (Future<Long> result : results) {
Long maxKeyResult = result.get();
if (maxKeyResult != null) {
maxKey = Math.max(maxKey, maxKeyResult);
try {
List<Future<Long>> results = executor.invokeAll(tasks);
for (Future<Long> 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);

27
clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/UserService.java
View file

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

22
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/ResultStatuses.java Normal file
View file

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

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

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

41
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/utilities/UserAuthRequest.java
View file

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

3
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/service/QueueConsumer.java
View file

@ -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();
}