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

http://jira.mfd.msk:8088/browse/CLS-293 meta 4: зачистка удаляемых объектов

Browse source
This commit is contained in:
AKurakin 2023-05-10 18:48:16 +03:00
parent d0d59ba582
commit d9fa17b0c7
92 changed files with 23 additions and 6470 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1,40 +0,0 @@
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;
@Deprecated
@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/liabilities/LiabilitiesClaimsAssetController.java
View file

@ -1,44 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.liabilities;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
import ru.spcex.clearing.backendapi.service.IOperator;
import ru.spcex.clearing.backendapi.service.IStateLoader;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.util.Collection;
import java.util.Map;
@Controller
@RequestMapping("/liabilities-claims-assets")
public class LiabilitiesClaimsAssetController extends AbstractQueueController {
private final IStateLoader stateLoader;
@Autowired
public LiabilitiesClaimsAssetController(IOperator operator, IStateLoader stateLoader) {
super(operator);
this.stateLoader = stateLoader;
}
@ApiOperation(value = "get all LiabilitiesClaimsAssets.")
@ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
@RequestMapping(method = RequestMethod.GET)
@ResponseBody
public CommonGetAllResponse getAll() {
Collection<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
View file

@ -1,44 +0,0 @@
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;
}
}

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

@ -1,44 +0,0 @@
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
View file

@ -1,44 +0,0 @@
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
View file

@ -1,44 +0,0 @@
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/CoveredDealRegisterController.java
View file

@ -1,44 +0,0 @@
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
View file

@ -1,44 +0,0 @@
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
View file

@ -1,44 +0,0 @@
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/UncoveredDealRegisterController.java
View file

@ -1,44 +0,0 @@
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;
}
}

83
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/CudKeyRateController.java
View file

@ -1,83 +0,0 @@
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.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import ru.clearing.classes.statics.data.misc.KeyRate;
import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
import ru.spcex.clearing.backendapi.controller.request.cud.utilities.KeyRateNewAction;
import ru.spcex.clearing.backendapi.controller.request.cud.utilities.KeyRateUpdateAction;
import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
import ru.spcex.clearing.backendapi.service.IOperator;
import ru.spcex.clearing.backendapi.service.IStateLoader;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ExecutionException;
@Controller
@RequestMapping("/utilities/key-rates")
public class CudKeyRateController extends AbstractQueueController {
private final IStateLoader stateLoader;
@Autowired
public CudKeyRateController(IOperator operator, IStateLoader stateLoader) {
super(operator);
this.stateLoader = stateLoader;
}
@ApiOperation(value = "create key rate.")
@ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
@RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public CudResponse add(
@ApiParam(value = "Параметры команды в JSON формате.", required = true)
@RequestBody KeyRateNewAction keyRateNewAction) throws ExecutionException, InterruptedException {
return processRequest(Consts.DESTINATION_KEY_RATE_NEW, keyRateNewAction);
}
@ApiOperation(value = "update key rate.")
@ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
@RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public CudResponse update(
@ApiParam(value = "Идентификатор изменяемого объекта.", required = true, example = "1234")
@PathVariable("id") Long id,
@ApiParam(value = "Новые значения полей объекта.", required = true)
@RequestBody KeyRateUpdateAction keyRateUpdateAction) throws ExecutionException, InterruptedException {
keyRateUpdateAction.setId(id);
return processRequest(Consts.DESTINATION_KEY_RATE_UPDATE, keyRateUpdateAction);
}
@ApiOperation(value = "delete key rate.")
@ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
@ResponseBody
public CudResponse delete(@ApiParam(value = "Идентификатор удаляемого объекта", required = true, example = "1234")
@PathVariable("id") Long id) throws ExecutionException, InterruptedException {
CommonDeleteAction deleteAction = new CommonDeleteAction();
deleteAction.setId(id);
return processRequest(Consts.DESTINATION_KEY_RATE_DELETE, deleteAction);
}
@ApiOperation(value = "get all KeyRate'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_KeyRate, KeyRate.class);
CommonGetAllResponse response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

92
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/KeyRateNewAction.java
View file

@ -1,92 +0,0 @@
package ru.spcex.clearing.backendapi.controller.request.cud.utilities;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import io.swagger.annotations.ApiModelProperty;
import ru.spcex.clearing.backendapi.domain.actions.IAction;
import ru.spcex.clearing.backendapi.errors.BackEndError;
import ru.spcex.clearing.platform.messaging.domain.ActionType;
import ru.spcex.clearing.platform.messaging.domain.cud.utilities.KeyRateNewRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class KeyRateNewAction implements IAction<KeyRateNewRequest> {
@ApiModelProperty(value = "Ключевая ставка ЦБ РФ", example = "12.5")
@JsonProperty
public BigDecimal rate;
@ApiModelProperty(value = "Дата начала действия ключевой ставки", example = "2022-01-20")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate startDate;
@ApiModelProperty(value = "Дата окончания действия ключевой ставки", example = "2022-04-20")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate endDate;
@ApiModelProperty(value = "Документ ЦБ", example = "Lorem ipsum")
@JsonProperty
public String document;
@Override
public Collection<EnumMessage> validate() {
if (this.startDate == null)
return List.of(new EnumMessage(BackEndError.ValidationError, "startDate"));
else return Collections.emptyList();
}
@ApiModelProperty(hidden = true)
@Override
public ActionType getActionType() {
return ActionType.NEW;
}
@Override
public KeyRateNewRequest toRequest() {
var req = new KeyRateNewRequest();
req.setStartDate(this.getStartDate());
req.setEndDate(this.getEndDate());
req.setKeyRate(this.getRate());
req.setDocument(this.getDocument());
return req;
}
public BigDecimal getRate() {
return rate;
}
public void setRate(BigDecimal rate) {
this.rate = rate;
}
public LocalDate getStartDate() {
return startDate;
}
public void setStartDate(LocalDate startDate) {
this.startDate = startDate;
}
public LocalDate getEndDate() {
return endDate;
}
public void setEndDate(LocalDate endDate) {
this.endDate = endDate;
}
public String getDocument() {
return document;
}
public void setDocument(String document) {
this.document = document;
}
}

92
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/KeyRateUpdateAction.java
View file

@ -1,92 +0,0 @@
package ru.spcex.clearing.backendapi.controller.request.cud.utilities;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import io.swagger.annotations.ApiModelProperty;
import ru.spcex.clearing.backendapi.domain.actions.IAction;
import ru.spcex.clearing.platform.messaging.domain.ActionType;
import ru.spcex.clearing.platform.messaging.domain.cud.utilities.KeyRateUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import java.math.BigDecimal;
import java.time.LocalDate;
public class KeyRateUpdateAction implements IAction<KeyRateUpdateRequest> {
@ApiModelProperty(hidden = true)
@JsonProperty
public Long id;
@ApiModelProperty(value = "Ключевая ставка ЦБ РФ", example = "12.5")
@JsonProperty
public BigDecimal rate;
@ApiModelProperty(value = "Дата начала действия ключевой ставки", example = "2022-01-20")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate startDate;
@ApiModelProperty(value = "Дата окончания действия ключевой ставки", example = "2022-04-20")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate endDate;
@ApiModelProperty(value = "Документ ЦБ", example = "Lorem ipsum")
@JsonProperty
public String document;
@ApiModelProperty(hidden = true)
@Override
public ActionType getActionType() {
return ActionType.UPDATE;
}
@Override
public KeyRateUpdateRequest toRequest() {
var req = new KeyRateUpdateRequest();
req.setId(this.getId());
req.setStartDate(this.getStartDate());
req.setEndDate(this.getEndDate());
req.setKeyRate(this.getRate());
req.setDocument(this.getDocument());
return req;
}
public BigDecimal getRate() {
return rate;
}
public void setRate(BigDecimal rate) {
this.rate = rate;
}
public LocalDate getStartDate() {
return startDate;
}
public void setStartDate(LocalDate startDate) {
this.startDate = startDate;
}
public LocalDate getEndDate() {
return endDate;
}
public void setEndDate(LocalDate endDate) {
this.endDate = endDate;
}
public String getDocument() {
return document;
}
public void setDocument(String document) {
this.document = document;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}

54
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/utilities/KeyRateBackendGetAll.java
View file

@ -1,54 +0,0 @@
package ru.spcex.clearing.backendapi.controller.response.entity.utilities;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import ru.clearing.classes.statics.data.misc.KeyRate;
import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@ApiModel(description = "Ответ при получении объектов KeyRate.")
public class KeyRateBackendGetAll extends BasicSpcexResponse {
@JsonProperty
@ApiModelProperty(value = "Полезная нагрузка")
private KeyRateBackendPayload payload = new KeyRateBackendPayload();
private static class KeyRateBackendPayload {
private List<KeyRateBackendGetFields> items = new ArrayList<>();
public List<KeyRateBackendGetFields> getItems() {
return items;
}
public void setItems(List<KeyRateBackendGetFields> items) {
this.items = items;
}
}
public KeyRateBackendPayload getPayload() {
return payload;
}
public void setPayload(KeyRateBackendPayload payload) {
this.payload = payload;
}
public void fromEntity(Collection<KeyRate> keyRates) {
var payload = this.getPayload();
for (var keyRate : keyRates) {
var singleItem = new KeyRateBackendGetFields();
singleItem.setId(keyRate.getId());
singleItem.setKeyRate(keyRate.getRate());
singleItem.setStartDate(keyRate.getStartDate());
singleItem.setEndDate(keyRate.getEndDate());
singleItem.setDocument(keyRate.getDocument());
singleItem.setWorkflowStatus(keyRate.getWorkflowStatus());
payload.getItems().add(singleItem);
}
}
}

73
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/utilities/KeyRateBackendGetFields.java
View file

@ -1,73 +0,0 @@
package ru.spcex.clearing.backendapi.controller.response.entity.utilities;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import java.math.BigDecimal;
import java.time.LocalDate;
public class KeyRateBackendGetFields {
@JsonProperty
private Long id;
@JsonProperty
private BigDecimal keyRate;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonProperty
private LocalDate startDate;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonProperty
private LocalDate endDate;
@JsonProperty
private String document;
@JsonProperty
private String workflowStatus;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public BigDecimal getKeyRate() {
return keyRate;
}
public void setKeyRate(BigDecimal keyRate) {
this.keyRate = keyRate;
}
public LocalDate getStartDate() {
return startDate;
}
public void setStartDate(LocalDate startDate) {
this.startDate = startDate;
}
public LocalDate getEndDate() {
return endDate;
}
public void setEndDate(LocalDate endDate) {
this.endDate = endDate;
}
public String getDocument() {
return document;
}
public void setDocument(String document) {
this.document = document;
}
public String getWorkflowStatus() {
return workflowStatus;
}
public void setWorkflowStatus(String workflowStatus) {
this.workflowStatus = workflowStatus;
}
}

14
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/AbstractControllerTest.java
View file

@ -35,8 +35,6 @@ import ru.spcex.clearing.backendapi.controller.queue.execution.ExecutionFondCont
import ru.spcex.clearing.backendapi.controller.queue.journal.InDocumentJournalController; import ru.spcex.clearing.backendapi.controller.queue.journal.InDocumentJournalController;
import ru.spcex.clearing.backendapi.controller.queue.journal.ManagementJournalController; import ru.spcex.clearing.backendapi.controller.queue.journal.ManagementJournalController;
import ru.spcex.clearing.backendapi.controller.queue.journal.OutDocumentJournalController; import ru.spcex.clearing.backendapi.controller.queue.journal.OutDocumentJournalController;
import ru.spcex.clearing.backendapi.controller.queue.liabilities.LiabilitiesClaimsAssetController;
import ru.spcex.clearing.backendapi.controller.queue.liabilities.LiabilitiesClaimsMoneyController;
import ru.spcex.clearing.backendapi.controller.queue.misc.*; import ru.spcex.clearing.backendapi.controller.queue.misc.*;
import ru.spcex.clearing.backendapi.controller.queue.payment.PaymentInstructionController; import ru.spcex.clearing.backendapi.controller.queue.payment.PaymentInstructionController;
import ru.spcex.clearing.backendapi.controller.queue.register.*; import ru.spcex.clearing.backendapi.controller.queue.register.*;
@ -45,7 +43,6 @@ import ru.spcex.clearing.backendapi.controller.queue.scheduler.*;
import ru.spcex.clearing.backendapi.controller.queue.securities.*; import ru.spcex.clearing.backendapi.controller.queue.securities.*;
import ru.spcex.clearing.backendapi.controller.queue.user.UserController; import ru.spcex.clearing.backendapi.controller.queue.user.UserController;
import ru.spcex.clearing.backendapi.controller.queue.user.UserRoleSessionController; import ru.spcex.clearing.backendapi.controller.queue.user.UserRoleSessionController;
import ru.spcex.clearing.backendapi.controller.queue.utilities.CudKeyRateController;
import ru.spcex.clearing.backendapi.controller.queue.utilities.StatementController; import ru.spcex.clearing.backendapi.controller.queue.utilities.StatementController;
import ru.spcex.clearing.backendapi.controller.queue.utilities.UserSettingsController; import ru.spcex.clearing.backendapi.controller.queue.utilities.UserSettingsController;
import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction; import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
@ -85,7 +82,6 @@ import static ru.spcex.clearing.test.json.MatcherFactoryWithJson.usingIgnoringFi
@ContextConfiguration(classes = { @ContextConfiguration(classes = {
//account //account
AccountBalanceController.class,
AccountController.class, AccountController.class,
BankAccountController.class, BankAccountController.class,
ClearingAccountController.class, ClearingAccountController.class,
@ -109,8 +105,6 @@ import static ru.spcex.clearing.test.json.MatcherFactoryWithJson.usingIgnoringFi
ManagementJournalController.class, ManagementJournalController.class,
OutDocumentJournalController.class, OutDocumentJournalController.class,
//liabilities //liabilities
LiabilitiesClaimsAssetController.class,
LiabilitiesClaimsMoneyController.class,
//misc //misc
CurrencyController.class, CurrencyController.class,
ErrorTextController.class, ErrorTextController.class,
@ -121,15 +115,8 @@ import static ru.spcex.clearing.test.json.MatcherFactoryWithJson.usingIgnoringFi
//payment //payment
PaymentInstructionController.class, PaymentInstructionController.class,
//register //register
AdmittedDealRegisterController.class,
BalanceRegisterController.class,
ClearMemberRegisterController.class,
ContractRegisterController.class, ContractRegisterController.class,
CoveredDealRegisterController.class,
DealRegisterController.class,
OrderRegisterController.class,
ReportRegisterController.class, ReportRegisterController.class,
UncoveredDealRegisterController.class,
//registry //registry
TradingClearingRegistryController.class, TradingClearingRegistryController.class,
//scheduler //scheduler
@ -150,7 +137,6 @@ import static ru.spcex.clearing.test.json.MatcherFactoryWithJson.usingIgnoringFi
UserController.class, UserController.class,
UserRoleSessionController.class, UserRoleSessionController.class,
//utilities //utilities
CudKeyRateController.class,
StatementController.class, StatementController.class,
UserSettingsController.class, UserSettingsController.class,
//******* common configs ******* //******* common configs *******

29
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountBalanceControllerTest.java
View file

@ -1,29 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.account;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.account.AccountBalance;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
@Deprecated
class AccountBalanceControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/account-balances/";
/**
* {@link AccountBalanceController#getAll()} <br>
* Тест проверяет получение запроса по REST API и отправку всех записей из таблицы hazelcast Map_BankAccount.<br>
* Входной запрос /account-balances/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
AccountBalance existBankAccount = new AccountBalance();
existBankAccount.setAccountType("99");
existBankAccount.setAccount("123456789123");
existBankAccount.setId(currentId.get());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_AccountBalance, existBankAccount, REST_URL);
}
}

53
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsAssetControllerTest.java
View file

@ -1,53 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.liabilities;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.math.BigDecimal;
import java.time.LocalDate;
class LiabilitiesClaimsAssetControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/liabilities-claims-assets/";
/**
* {@link LiabilitiesClaimsAssetController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /liabilities-claims-assets/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
LiabilitiesClaimsAssets liabilitiesClaimsAssets = new LiabilitiesClaimsAssets();
liabilitiesClaimsAssets.setId(currentId.get());
liabilitiesClaimsAssets.setCompanyId(currentId.get());
liabilitiesClaimsAssets.setClearingDate(LocalDate.now());
liabilitiesClaimsAssets.setAccountId(currentId.get());
liabilitiesClaimsAssets.setAccountType("man");
liabilitiesClaimsAssets.setAccount("res");
liabilitiesClaimsAssets.setLiabilitiesQuantity(new BigDecimal(0));
liabilitiesClaimsAssets.setClaimsQuantity(new BigDecimal(0));
liabilitiesClaimsAssets.setCurrency("dos");
liabilitiesClaimsAssets.setSettlementDate(LocalDate.now());
liabilitiesClaimsAssets.setTradingDate(LocalDate.now());
liabilitiesClaimsAssets.setRefundDate(LocalDate.now());
liabilitiesClaimsAssets.setPrice(new BigDecimal(0));
liabilitiesClaimsAssets.setSecurityId(currentId.get());
liabilitiesClaimsAssets.setTradingCode("tra");
liabilitiesClaimsAssets.setClearingCode("cle");
liabilitiesClaimsAssets.setShortName("man");
liabilitiesClaimsAssets.setContract("res");
liabilitiesClaimsAssets.setComment("com");
liabilitiesClaimsAssets.setFullName("send");
liabilitiesClaimsAssets.setParentId(currentId.get());
liabilitiesClaimsAssets.setLiabilitiesClaimsMoneyId(currentId.get());
liabilitiesClaimsAssets.setClearingStatus(currentId.get());
liabilitiesClaimsAssets.setPaymentId(currentId.get());
liabilitiesClaimsAssets.setRefundPaymentId(currentId.get());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_LiabilitiesClaimsAssets, liabilitiesClaimsAssets, REST_URL);
}
}

42
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsMoneyControllerTest.java
View file

@ -1,42 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.liabilities;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.math.BigDecimal;
import java.time.LocalDate;
class LiabilitiesClaimsMoneyControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/liabilities-claims-money/";
/**
* {@link LiabilitiesClaimsMoneyController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /liabilities-claims-money/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
LiabilitiesClaimsMoney liabilitiesClaimsMoney = new LiabilitiesClaimsMoney();
liabilitiesClaimsMoney.setId(currentId.get());
liabilitiesClaimsMoney.setCompanyId(currentId.get());
liabilitiesClaimsMoney.setAccountId(currentId.get());
liabilitiesClaimsMoney.setAccountType("acc");
liabilitiesClaimsMoney.setAccount("acc");
liabilitiesClaimsMoney.setLiabilitiesAmount(new BigDecimal(0));
liabilitiesClaimsMoney.setClaimsAmount(new BigDecimal(0));
liabilitiesClaimsMoney.setSettlementDate(LocalDate.now());
liabilitiesClaimsMoney.setTradingDate(LocalDate.now());
liabilitiesClaimsMoney.setCurrency("dos");
liabilitiesClaimsMoney.setTradingCode("tra");
liabilitiesClaimsMoney.setShortName("short");
liabilitiesClaimsMoney.setFullName("full");
liabilitiesClaimsMoney.setClearingDate(LocalDate.now());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_LiabilitiesClaimsMoney, liabilitiesClaimsMoney, REST_URL);
}
}

45
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/register/AdmittedDealRegisterControllerTest.java
View file

@ -1,45 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.register;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.register.AdmittedDealRegister;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
class AdmittedDealRegisterControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/admitted-deal-registers/";
/**
* {@link AdmittedDealRegisterController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /admitted-deal-registers/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
AdmittedDealRegister admittedDealRegister = new AdmittedDealRegister();
admittedDealRegister.setId(currentId.get());
admittedDealRegister.setExecutionId(currentId.get());
admittedDealRegister.setCompanyFullName("com");
admittedDealRegister.setTradingDate(LocalDate.now());
admittedDealRegister.setExchangeExecutionId(currentId.get());
admittedDealRegister.setExchangeExecutionTime(Instant.now());
admittedDealRegister.setSecuritySymbol("symb");
admittedDealRegister.setSecurityFullName("name");
admittedDealRegister.setSellerFullName("dos");
admittedDealRegister.setSellerClearingCode("code");
admittedDealRegister.setSellerAccount("acc");
admittedDealRegister.setBuyerFullName("name");
admittedDealRegister.setBuyerClearingCode("code");
admittedDealRegister.setBuyerAccount("buy");
admittedDealRegister.setAmount(new BigDecimal(0));
admittedDealRegister.setClearingDate(LocalDate.now());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_AdmittedDealRegister, admittedDealRegister, REST_URL);
}
}

43
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/register/BalanceRegisterControllerTest.java
View file

@ -1,43 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.register;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.misc.BalanceRegister;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.math.BigDecimal;
import java.time.Instant;
class BalanceRegisterControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/balance-registers/";
/**
* {@link BalanceRegisterController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /balance-registers/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
BalanceRegister balanceRegister = new BalanceRegister();
balanceRegister.setId(currentId.get());
balanceRegister.setsDf01Date(Instant.now());
balanceRegister.setCurrencyCode("com");
balanceRegister.setSetHouseName("name");
balanceRegister.setAccount("acc");
balanceRegister.setInfoAccount("acc");
balanceRegister.setRemainderSum(new BigDecimal(0));
balanceRegister.setBlockedSum(new BigDecimal(0));
balanceRegister.setUnblockedSum(new BigDecimal(0));
balanceRegister.setInn("code");
balanceRegister.setMarket(currentId.get());
balanceRegister.setFullName("name");
balanceRegister.setTypeRemains("code");
balanceRegister.setDocNumber("buy");
balanceRegister.setCompanyId(currentId.get());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_BalanceRegister, balanceRegister, REST_URL);
}
}

54
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/register/ClearMemberRegisterControllerTest.java
View file

@ -1,54 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.register;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.misc.ClearMemberRegister;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.time.Instant;
import java.time.LocalDate;
class ClearMemberRegisterControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/clearmember-registers/";
/**
* {@link ClearMemberRegisterController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /clearmember-registers/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
ClearMemberRegister clearMemberRegister = new ClearMemberRegister();
clearMemberRegister.setId(currentId.get());
clearMemberRegister.setTradingCode("code");
clearMemberRegister.setClearingCode("com");
clearMemberRegister.setFullName("name");
clearMemberRegister.setShortName("name");
clearMemberRegister.setCategoryList("cat");
clearMemberRegister.setCorporationSole("symb");
clearMemberRegister.setAccount("name");
clearMemberRegister.setBank(currentId.get());
clearMemberRegister.setBankName("code");
clearMemberRegister.setInn("acc");
clearMemberRegister.setBic("name");
clearMemberRegister.setOgrn("code");
clearMemberRegister.setCpp("buy");
clearMemberRegister.setOcpo("ocpo");
clearMemberRegister.setContractNumber("cont");
clearMemberRegister.setContractDate(LocalDate.now());
clearMemberRegister.setRegistrationDate(LocalDate.now());
clearMemberRegister.setSystemDate(LocalDate.now());
clearMemberRegister.setAccessDate(Instant.now());
clearMemberRegister.setSuspentionDate(Instant.now());
clearMemberRegister.setReopeningDate(Instant.now());
clearMemberRegister.setCloseDate(Instant.now());
clearMemberRegister.setExclusionDate(Instant.now());
clearMemberRegister.setAddress("code");
clearMemberRegister.setEmail("acc");
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_ClearMemberRegister, clearMemberRegister, REST_URL);
}
}

45
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/register/CoveredDealRegisterControllerTest.java
View file

@ -1,45 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.register;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.register.CoveredDealRegister;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
class CoveredDealRegisterControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/covered-deal-registers/";
/**
* {@link CoveredDealRegisterController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /covered-deal-registers/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
CoveredDealRegister coveredDealRegister = new CoveredDealRegister();
coveredDealRegister.setId(currentId.get());
coveredDealRegister.setExecutionId(currentId.get());
coveredDealRegister.setCompanyFullName("com");
coveredDealRegister.setTradingDate(LocalDate.now());
coveredDealRegister.setExchangeExecutionId(currentId.get());
coveredDealRegister.setExchangeExecutionTime(Instant.now());
coveredDealRegister.setSecuritySymbol("symb");
coveredDealRegister.setSecurityFullName("name");
coveredDealRegister.setSellerFullName("name");
coveredDealRegister.setSellerClearingCode("code");
coveredDealRegister.setSellerAccount("acc");
coveredDealRegister.setBuyerFullName("name");
coveredDealRegister.setBuyerClearingCode("code");
coveredDealRegister.setBuyerAccount("buy");
coveredDealRegister.setAmount(new BigDecimal(0));
coveredDealRegister.setClearingDate(LocalDate.now());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_CoveredDealRegister, coveredDealRegister, REST_URL);
}
}

50
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/register/DealRegisterControllerTest.java
View file

@ -1,50 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.register;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.register.DealRegister;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
class DealRegisterControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/deal-registers/";
/**
* {@link DealRegisterController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /deal-registers/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
DealRegister dealRegister = new DealRegister();
dealRegister.setId(currentId.get());
dealRegister.setExecutionId(currentId.get());
dealRegister.setExchangeExecutionId(currentId.get());
dealRegister.setExchangeExecutionTime(Instant.now());
dealRegister.setTradingDate(LocalDate.now());
dealRegister.setAccount("cat");
dealRegister.setMarket("symb");
dealRegister.setPrice(new BigDecimal(0));
dealRegister.setAmount(new BigDecimal(0));
dealRegister.setSide("code");
dealRegister.setSettlementCurrency("acc");
dealRegister.setCompanyId(currentId.get());
dealRegister.setFirstLegSettlementDate(LocalDate.now());
dealRegister.setSecondLegSettlementDate(LocalDate.now());
dealRegister.setSecurityFullName("ocpo");
dealRegister.setSecuritySymbol("cont");
dealRegister.setSecurityId(currentId.get());
dealRegister.setCounterPartyId(currentId.get());
dealRegister.setCoverageStatus("status");
dealRegister.setSessionId(currentId.get());
dealRegister.setClearingDate(LocalDate.now());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_DealRegister, dealRegister, REST_URL);
}
}

38
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/register/OrderRegisterControllerTest.java
View file

@ -1,38 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.register;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.register.OrderRegister;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.math.BigDecimal;
import java.time.LocalDate;
class OrderRegisterControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/order-registers/";
/**
* {@link OrderRegisterController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /order-registers/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
OrderRegister orderRegister = new OrderRegister();
orderRegister.setId(currentId.get());
orderRegister.setCreditLegAccount("code");
orderRegister.setCreditLegAmount(new BigDecimal(0));
orderRegister.setCreditLegCurrencyCode("name");
orderRegister.setCreditLegDirection(currentId.get());
orderRegister.setDebitLegAccount("cat");
orderRegister.setSender("symb");
orderRegister.setAddressee("name");
orderRegister.setDocumentNumber("doc");
orderRegister.setClearingDate(LocalDate.now());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_OrderRegister, orderRegister, REST_URL);
}
}

46
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/register/UncoveredDealRegisterControllerTest.java
View file

@ -1,46 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.register;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.register.UncoveredDealRegister;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
class UncoveredDealRegisterControllerTest extends AbstractControllerTest {
private static final String REST_URL = "/uncovered-deal-registers/";
/**
* {@link UncoveredDealRegisterController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /uncovered-deal-registers/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
UncoveredDealRegister uncoveredDealRegister = new UncoveredDealRegister();
uncoveredDealRegister.setId(currentId.get());
uncoveredDealRegister.setExecutionId(currentId.get());
uncoveredDealRegister.setCompanyFullName("code");
uncoveredDealRegister.setTradingDate(LocalDate.now());
uncoveredDealRegister.setExchangeExecutionId(currentId.get());
uncoveredDealRegister.setExchangeExecutionTime(Instant.now());
uncoveredDealRegister.setSecuritySymbol("sec");
uncoveredDealRegister.setSecurityFullName("code");
uncoveredDealRegister.setSellerFullName("code");
uncoveredDealRegister.setSellerClearingCode("sell");
uncoveredDealRegister.setSellerAccount("coment");
uncoveredDealRegister.setBuyerFullName("cat");
uncoveredDealRegister.setBuyerClearingCode("buyer");
uncoveredDealRegister.setBuyerAccount("code");
uncoveredDealRegister.setAmount(new BigDecimal(0));
uncoveredDealRegister.setResultStatus("res");
uncoveredDealRegister.setClearingDate(LocalDate.now());
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_UncoveredDealRegister, uncoveredDealRegister, REST_URL);
}
}

95
clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/utilities/CudKeyRateControllerTest.java
View file

@ -1,95 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.utilities;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.misc.KeyRate;
import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
import ru.spcex.clearing.backendapi.controller.request.cud.utilities.KeyRateNewAction;
import ru.spcex.clearing.backendapi.controller.request.cud.utilities.KeyRateUpdateAction;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import java.math.BigDecimal;
import java.time.LocalDate;
class CudKeyRateControllerTest extends AbstractControllerTest {
public static final String REST_URL = "/utilities/key-rates/";
/**
* {@link CudKeyRateController#add(KeyRateNewAction)} <br>
* Тест проверяет получение сущности {@link KeyRateNewAction} по REST API и отправку в Apache Kafka.<br>
* Входной запрос {@link KeyRateNewAction}:<br>
*/
@Test
void add() throws Exception {
//ARRANGE
KeyRateNewAction keyRateUpdateAction = new KeyRateNewAction();
// keyRateUpdateAction.setId(currentId.get());
keyRateUpdateAction.setRate(new BigDecimal(0));
keyRateUpdateAction.setStartDate(LocalDate.now());
keyRateUpdateAction.setEndDate(LocalDate.now());
keyRateUpdateAction.setDocument("name");
//ACT and ASSERT
checkAddingByRestApi(REST_URL, keyRateUpdateAction);
checkSendedMessegeFromKafka(Consts.DESTINATION_KEY_RATE_NEW, keyRateUpdateAction);
}
/**
* {@link CudKeyRateController#update(Long, KeyRateUpdateAction)} <br>
* Тест проверяет получение сущности {@link KeyRateNewAction} по REST API и отправку в Apache Kafka.<br>
* Входной запрос {@link KeyRateNewAction}:<br>
*/
@Test
void update() throws Exception {
//ARRANGE
long id = currentId.get();
KeyRateUpdateAction keyRateUpdateAction = new KeyRateUpdateAction();
keyRateUpdateAction.setId(id);
keyRateUpdateAction.setRate(new BigDecimal(0));
keyRateUpdateAction.setStartDate(LocalDate.now());
keyRateUpdateAction.setEndDate(LocalDate.now());
keyRateUpdateAction.setDocument("name");
//ACT and ASSERT
checkUpdatingByRestApi(REST_URL, keyRateUpdateAction, id);
checkSendedMessegeFromKafka(Consts.DESTINATION_KEY_RATE_UPDATE, keyRateUpdateAction);
}
/**
* {@link CudKeyRateController#delete(Long)} <br>
* Тест проверяет получение id сущности {@link Long} по REST API и отправку в Apache Kafka.<br>
* Входной запрос /utilities/key-rates/{@link Long}: - 0L<br>
*/
@Test
void delete() throws Exception {
//ARRANGE
long id = currentId.getAndIncrement();
CommonDeleteAction deleteAction = new CommonDeleteAction();
deleteAction.setId(id);
//ACT and ASSERT
checkDeletingByRestApi(REST_URL, id);
checkSendedMessegeFromKafka(Consts.DESTINATION_KEY_RATE_DELETE, deleteAction);
}
/**
* {@link CudKeyRateController#getAll()} <br>
* Тест проверяет получение запроса по REST API.<br>
* Входной запрос /utilities/key-rates/ <br>
* Ответ CommonGetAllResponse <br>
*/
@Test
void getAll() throws Exception {
//ARRANGE
KeyRate keyRate = new KeyRate();
keyRate.setId(currentId.get());
keyRate.setRate(new BigDecimal(0));
keyRate.setStartDate(LocalDate.now());
keyRate.setEndDate(LocalDate.now());
keyRate.setDocument("name");
keyRate.setWorkflowStatus("name");
//ACT and ASSERT
checkGettingAllFromRestApi(IMDGDistributedNames.Map_KeyRate, keyRate, REST_URL);
}
}

2
clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/validation/Sdf16ValidationRuleTest.java
View file

@ -12,7 +12,7 @@ import java.math.BigDecimal;
import java.util.Optional; import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.Assertions.*;
@Deprecated // sDf16 was deleted
class Sdf16ValidationRuleTest { class Sdf16ValidationRuleTest {
@Test @Test

1
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/liabilities/LiabilitiesClaimsAssets.java
View file

@ -6,6 +6,7 @@ import ru.clearing.classes.objects.BusinessObject;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.time.LocalDate; import java.time.LocalDate;
@Deprecated
public class LiabilitiesClaimsAssets extends BusinessObject { public class LiabilitiesClaimsAssets extends BusinessObject {
private static final long serialVersionUID = ConstSerializable.serialVersionUID; private static final long serialVersionUID = ConstSerializable.serialVersionUID;

1
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/liabilities/LiabilitiesClaimsMoney.java
View file

@ -6,6 +6,7 @@ import ru.clearing.classes.objects.BusinessObject;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.time.LocalDate; import java.time.LocalDate;
@Deprecated
public class LiabilitiesClaimsMoney extends BusinessObject { public class LiabilitiesClaimsMoney extends BusinessObject {
private static final long serialVersionUID = ConstSerializable.serialVersionUID; private static final long serialVersionUID = ConstSerializable.serialVersionUID;
private Long companyId; private Long companyId;

138
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/misc/BalanceRegister.java
View file

@ -1,138 +0,0 @@
package ru.clearing.classes.statics.data.misc;
import ru.clearing.classes.ConstSerializable;
import ru.clearing.classes.objects.BusinessObject;
import java.math.BigDecimal;
import java.time.Instant;
public class BalanceRegister extends BusinessObject {
private static final long serialVersionUID = ConstSerializable.serialVersionUID;
private Instant sDf01Date;
private String currencyCode;
private String setHouseName;
private String account;
private String infoAccount;
private BigDecimal remainderSum;
private BigDecimal blockedSum;
private BigDecimal unblockedSum;
private String inn;
private Long market;
private String fullName;
private String typeRemains;
private String docNumber;
private Long companyId;
public Instant getsDf01Date() {
return sDf01Date;
}
public void setsDf01Date(Instant sDf01Date) {
this.sDf01Date = sDf01Date;
}
public String getCurrencyCode() {
return currencyCode;
}
public void setCurrencyCode(String currencyCode) {
this.currencyCode = currencyCode;
}
public String getSetHouseName() {
return setHouseName;
}
public void setSetHouseName(String setHouseName) {
this.setHouseName = setHouseName;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public String getInfoAccount() {
return infoAccount;
}
public void setInfoAccount(String infoAccount) {
this.infoAccount = infoAccount;
}
public BigDecimal getRemainderSum() {
return remainderSum;
}
public void setRemainderSum(BigDecimal remainderSum) {
this.remainderSum = remainderSum;
}
public BigDecimal getBlockedSum() {
return blockedSum;
}
public void setBlockedSum(BigDecimal blockedSum) {
this.blockedSum = blockedSum;
}
public BigDecimal getUnblockedSum() {
return unblockedSum;
}
public void setUnblockedSum(BigDecimal unblockedSum) {
this.unblockedSum = unblockedSum;
}
public String getInn() {
return inn;
}
public void setInn(String inn) {
this.inn = inn;
}
public Long getMarket() {
return market;
}
public void setMarket(Long market) {
this.market = market;
}
public String getFullName() {
return fullName;
}
public void setFullName(String fullName) {
this.fullName = fullName;
}
public String getTypeRemains() {
return typeRemains;
}
public void setTypeRemains(String typeRemains) {
this.typeRemains = typeRemains;
}
public String getDocNumber() {
return docNumber;
}
public void setDocNumber(String docNumber) {
this.docNumber = docNumber;
}
public Long getCompanyId() {
return companyId;
}
public void setCompanyId(Long companyId) {
this.companyId = companyId;
}
}

236
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/misc/ClearMemberRegister.java
View file

@ -1,236 +0,0 @@
package ru.clearing.classes.statics.data.misc;
import ru.clearing.classes.ConstSerializable;
import ru.clearing.classes.objects.BusinessObject;
import java.time.Instant;
import java.time.LocalDate;
public class ClearMemberRegister extends BusinessObject {
private static final long serialVersionUID = ConstSerializable.serialVersionUID;
private String tradingCode;
private String clearingCode;
private String fullName;
private String shortName;
private String categoryList;
private String corporationSole;
private String account;
private Long bank;
private String bankName;
private String inn;
private String bic;
private String ogrn;
private String cpp;
private String ocpo;
private String contractNumber;
private LocalDate contractDate;
private LocalDate registrationDate;
private LocalDate systemDate;
private Instant accessDate;
private Instant suspentionDate;
private Instant reopeningDate;
private Instant closeDate;
private Instant exclusionDate;
private String address;
private String email;
public String getTradingCode() {
return tradingCode;
}
public void setTradingCode(String tradingCode) {
this.tradingCode = tradingCode;
}
public String getClearingCode() {
return clearingCode;
}
public void setClearingCode(String clearingCode) {
this.clearingCode = clearingCode;
}
public String getFullName() {
return fullName;
}
public void setFullName(String fullName) {
this.fullName = fullName;
}
public String getShortName() {
return shortName;
}
public void setShortName(String shortName) {
this.shortName = shortName;
}
public String getCategoryList() {
return categoryList;
}
public void setCategoryList(String categoryList) {
this.categoryList = categoryList;
}
public String getCorporationSole() {
return corporationSole;
}
public void setCorporationSole(String corporationSole) {
this.corporationSole = corporationSole;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public Long getBank() {
return bank;
}
public void setBank(Long bank) {
this.bank = bank;
}
public String getBankName() {
return bankName;
}
public void setBankName(String bankName) {
this.bankName = bankName;
}
public String getInn() {
return inn;
}
public void setInn(String inn) {
this.inn = inn;
}
public String getBic() {
return bic;
}
public void setBic(String bic) {
this.bic = bic;
}
public String getOgrn() {
return ogrn;
}
public void setOgrn(String ogrn) {
this.ogrn = ogrn;
}
public String getCpp() {
return cpp;
}
public void setCpp(String cpp) {
this.cpp = cpp;
}
public String getOcpo() {
return ocpo;
}
public void setOcpo(String ocpo) {
this.ocpo = ocpo;
}
public String getContractNumber() {
return contractNumber;
}
public void setContractNumber(String contractNumber) {
this.contractNumber = contractNumber;
}
public LocalDate getContractDate() {
return contractDate;
}
public void setContractDate(LocalDate contractDate) {
this.contractDate = contractDate;
}
public LocalDate getRegistrationDate() {
return registrationDate;
}
public void setRegistrationDate(LocalDate registrationDate) {
this.registrationDate = registrationDate;
}
public LocalDate getSystemDate() {
return systemDate;
}
public void setSystemDate(LocalDate systemDate) {
this.systemDate = systemDate;
}
public Instant getAccessDate() {
return accessDate;
}
public void setAccessDate(Instant accessDate) {
this.accessDate = accessDate;
}
public Instant getSuspentionDate() {
return suspentionDate;
}
public void setSuspentionDate(Instant suspentionDate) {
this.suspentionDate = suspentionDate;
}
public Instant getReopeningDate() {
return reopeningDate;
}
public void setReopeningDate(Instant reopeningDate) {
this.reopeningDate = reopeningDate;
}
public Instant getCloseDate() {
return closeDate;
}
public void setCloseDate(Instant closeDate) {
this.closeDate = closeDate;
}
public Instant getExclusionDate() {
return exclusionDate;
}
public void setExclusionDate(Instant exclusionDate) {
this.exclusionDate = exclusionDate;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}

1
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/misc/KeyRate.java
View file

@ -10,6 +10,7 @@ import java.time.LocalDate;
* <p> * <p>
* DB table: KEY_RATE * DB table: KEY_RATE
**/ **/
@Deprecated
public class KeyRate extends SpcexObjectBase { public class KeyRate extends SpcexObjectBase {
private BigDecimal rate; private BigDecimal rate;
private LocalDate startDate; private LocalDate startDate;

153
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/register/AdmittedDealRegister.java
View file

@ -1,153 +0,0 @@
package ru.clearing.classes.statics.data.register;
import ru.clearing.classes.ConstSerializable;
import ru.clearing.classes.objects.BusinessObject;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
/**
* Реестр сделок допущенных к клирингу
* <p>
* DB table: ADMITTED_DEAL_REGISTER
**/
public class AdmittedDealRegister extends BusinessObject {
private static final long serialVersionUID = ConstSerializable.serialVersionUID;
private Long executionId;
private String companyFullName;
private LocalDate tradingDate;
private Long exchangeExecutionId;
private Instant exchangeExecutionTime;
private String securitySymbol;
private String securityFullName;
private String sellerFullName;
private String sellerClearingCode;
private String sellerAccount;
private String buyerFullName;
private String buyerClearingCode;
private String buyerAccount;
private BigDecimal amount;
private LocalDate clearingDate;
public Long getExecutionId() {
return executionId;
}
public void setExecutionId(Long executionId) {
this.executionId = executionId;
}
public String getCompanyFullName() {
return companyFullName;
}
public void setCompanyFullName(String companyFullName) {
this.companyFullName = companyFullName;
}
public LocalDate getTradingDate() {
return tradingDate;
}
public void setTradingDate(LocalDate tradingDate) {
this.tradingDate = tradingDate;
}
public Long getExchangeExecutionId() {
return exchangeExecutionId;
}
public void setExchangeExecutionId(Long exchangeExecutionId) {
this.exchangeExecutionId = exchangeExecutionId;
}
public Instant getExchangeExecutionTime() {
return exchangeExecutionTime;
}
public void setExchangeExecutionTime(Instant exchangeExecutionTime) {
this.exchangeExecutionTime = exchangeExecutionTime;
}
public String getSecuritySymbol() {
return securitySymbol;
}
public void setSecuritySymbol(String securitySymbol) {
this.securitySymbol = securitySymbol;
}
public String getSecurityFullName() {
return securityFullName;
}
public void setSecurityFullName(String securityFullName) {
this.securityFullName = securityFullName;
}
public String getSellerFullName() {
return sellerFullName;
}
public void setSellerFullName(String sellerFullName) {
this.sellerFullName = sellerFullName;
}
public String getSellerClearingCode() {
return sellerClearingCode;
}
public void setSellerClearingCode(String sellerClearingCode) {
this.sellerClearingCode = sellerClearingCode;
}
public String getSellerAccount() {
return sellerAccount;
}
public void setSellerAccount(String sellerAccount) {
this.sellerAccount = sellerAccount;
}
public String getBuyerFullName() {
return buyerFullName;
}
public void setBuyerFullName(String buyerFullName) {
this.buyerFullName = buyerFullName;
}
public String getBuyerClearingCode() {
return buyerClearingCode;
}
public void setBuyerClearingCode(String buyerClearingCode) {
this.buyerClearingCode = buyerClearingCode;
}
public String getBuyerAccount() {
return buyerAccount;
}
public void setBuyerAccount(String buyerAccount) {
this.buyerAccount = buyerAccount;
}
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

41
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/register/ClearMemberRegisterChange.java
View file

@ -1,41 +0,0 @@
package ru.clearing.classes.statics.data.register;
import ru.clearing.classes.ConstSerializable;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import java.time.Instant;
/**
* Журнал изменений информации участников клиринга
**/
public class ClearMemberRegisterChange extends SpcexObjectBase {
private static final long serialVersionUID = ConstSerializable.serialVersionUID;
private Instant date;
private String comment;
private String clearingCode;
public Instant getDate() {
return date;
}
public void setDate(Instant date) {
this.date = date;
}
public String getComment() {
return comment;
}
public void setComment(String comment) {
this.comment = comment;
}
public String getClearingCode() {
return clearingCode;
}
public void setClearingCode(String clearingCode) {
this.clearingCode = clearingCode;
}
}

148
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/register/CoveredDealRegister.java
View file

@ -1,148 +0,0 @@
package ru.clearing.classes.statics.data.register;
import ru.clearing.classes.ConstSerializable;
import ru.clearing.classes.objects.BusinessObject;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
public class CoveredDealRegister extends BusinessObject {
private static final long serialVersionUID = ConstSerializable.serialVersionUID;
private Long executionId;
private String companyFullName;
private LocalDate tradingDate;
private Long exchangeExecutionId;
private Instant exchangeExecutionTime;
private String securitySymbol;
private String securityFullName;
private String sellerFullName;
private String sellerClearingCode;
private String sellerAccount;
private String buyerFullName;
private String buyerClearingCode;
private String buyerAccount;
private BigDecimal amount;
private LocalDate clearingDate;
public Long getExecutionId() {
return executionId;
}
public void setExecutionId(Long executionId) {
this.executionId = executionId;
}
public String getCompanyFullName() {
return companyFullName;
}
public void setCompanyFullName(String companyFullName) {
this.companyFullName = companyFullName;
}
public LocalDate getTradingDate() {
return tradingDate;
}
public void setTradingDate(LocalDate tradingDate) {
this.tradingDate = tradingDate;
}
public Long getExchangeExecutionId() {
return exchangeExecutionId;
}
public void setExchangeExecutionId(Long exchangeExecutionId) {
this.exchangeExecutionId = exchangeExecutionId;
}
public Instant getExchangeExecutionTime() {
return exchangeExecutionTime;
}
public void setExchangeExecutionTime(Instant exchangeExecutionTime) {
this.exchangeExecutionTime = exchangeExecutionTime;
}
public String getSecuritySymbol() {
return securitySymbol;
}
public void setSecuritySymbol(String securitySymbol) {
this.securitySymbol = securitySymbol;
}
public String getSecurityFullName() {
return securityFullName;
}
public void setSecurityFullName(String securityFullName) {
this.securityFullName = securityFullName;
}
public String getSellerFullName() {
return sellerFullName;
}
public void setSellerFullName(String sellerFullName) {
this.sellerFullName = sellerFullName;
}
public String getSellerClearingCode() {
return sellerClearingCode;
}
public void setSellerClearingCode(String sellerClearingCode) {
this.sellerClearingCode = sellerClearingCode;
}
public String getSellerAccount() {
return sellerAccount;
}
public void setSellerAccount(String sellerAccount) {
this.sellerAccount = sellerAccount;
}
public String getBuyerFullName() {
return buyerFullName;
}
public void setBuyerFullName(String buyerFullName) {
this.buyerFullName = buyerFullName;
}
public String getBuyerClearingCode() {
return buyerClearingCode;
}
public void setBuyerClearingCode(String buyerClearingCode) {
this.buyerClearingCode = buyerClearingCode;
}
public String getBuyerAccount() {
return buyerAccount;
}
public void setBuyerAccount(String buyerAccount) {
this.buyerAccount = buyerAccount;
}
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

190
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/register/DealRegister.java
View file

@ -1,190 +0,0 @@
package ru.clearing.classes.statics.data.register;
import ru.clearing.classes.objects.BusinessObject;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
public class DealRegister extends BusinessObject {
private Long executionId;
private Long exchangeExecutionId;
private Instant exchangeExecutionTime;
private LocalDate tradingDate;
private String account;
private String market;
private BigDecimal price;
private BigDecimal amount;
private String side;
private String settlementCurrency;
private Long companyId;
private LocalDate firstLegSettlementDate;
private LocalDate secondLegSettlementDate;
private String securityFullName;
private String securitySymbol;
private Long securityId;
private Long counterPartyId;
private String coverageStatus;
private Long sessionId;
private LocalDate clearingDate;
public Long getExecutionId() {
return executionId;
}
public void setExecutionId(Long executionId) {
this.executionId = executionId;
}
public Long getExchangeExecutionId() {
return exchangeExecutionId;
}
public void setExchangeExecutionId(Long exchangeExecutionId) {
this.exchangeExecutionId = exchangeExecutionId;
}
public Instant getExchangeExecutionTime() {
return exchangeExecutionTime;
}
public void setExchangeExecutionTime(Instant exchangeExecutionTime) {
this.exchangeExecutionTime = exchangeExecutionTime;
}
public LocalDate getTradingDate() {
return tradingDate;
}
public void setTradingDate(LocalDate tradingDate) {
this.tradingDate = tradingDate;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public String getMarket() {
return market;
}
public void setMarket(String market) {
this.market = market;
}
public BigDecimal getPrice() {
return price;
}
public void setPrice(BigDecimal price) {
this.price = price;
}
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
public String getSide() {
return side;
}
public void setSide(String side) {
this.side = side;
}
public String getSettlementCurrency() {
return settlementCurrency;
}
public void setSettlementCurrency(String settlementCurrency) {
this.settlementCurrency = settlementCurrency;
}
public Long getCompanyId() {
return companyId;
}
public void setCompanyId(Long companyId) {
this.companyId = companyId;
}
public LocalDate getFirstLegSettlementDate() {
return firstLegSettlementDate;
}
public void setFirstLegSettlementDate(LocalDate firstLegSettlementDate) {
this.firstLegSettlementDate = firstLegSettlementDate;
}
public LocalDate getSecondLegSettlementDate() {
return secondLegSettlementDate;
}
public void setSecondLegSettlementDate(LocalDate secondLegSettlementDate) {
this.secondLegSettlementDate = secondLegSettlementDate;
}
public String getSecurityFullName() {
return securityFullName;
}
public void setSecurityFullName(String securityFullName) {
this.securityFullName = securityFullName;
}
public String getSecuritySymbol() {
return securitySymbol;
}
public void setSecuritySymbol(String securitySymbol) {
this.securitySymbol = securitySymbol;
}
public Long getSecurityId() {
return securityId;
}
public void setSecurityId(Long securityId) {
this.securityId = securityId;
}
public Long getCounterPartyId() {
return counterPartyId;
}
public void setCounterPartyId(Long counterPartyId) {
this.counterPartyId = counterPartyId;
}
public String getCoverageStatus() {
return coverageStatus;
}
public void setCoverageStatus(String coverageStatus) {
this.coverageStatus = coverageStatus;
}
public Long getSessionId() {
return sessionId;
}
public void setSessionId(Long sessionId) {
this.sessionId = sessionId;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

93
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/register/OrderRegister.java
View file

@ -1,93 +0,0 @@
package ru.clearing.classes.statics.data.register;
import ru.clearing.classes.ConstSerializable;
import ru.clearing.classes.objects.BusinessObject;
import java.math.BigDecimal;
import java.time.LocalDate;
public class OrderRegister extends BusinessObject {
private static final long serialVersionUID = ConstSerializable.serialVersionUID;
private String creditLegAccount;
private BigDecimal creditLegAmount;
private String creditLegCurrencyCode;
private Long creditLegDirection;
private String debitLegAccount;
private String sender;
private String addressee;
private String documentNumber;
private LocalDate clearingDate;
public String getCreditLegAccount() {
return creditLegAccount;
}
public void setCreditLegAccount(String creditLegAccount) {
this.creditLegAccount = creditLegAccount;
}
public BigDecimal getCreditLegAmount() {
return creditLegAmount;
}
public void setCreditLegAmount(BigDecimal creditLegAmount) {
this.creditLegAmount = creditLegAmount;
}
public String getCreditLegCurrencyCode() {
return creditLegCurrencyCode;
}
public void setCreditLegCurrencyCode(String creditLegCurrencyCode) {
this.creditLegCurrencyCode = creditLegCurrencyCode;
}
public Long getCreditLegDirection() {
return creditLegDirection;
}
public void setCreditLegDirection(Long creditLegDirection) {
this.creditLegDirection = creditLegDirection;
}
public String getDebitLegAccount() {
return debitLegAccount;
}
public void setDebitLegAccount(String debitLegAccount) {
this.debitLegAccount = debitLegAccount;
}
public String getSender() {
return sender;
}
public void setSender(String sender) {
this.sender = sender;
}
public String getAddressee() {
return addressee;
}
public void setAddressee(String addressee) {
this.addressee = addressee;
}
public String getDocumentNumber() {
return documentNumber;
}
public void setDocumentNumber(String documentNumber) {
this.documentNumber = documentNumber;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

157
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/register/UncoveredDealRegister.java
View file

@ -1,157 +0,0 @@
package ru.clearing.classes.statics.data.register;
import ru.clearing.classes.ConstSerializable;
import ru.clearing.classes.objects.BusinessObject;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
public class UncoveredDealRegister extends BusinessObject {
private static final long serialVersionUID = ConstSerializable.serialVersionUID;
private Long executionId;
private String companyFullName;
private LocalDate tradingDate;
private Long exchangeExecutionId;
private Instant exchangeExecutionTime;
private String securitySymbol;
private String securityFullName;
private String sellerFullName;
private String sellerClearingCode;
private String sellerAccount;
private String buyerFullName;
private String buyerClearingCode;
private String buyerAccount;
private BigDecimal amount;
private String resultStatus;
private LocalDate clearingDate;
public Long getExecutionId() {
return executionId;
}
public void setExecutionId(Long executionId) {
this.executionId = executionId;
}
public String getCompanyFullName() {
return companyFullName;
}
public void setCompanyFullName(String companyFullName) {
this.companyFullName = companyFullName;
}
public LocalDate getTradingDate() {
return tradingDate;
}
public void setTradingDate(LocalDate tradingDate) {
this.tradingDate = tradingDate;
}
public Long getExchangeExecutionId() {
return exchangeExecutionId;
}
public void setExchangeExecutionId(Long exchangeExecutionId) {
this.exchangeExecutionId = exchangeExecutionId;
}
public Instant getExchangeExecutionTime() {
return exchangeExecutionTime;
}
public void setExchangeExecutionTime(Instant exchangeExecutionTime) {
this.exchangeExecutionTime = exchangeExecutionTime;
}
public String getSecuritySymbol() {
return securitySymbol;
}
public void setSecuritySymbol(String securitySymbol) {
this.securitySymbol = securitySymbol;
}
public String getSecurityFullName() {
return securityFullName;
}
public void setSecurityFullName(String securityFullName) {
this.securityFullName = securityFullName;
}
public String getSellerFullName() {
return sellerFullName;
}
public void setSellerFullName(String sellerFullName) {
this.sellerFullName = sellerFullName;
}
public String getSellerClearingCode() {
return sellerClearingCode;
}
public void setSellerClearingCode(String sellerClearingCode) {
this.sellerClearingCode = sellerClearingCode;
}
public String getSellerAccount() {
return sellerAccount;
}
public void setSellerAccount(String sellerAccount) {
this.sellerAccount = sellerAccount;
}
public String getBuyerFullName() {
return buyerFullName;
}
public void setBuyerFullName(String buyerFullName) {
this.buyerFullName = buyerFullName;
}
public String getBuyerClearingCode() {
return buyerClearingCode;
}
public void setBuyerClearingCode(String buyerClearingCode) {
this.buyerClearingCode = buyerClearingCode;
}
public String getBuyerAccount() {
return buyerAccount;
}
public void setBuyerAccount(String buyerAccount) {
this.buyerAccount = buyerAccount;
}
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
public String getResultStatus() {
return resultStatus;
}
public void setResultStatus(String resultStatus) {
this.resultStatus = resultStatus;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

1
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/sdf/SDf16.java
View file

@ -14,6 +14,7 @@ import java.time.Instant;
* <p> * <p>
* DB table: S_DF16 * DB table: S_DF16
**/ **/
@Deprecated
public class SDf16 extends SpcexObjectBase implements WithAccount, WithMarket, WithSum { public class SDf16 extends SpcexObjectBase implements WithAccount, WithMarket, WithSum {
private static final long serialVersionUID = ConstSerializable.serialVersionUID; private static final long serialVersionUID = ConstSerializable.serialVersionUID;

1
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/sdf/SDf17.java
View file

@ -12,6 +12,7 @@ import java.time.Instant;
* <p> * <p>
* DB table: S_DF17 * DB table: S_DF17
**/ **/
@Deprecated
public class SDf17 extends SpcexObjectBase implements WithAccount { public class SDf17 extends SpcexObjectBase implements WithAccount {
private static final long serialVersionUID = ConstSerializable.serialVersionUID; private static final long serialVersionUID = ConstSerializable.serialVersionUID;

1
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/sdf/SDf18.java
View file

@ -12,6 +12,7 @@ import java.time.Instant;
* <p> * <p>
* DB table: S_DF18 * DB table: S_DF18
**/ **/
@Deprecated
public class SDf18 extends SpcexObjectBase implements WithAccount { public class SDf18 extends SpcexObjectBase implements WithAccount {
private static final long serialVersionUID = ConstSerializable.serialVersionUID; private static final long serialVersionUID = ConstSerializable.serialVersionUID;

1
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/LiabilitiesClaimsMoneyCreator.java
View file

@ -19,6 +19,7 @@ import java.util.Optional;
import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD; import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
@Deprecated // liabilitiesClaimsMoney даляется
@Component @Component
public class LiabilitiesClaimsMoneyCreator { public class LiabilitiesClaimsMoneyCreator {
private final Logger log = LoggerFactory.getLogger(this.getClass()); private final Logger log = LoggerFactory.getLogger(this.getClass());

11
clearing-parent/dictionary/src/main/java/ru/clearing/platform/dictionary/BalanceAccountTypeDictionary.java
View file

@ -1,11 +0,0 @@
package ru.clearing.platform.dictionary;
/**
* Справочник типов лимитов
*
* Dictionary DB table: BALANCE_ACCOUNT_TYPE_DICTIONARY
**/
public class BalanceAccountTypeDictionary extends AbstractDictionary {
private static final long serialVersionUID = ConstDictionarySerializable.serialVersionUID;
}

12
clearing-parent/dictionary/src/main/java/ru/clearing/platform/dictionary/ChargeDirectionDictionary.java
View file

@ -1,12 +0,0 @@
package ru.clearing.platform.dictionary;
/**
* Направление начисления комиссии
*
* Dictionary DB table: CHARGE_DIRECTION_DICTIONARY
**/
public class ChargeDirectionDictionary extends AbstractDictionary {
private static final long serialVersionUID = ConstDictionarySerializable.serialVersionUID;
}

11
clearing-parent/dictionary/src/main/java/ru/clearing/platform/dictionary/ChargeTypeDictionary.java
View file

@ -1,11 +0,0 @@
package ru.clearing.platform.dictionary;
/**
* Справочник типов комиссий
*
* Dictionary DB table: CHARGE_TYPE_DICTIONARY
**/
public class ChargeTypeDictionary extends AbstractDictionary {
private static final long serialVersionUID = ConstDictionarySerializable.serialVersionUID;
}

1
clearing-parent/dictionary/src/main/java/ru/clearing/platform/dictionary/ClearingStatusDictionary.java
View file

@ -5,6 +5,7 @@ package ru.clearing.platform.dictionary;
* *
* Dictionary DB table: CLEARING_STATUS_DICTIONARY * Dictionary DB table: CLEARING_STATUS_DICTIONARY
**/ **/
@Deprecated
public class ClearingStatusDictionary extends AbstractDictionary { public class ClearingStatusDictionary extends AbstractDictionary {
private static final long serialVersionUID = ConstDictionarySerializable.serialVersionUID; private static final long serialVersionUID = ConstDictionarySerializable.serialVersionUID;

100
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/AccountBalanceMapStore.java
View file

@ -1,100 +0,0 @@
package ru.spcex.clearing.imdg.businessobject;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.account.AccountBalance;
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;
@Deprecated
//@Component
public class AccountBalanceMapStore extends TemplateMapStore<AccountBalance> {
public AccountBalanceMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_AccountBalance;
}
@Override
public String getTableName() {
return "ACCOUNT_BALANCE";
}
@Override
public String[] getFields() {
return new String[]{
"ID", "COMPANY_ID", "CREATED_AT", "UPDATED_AT", "ACCOUNT_ID", "ACCOUNT_TYPE",
"ACCOUNT", "OPEN_BALANCE_AMOUNT", "START_BALANCE_AMOUNT", "CLOSE_BALANCE_AMOUNT",
"TRADE_BALANCE_AMOUNT", "FREE_BALANCE_AMOUNT", "CHANGE_BALANCE_AMOUNT",
"CREDIT_AMOUNT", "DEBIT_AMOUNT", "BALANCE_AMOUNT", "BALANCE_ACCOUNT_TYPE",
"CLEARING_DATE", "CURRENCY_CODE", "TRADING_CODE", "SHORT_NAME", "FULL_NAME"
};
}
@Override
public AccountBalance objectReader(ResultSet resultSet) throws SQLException {
AccountBalance object = new AccountBalance();
object.setId(resultSet.getObject("ID", Long.class));
object.setCompanyId(resultSet.getObject("COMPANY_ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setAccountId(resultSet.getObject("ACCOUNT_ID", Long.class));
object.setAccountType(resultSet.getObject("ACCOUNT_TYPE", String.class));
object.setAccount(resultSet.getObject("ACCOUNT", String.class));
object.setOpenBalanceAmount(resultSet.getObject("OPEN_BALANCE_AMOUNT", BigDecimal.class));
object.setStartBalanceAmount(resultSet.getObject("START_BALANCE_AMOUNT", BigDecimal.class));
object.setCloseBalanceAmount(resultSet.getObject("CLOSE_BALANCE_AMOUNT", BigDecimal.class));
object.setTradeBalanceAmount(resultSet.getObject("TRADE_BALANCE_AMOUNT", BigDecimal.class));
object.setFreeBalanceAmount(resultSet.getObject("FREE_BALANCE_AMOUNT", BigDecimal.class));
object.setChangeBalanceAmount(resultSet.getObject("CHANGE_BALANCE_AMOUNT", BigDecimal.class));
object.setCreditAmount(resultSet.getObject("CREDIT_AMOUNT", BigDecimal.class));
object.setDebitAmount(resultSet.getObject("DEBIT_AMOUNT", BigDecimal.class));
object.setBalanceAmount(resultSet.getObject("BALANCE_AMOUNT", BigDecimal.class));
object.setBalanceAccountType(resultSet.getObject("BALANCE_ACCOUNT_TYPE", String.class));
object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE"));
object.setCurrencyCode(resultSet.getObject("CURRENCY_CODE", 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));
return object;
}
@Override
public Object[] objectToField(AccountBalance object) {
Object[] args = new Object[]{
object.getId(),
object.getCompanyId(),
TimeUtil.toDateFromInstant(object.getCreated()),
TimeUtil.toDateFromInstant(object.getUpdated()),
object.getAccountId(),
object.getAccountType(),
object.getAccount(),
object.getOpenBalanceAmount(),
object.getStartBalanceAmount(),
object.getCloseBalanceAmount(),
object.getTradeBalanceAmount(),
object.getFreeBalanceAmount(),
object.getChangeBalanceAmount(),
object.getCreditAmount(),
object.getDebitAmount(),
object.getBalanceAmount(),
object.getBalanceAccountType(),
TimeUtil.toDateFromLocalDate(object.getClearingDate()),
object.getCurrencyCode(),
object.getTradingCode(),
object.getShortName(),
object.getFullName()
};
return args;
}
}

108
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/LiabilitiesClaimsAssetsMapStore.java
View file

@ -1,108 +0,0 @@
package ru.spcex.clearing.imdg.businessobject;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
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 LiabilitiesClaimsAssetsMapStore extends TemplateMapStore<LiabilitiesClaimsAssets> {
public LiabilitiesClaimsAssetsMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_LiabilitiesClaimsAssets;
}
@Override
public String getTableName() {
return "LIABILITIES_CLAIMS_ASSETS";
}
@Override
public String[] getFields() {
return new String[]{
"ID", "COMPANY_ID", "CREATED_AT", "UPDATED_AT", "CLEARING_DATE", "ACCOUNT_ID", "ACCOUNT_TYPE", "ACCOUNT",
"LIABILITIES_QUANTITY", "CLAIMS_QUANTITY", "CURRENCY", "SETTLEMENT_DATE", "TRADING_DATE", "REFUND_DATE",
"PRICE", "SECURITY_ID", "TRADING_CODE", "CLEARING_CODE", "SHORT_NAME", "CONTRACT", "COMMENT", "FULL_NAME",
"PARENT_ID", "LIABILITIES_CLAIMS_MONEY_ID", "CLEARING_STATUS", "PAYMENT_ID", "REFUND_PAYMENT_ID"
};
}
@Override
public LiabilitiesClaimsAssets objectReader(ResultSet resultSet) throws SQLException {
LiabilitiesClaimsAssets object = new LiabilitiesClaimsAssets();
object.setId(resultSet.getObject("ID", Long.class));
object.setCompanyId(resultSet.getObject("COMPANY_ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE"));
object.setAccountId(resultSet.getObject("ACCOUNT_ID", Long.class));
object.setAccountType(resultSet.getObject("ACCOUNT_TYPE", String.class));
object.setAccount(resultSet.getObject("ACCOUNT", String.class));
object.setLiabilitiesQuantity(resultSet.getObject("LIABILITIES_QUANTITY", BigDecimal.class));
object.setClaimsQuantity(resultSet.getObject("CLAIMS_QUANTITY", BigDecimal.class));
object.setCurrency(resultSet.getObject("CURRENCY", String.class));
object.setSettlementDate(getLocalDateFromSqlDate(resultSet, "SETTLEMENT_DATE"));
object.setTradingDate(getLocalDateFromSqlDate(resultSet, "TRADING_DATE"));
object.setRefundDate(getLocalDateFromSqlDate(resultSet, "REFUND_DATE"));
object.setPrice(resultSet.getObject("PRICE", BigDecimal.class));
object.setSecurityId(resultSet.getObject("SECURITY_ID", Long.class));
object.setTradingCode(resultSet.getObject("TRADING_CODE", String.class));
object.setClearingCode(resultSet.getObject("CLEARING_CODE", String.class));
object.setShortName(resultSet.getObject("SHORT_NAME", String.class));
object.setContract(resultSet.getObject("CONTRACT", String.class));
object.setComment(resultSet.getObject("COMMENT", String.class));
object.setFullName(resultSet.getObject("FULL_NAME", String.class));
object.setParentId(resultSet.getObject("PARENT_ID", Long.class));
object.setLiabilitiesClaimsMoneyId(resultSet.getObject("LIABILITIES_CLAIMS_MONEY_ID", Long.class));
object.setClearingStatus(resultSet.getObject("CLEARING_STATUS", Long.class));
object.setPaymentId(resultSet.getObject("PAYMENT_ID", Long.class));
object.setRefundPaymentId(resultSet.getObject("REFUND_PAYMENT_ID", Long.class));
return object;
}
@Override
public Object[] objectToField(LiabilitiesClaimsAssets object) {
Object[] args = new Object[]{
object.getId(),
object.getCompanyId(),
TimeUtil.toDateFromInstant(object.getCreated()),
TimeUtil.toDateFromInstant(object.getUpdated()),
TimeUtil.toDateFromLocalDate(object.getClearingDate()),
object.getAccountId(),
object.getAccountType(),
object.getAccount(),
object.getLiabilitiesQuantity(),
object.getClaimsQuantity(),
object.getCurrency(),
TimeUtil.toDateFromLocalDate(object.getSettlementDate()),
TimeUtil.toDateFromLocalDate(object.getTradingDate()),
TimeUtil.toDateFromLocalDate(object.getRefundDate()),
object.getPrice(),
object.getSecurityId(),
object.getTradingCode(),
object.getClearingCode(),
object.getShortName(),
object.getContract(),
object.getComment(),
object.getFullName(),
object.getParentId(),
object.getLiabilitiesClaimsMoneyId(),
object.getClearingStatus(),
object.getPaymentId(),
object.getRefundPaymentId()
};
return args;
}
}

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

@ -1,95 +0,0 @@
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;
}
}

31
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/dictionary/BalanceAccountTypeDictionaryMapStore.java
View file

@ -1,31 +0,0 @@
package ru.spcex.clearing.imdg.dictionary;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.platform.dictionary.BalanceAccountTypeDictionary;
import ru.spcex.clearing.imdg.base.DictionaryTMapStore;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
@Component
public class BalanceAccountTypeDictionaryMapStore extends DictionaryTMapStore<BalanceAccountTypeDictionary> {
public BalanceAccountTypeDictionaryMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_BalanceAccountTypeDictionary;
}
@Override
public String getTableName() {
return "BALANCE_ACCOUNT_TYPE_DICTIONARY";
}
@Override
public BalanceAccountTypeDictionary getDictionaryObject() {
return new BalanceAccountTypeDictionary();
}
}

31
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/dictionary/ChargeDirectionDictionaryMapStore.java
View file

@ -1,31 +0,0 @@
package ru.spcex.clearing.imdg.dictionary;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.platform.dictionary.ChargeDirectionDictionary;
import ru.spcex.clearing.imdg.base.DictionaryTMapStore;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
@Component
public class ChargeDirectionDictionaryMapStore extends DictionaryTMapStore<ChargeDirectionDictionary> {
public ChargeDirectionDictionaryMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_ChargeDirectionDictionary;
}
@Override
public String getTableName() {
return "CHARGE_DIRECTION_DICTIONARY";
}
@Override
public ChargeDirectionDictionary getDictionaryObject() {
return new ChargeDirectionDictionary();
}
}

31
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/dictionary/ClearingStatusDictionaryMapStore.java
View file

@ -1,31 +0,0 @@
package ru.spcex.clearing.imdg.dictionary;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.platform.dictionary.ClearingStatusDictionary;
import ru.spcex.clearing.imdg.base.DictionaryTMapStore;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
@Component
public class ClearingStatusDictionaryMapStore extends DictionaryTMapStore<ClearingStatusDictionary> {
public ClearingStatusDictionaryMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_ClearingStatusDictionary;
}
@Override
public String getTableName() {
return "CLEARING_STATUS_DICTIONARY";
}
@Override
public ClearingStatusDictionary getDictionaryObject() {
return new ClearingStatusDictionary();
}
}

101
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/AdmittedDealRegisterMapStore.java
View file

@ -1,101 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.register.AdmittedDealRegister;
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 AdmittedDealRegisterMapStore extends TemplateMapStore<AdmittedDealRegister> {
public AdmittedDealRegisterMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getTableName() {
return "ADMITTED_DEAL_REGISTER";
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_AdmittedDealRegister;
}
@Override
public String[] getFields() {
return new String[]{"ID", "CREATED_AT", "UPDATED_AT",
"EXECUTION_ID",
"COMPANY_FULL_NAME",
"TRADING_DATE",
"EXCHANGE_EXECUTION_ID",
"EXCHANGE_EXECUTION_TIME",
"SECURITY_SYMBOL",
"SECURITY_FULL_NAME",
"SELLER_FULL_NAME",
"SELLER_CLEARING_CODE",
"SELLER_ACCOUNT",
"BUYER_FULL_NAME",
"BUYER_CLEARING_CODE",
"BUYER_ACCOUNT",
"AMOUNT",
"CLEARING_DATE",
};
}
@Override
protected AdmittedDealRegister objectReader(ResultSet resultSet) throws SQLException {
AdmittedDealRegister object = new AdmittedDealRegister();
object.setId(resultSet.getObject("ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setExecutionId(resultSet.getObject("EXECUTION_ID", Long.class));
object.setCompanyFullName(resultSet.getObject("COMPANY_FULL_NAME", String.class));
object.setTradingDate(getLocalDateFromSqlDate(resultSet, "TRADING_DATE"));
object.setExchangeExecutionId(resultSet.getObject("EXCHANGE_EXECUTION_ID", Long.class));
object.setExchangeExecutionTime(getInstantFromTimestamp(resultSet, "EXCHANGE_EXECUTION_TIME"));
object.setSecuritySymbol(resultSet.getObject("SECURITY_SYMBOL", String.class));
object.setSecurityFullName(resultSet.getObject("SECURITY_FULL_NAME", String.class));
object.setSellerFullName(resultSet.getObject("SELLER_FULL_NAME", String.class));
object.setSellerClearingCode(resultSet.getObject("SELLER_CLEARING_CODE", String.class));
object.setSellerAccount(resultSet.getObject("SELLER_ACCOUNT", String.class));
object.setBuyerFullName(resultSet.getObject("BUYER_FULL_NAME", String.class));
object.setBuyerClearingCode(resultSet.getObject("BUYER_CLEARING_CODE", String.class));
object.setBuyerAccount(resultSet.getObject("BUYER_ACCOUNT", String.class));
object.setAmount(resultSet.getObject("AMOUNT", BigDecimal.class));
object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE"));
return object;
}
@Override
protected Object[] objectToField(AdmittedDealRegister object) {
Object[] args = new Object[]{
object.getId(),
TimeUtil.toDateFromInstant(object.getCreated()),
TimeUtil.toDateFromInstant(object.getUpdated()),
object.getExecutionId(),
object.getCompanyFullName(),
TimeUtil.toDateFromLocalDate(object.getTradingDate()),
object.getExchangeExecutionId(),
TimeUtil.toDateFromInstant(object.getExchangeExecutionTime()),
object.getSecuritySymbol(),
object.getSecurityFullName(),
object.getSellerFullName(),
object.getSellerClearingCode(),
object.getSellerAccount(),
object.getBuyerFullName(),
object.getBuyerClearingCode(),
object.getBuyerAccount(),
object.getAmount(),
TimeUtil.toDateFromLocalDate(object.getClearingDate()),
};
return args;
}
}

98
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/BalanceRegisterMapStore.java
View file

@ -1,98 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.misc.BalanceRegister;
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 BalanceRegisterMapStore extends TemplateMapStore<BalanceRegister> {
public BalanceRegisterMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getTableName() {
return "BALANCE_REGISTER";
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_BalanceRegister;
}
@Override
public String[] getFields() {
return new String[]{"ID", "CREATED_AT", "UPDATED_AT",
"S_DF01_DATE",
"CURRENCY_CODE",
"SET_HOUSE_NAME",
"ACCOUNT",
"INFO_ACCOUNT",
"REMAINDER_SUM",
"BLOCKED_SUM",
"UNBLOCKED_SUM",
"INN",
"MARKET",
"FULL_NAME",
"TYPE_REMAINS",
"DOC_NUMBER",
"COMPANY_ID"
};
}
@Override
protected BalanceRegister objectReader(ResultSet resultSet) throws SQLException {
BalanceRegister object = new BalanceRegister();
object.setId(resultSet.getObject("ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setsDf01Date(getInstantFromTimestamp(resultSet, "S_DF01_DATE"));
object.setCurrencyCode(resultSet.getObject("CURRENCY_CODE", String.class));
object.setSetHouseName(resultSet.getObject("SET_HOUSE_NAME", String.class));
object.setAccount(resultSet.getObject("ACCOUNT", String.class));
object.setInfoAccount(resultSet.getObject("INFO_ACCOUNT", String.class));
object.setRemainderSum(resultSet.getObject("REMAINDER_SUM", BigDecimal.class));
object.setBlockedSum(resultSet.getObject("BLOCKED_SUM", BigDecimal.class));
object.setUnblockedSum(resultSet.getObject("UNBLOCKED_SUM", BigDecimal.class));
object.setInn(resultSet.getObject("INN", String.class));
object.setMarket(resultSet.getObject("MARKET", Long.class));
object.setFullName(resultSet.getObject("FULL_NAME", String.class));
object.setTypeRemains(resultSet.getObject("TYPE_REMAINS", String.class));
object.setDocNumber(resultSet.getObject("DOC_NUMBER", String.class));
object.setCompanyId(resultSet.getObject("COMPANY_ID", Long.class));
return object;
}
@Override
protected Object[] objectToField(BalanceRegister object) {
Object[] args = new Object[]{
object.getId(),
TimeUtil.toDateFromInstant(object.getCreated()),
TimeUtil.toDateFromInstant(object.getUpdated()),
TimeUtil.toDateFromInstant(object.getsDf01Date()),
object.getCurrencyCode(),
object.getSetHouseName(),
object.getAccount(),
object.getInfoAccount(),
object.getRemainderSum(),
object.getBlockedSum(),
object.getUnblockedSum(),
object.getInn(),
object.getMarket(),
object.getFullName(),
object.getTypeRemains(),
object.getDocNumber(),
object.getCompanyId()
};
return args;
}
}

130
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/ClearMemberRegisterMapStore.java
View file

@ -1,130 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.misc.ClearMemberRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.imdg.base.TemplateMapStore;
import ru.spcex.platform.utils.time.TimeUtil;
import java.sql.ResultSet;
import java.sql.SQLException;
@Component
public class ClearMemberRegisterMapStore extends TemplateMapStore<ClearMemberRegister> {
public ClearMemberRegisterMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getTableName() {
return "CLEARMEMBER_REGISTER";
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_ClearMemberRegister;
}
@Override
public String[] getFields() {
return new String[]{"ID", "CREATED_AT", "UPDATED_AT",
"TRADING_CODE",
"CLEARING_CODE",
"FULL_NAME",
"SHORT_NAME",
"CATEGORY_LIST",
"CORPORATION_SOLE",
"ACCOUNT",
"BANK",
"BANK_NAME",
"INN",
"BIC",
"OGRN",
"CPP",
"OCPO",
"CONTRACT_NUMBER",
"CONTRACT_DATE",
"REGISTRATION_DATE",
"SYSTEM_DATE",
"ACCESS_DATE",
"SUSPENTION_DATE",
"REOPENING_DATE",
"CLOSE_DATE",
"EXCLUSION_DATE",
"ADDRESS",
"EMAIL",
};
}
@Override
protected ClearMemberRegister objectReader(ResultSet resultSet) throws SQLException {
ClearMemberRegister object = new ClearMemberRegister();
object.setId(resultSet.getObject("ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setTradingCode(resultSet.getObject("TRADING_CODE", String.class));
object.setClearingCode(resultSet.getObject("CLEARING_CODE", String.class));
object.setFullName(resultSet.getObject("FULL_NAME", String.class));
object.setShortName(resultSet.getObject("SHORT_NAME", String.class));
object.setCategoryList(resultSet.getObject("CATEGORY_LIST", String.class));
object.setCorporationSole(resultSet.getObject("CORPORATION_SOLE", String.class));
object.setAccount(resultSet.getObject("ACCOUNT", String.class));
object.setBank(resultSet.getObject("BANK", Long.class));
object.setBankName(resultSet.getObject("BANK_NAME", String.class));
object.setInn(resultSet.getObject("INN", String.class));
object.setBic(resultSet.getObject("BIC", String.class));
object.setOgrn(resultSet.getObject("OGRN", String.class));
object.setCpp(resultSet.getObject("CPP", String.class));
object.setOcpo(resultSet.getObject("OCPO", String.class));
object.setContractNumber(resultSet.getObject("CONTRACT_NUMBER", String.class));
object.setContractDate(getLocalDateFromSqlDate(resultSet, "CONTRACT_DATE"));
object.setRegistrationDate(getLocalDateFromSqlDate(resultSet, "REGISTRATION_DATE"));
object.setSystemDate(getLocalDateFromSqlDate(resultSet, "SYSTEM_DATE"));
object.setAccessDate(getInstantFromTimestamp(resultSet, "ACCESS_DATE"));
object.setSuspentionDate(getInstantFromTimestamp(resultSet, "SUSPENTION_DATE"));
object.setReopeningDate(getInstantFromTimestamp(resultSet, "REOPENING_DATE"));
object.setCloseDate(getInstantFromTimestamp(resultSet, "CLOSE_DATE"));
object.setExclusionDate(getInstantFromTimestamp(resultSet, "EXCLUSION_DATE"));
object.setAddress(resultSet.getObject("ADDRESS", String.class));
object.setEmail(resultSet.getObject("EMAIL", String.class));
return object;
}
@Override
protected Object[] objectToField(ClearMemberRegister clearMemberRegister) {
Object[] args = new Object[]{
clearMemberRegister.getId(),
TimeUtil.toDateFromInstant(clearMemberRegister.getCreated()),
TimeUtil.toDateFromInstant(clearMemberRegister.getUpdated()),
clearMemberRegister.getTradingCode(),
clearMemberRegister.getClearingCode(),
clearMemberRegister.getFullName(),
clearMemberRegister.getShortName(),
clearMemberRegister.getCategoryList(),
clearMemberRegister.getCorporationSole(),
clearMemberRegister.getAccount(),
clearMemberRegister.getBank(),
clearMemberRegister.getBankName(),
clearMemberRegister.getInn(),
clearMemberRegister.getBic(),
clearMemberRegister.getOgrn(),
clearMemberRegister.getCpp(),
clearMemberRegister.getOcpo(),
clearMemberRegister.getContractNumber(),
TimeUtil.toDateFromLocalDate(clearMemberRegister.getContractDate()),
TimeUtil.toDateFromLocalDate(clearMemberRegister.getRegistrationDate()),
TimeUtil.toDateFromLocalDate(clearMemberRegister.getSystemDate()),
TimeUtil.toDateFromInstant(clearMemberRegister.getAccessDate()),
TimeUtil.toDateFromInstant(clearMemberRegister.getSuspentionDate()),
TimeUtil.toDateFromInstant(clearMemberRegister.getReopeningDate()),
TimeUtil.toDateFromInstant(clearMemberRegister.getCloseDate()),
TimeUtil.toDateFromInstant(clearMemberRegister.getExclusionDate()),
clearMemberRegister.getAddress(),
clearMemberRegister.getEmail()
};
return args;
}
}

101
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/CoveredDealRegisterMapStore.java
View file

@ -1,101 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.register.CoveredDealRegister;
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 CoveredDealRegisterMapStore extends TemplateMapStore<CoveredDealRegister> {
public CoveredDealRegisterMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getTableName() {
return "COVERED_DEAL_REGISTER";
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_CoveredDealRegister;
}
@Override
public String[] getFields() {
return new String[]{"ID", "CREATED_AT", "UPDATED_AT",
"EXECUTION_ID",
"COMPANY_FULL_NAME",
"TRADING_DATE",
"EXCHANGE_EXECUTION_ID",
"EXCHANGE_EXECUTION_TIME",
"SECURITY_SYMBOL",
"SECURITY_FULL_NAME",
"SELLER_FULL_NAME",
"SELLER_CLEARING_CODE",
"SELLER_ACCOUNT",
"BUYER_FULL_NAME",
"BUYER_CLEARING_CODE",
"BUYER_ACCOUNT",
"AMOUNT",
"CLEARING_DATE",
};
}
@Override
protected CoveredDealRegister objectReader(ResultSet resultSet) throws SQLException {
CoveredDealRegister object = new CoveredDealRegister();
object.setId(resultSet.getObject("ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setExecutionId(resultSet.getObject("EXECUTION_ID", Long.class));
object.setCompanyFullName(resultSet.getObject("COMPANY_FULL_NAME", String.class));
object.setTradingDate(getLocalDateFromSqlDate(resultSet, "TRADING_DATE"));
object.setExchangeExecutionId(resultSet.getObject("EXCHANGE_EXECUTION_ID", Long.class));
object.setExchangeExecutionTime(getInstantFromTimestamp(resultSet, "EXCHANGE_EXECUTION_TIME"));
object.setSecuritySymbol(resultSet.getObject("SECURITY_SYMBOL", String.class));
object.setSecurityFullName(resultSet.getObject("SECURITY_FULL_NAME", String.class));
object.setSellerFullName(resultSet.getObject("SELLER_FULL_NAME", String.class));
object.setSellerClearingCode(resultSet.getObject("SELLER_CLEARING_CODE", String.class));
object.setSellerAccount(resultSet.getObject("SELLER_ACCOUNT", String.class));
object.setBuyerFullName(resultSet.getObject("BUYER_FULL_NAME", String.class));
object.setBuyerClearingCode(resultSet.getObject("BUYER_CLEARING_CODE", String.class));
object.setBuyerAccount(resultSet.getObject("BUYER_ACCOUNT", String.class));
object.setAmount(resultSet.getObject("AMOUNT", BigDecimal.class));
object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE"));
return object;
}
@Override
protected Object[] objectToField(CoveredDealRegister object) {
Object[] args = new Object[]{
object.getId(),
TimeUtil.toDateFromInstant(object.getCreated()),
TimeUtil.toDateFromInstant(object.getUpdated()),
object.getExecutionId(),
object.getCompanyFullName(),
TimeUtil.toDateFromLocalDate(object.getTradingDate()),
object.getExchangeExecutionId(),
TimeUtil.toDateFromInstant(object.getExchangeExecutionTime()),
object.getSecuritySymbol(),
object.getSecurityFullName(),
object.getSellerFullName(),
object.getSellerClearingCode(),
object.getSellerAccount(),
object.getBuyerFullName(),
object.getBuyerClearingCode(),
object.getBuyerAccount(),
object.getAmount(),
TimeUtil.toDateFromLocalDate(object.getClearingDate()),
};
return args;
}
}

116
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/DealRegisterMapStore.java
View file

@ -1,116 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.register.DealRegister;
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 DealRegisterMapStore extends TemplateMapStore<DealRegister> {
public DealRegisterMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getTableName() {
return "DEAL_REGISTER";
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_DealRegister;
}
@Override
public String[] getFields() {
return new String[]{"ID", "CREATED_AT", "UPDATED_AT",
"EXECUTION_ID",
"EXCHANGE_EXECUTION_ID",
"EXCHANGE_EXECUTION_TIME",
"TRADING_DATE",
"ACCOUNT",
"MARKET",
"PRICE",
"AMOUNT",
"SIDE",
"SETTLEMENT_CURRENCY",
"COMPANY_ID",
"FIRST_LEG_SETTLEMENT_DATE",
"SECOND_LEG_SETTLEMENT_DATE",
"SECURITY_FULL_NAME",
"SECURITY_SYMBOL",
"SECURITY_ID",
"COUNTER_PARTY_ID",
"COVERAGE_STATUS",
"SESSION_ID",
"CLEARING_DATE",
};
}
@Override
protected DealRegister objectReader(ResultSet resultSet) throws SQLException {
DealRegister object = new DealRegister();
object.setId(resultSet.getObject("ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setExecutionId(resultSet.getObject("EXECUTION_ID", Long.class));
object.setExchangeExecutionId(resultSet.getObject("EXCHANGE_EXECUTION_ID", Long.class));
object.setExchangeExecutionTime(getInstantFromTimestamp(resultSet, "EXCHANGE_EXECUTION_TIME"));
object.setTradingDate(getLocalDateFromSqlDate(resultSet, "TRADING_DATE"));
object.setAccount(resultSet.getObject("ACCOUNT", String.class));
object.setMarket(resultSet.getObject("MARKET", String.class));
object.setPrice(resultSet.getObject("PRICE", BigDecimal.class));
object.setAmount(resultSet.getObject("AMOUNT", BigDecimal.class));
object.setSide(resultSet.getObject("SIDE", String.class));
object.setSettlementCurrency(resultSet.getObject("SETTLEMENT_CURRENCY", String.class));
object.setCompanyId(resultSet.getObject("COMPANY_ID", Long.class));
object.setFirstLegSettlementDate(getLocalDateFromSqlDate(resultSet, "FIRST_LEG_SETTLEMENT_DATE"));
object.setSecondLegSettlementDate(getLocalDateFromSqlDate(resultSet, "SECOND_LEG_SETTLEMENT_DATE"));
object.setSecurityFullName(resultSet.getObject("SECURITY_FULL_NAME", String.class));
object.setSecuritySymbol(resultSet.getObject("SECURITY_SYMBOL", String.class));
object.setSecurityId(resultSet.getObject("SECURITY_ID", Long.class));
object.setCounterPartyId(resultSet.getObject("COUNTER_PARTY_ID", Long.class));
object.setCoverageStatus(resultSet.getObject("COVERAGE_STATUS", String.class));
object.setSessionId(resultSet.getObject("SESSION_ID", Long.class));
object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE"));
return object;
}
@Override
protected Object[] objectToField(DealRegister object) {
Object[] args = new Object[]{
object.getId(),
TimeUtil.toDateFromInstant(object.getCreated()),
TimeUtil.toDateFromInstant(object.getUpdated()),
object.getExecutionId(),
object.getExchangeExecutionId(),
TimeUtil.toDateFromInstant(object.getExchangeExecutionTime()),
TimeUtil.toDateFromLocalDate(object.getTradingDate()),
object.getAccount(),
object.getMarket(),
object.getPrice(),
object.getAmount(),
object.getSide(),
object.getSettlementCurrency(),
object.getCompanyId(),
TimeUtil.toDateFromLocalDate(object.getFirstLegSettlementDate()),
TimeUtil.toDateFromLocalDate(object.getSecondLegSettlementDate()),
object.getSecurityFullName(),
object.getSecuritySymbol(),
object.getSecurityId(),
object.getCounterPartyId(),
object.getCoverageStatus(),
object.getSessionId(),
TimeUtil.toDateFromLocalDate(object.getClearingDate()),
};
return args;
}
}

66
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/KeyRateMapStore.java
View file

@ -1,66 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.misc.KeyRate;
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 KeyRateMapStore extends TemplateMapStore<KeyRate> {
public KeyRateMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getTableName() {
return "KEY_RATE";
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_KeyRate;
}
@Override
public String[] getIndexingField() {
return new String[]{"startDate", "endDate"};
}
@Override
public String[] getFields() {
return new String[]{"id", "rate", "start_date", "end_date", "document", "workflow_status"};
}
@Override
protected KeyRate objectReader(ResultSet resultSet) throws SQLException {
KeyRate keyRate = new KeyRate();
keyRate.setId(resultSet.getObject("ID", Long.class));
keyRate.setRate(resultSet.getObject("RATE", BigDecimal.class));
keyRate.setStartDate(getLocalDateFromSqlDate(resultSet, "START_DATE"));
keyRate.setEndDate(getLocalDateFromSqlDate(resultSet, "END_DATE"));
keyRate.setDocument(resultSet.getObject("DOCUMENT", String.class));
keyRate.setWorkflowStatus(resultSet.getObject("WORKFLOW_STATUS", String.class));
return keyRate;
}
@Override
protected Object[] objectToField(KeyRate partnerList) {
Object[] args = new Object[]{
partnerList.getId(),
partnerList.getRate(),
TimeUtil.toDateFromLocalDate(partnerList.getStartDate()),
TimeUtil.toDateFromLocalDate(partnerList.getEndDate()),
partnerList.getDocument(),
partnerList.getWorkflowStatus()
};
return args;
}
}

83
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/OrderRegisterMapStore.java
View file

@ -1,83 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.register.OrderRegister;
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 OrderRegisterMapStore extends TemplateMapStore<OrderRegister> {
public OrderRegisterMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getTableName() {
return "ORDER_REGISTER";
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_OrderRegister;
}
@Override
public String[] getFields() {
return new String[]{"ID", "CREATED_AT", "UPDATED_AT",
"CREDIT_LEG_ACCOUNT",
"CREDIT_LEG_AMOUNT",
"CREDIT_LEG_CURRENCY_CODE",
"CREDIT_LEG_DIRECTION",
"DEBIT_LEG_ACCOUNT",
"SENDER",
"ADDRESSEE",
"DOCUMENT_NUMBER",
"CLEARING_DATE",
};
}
@Override
protected OrderRegister objectReader(ResultSet resultSet) throws SQLException {
OrderRegister object = new OrderRegister();
object.setId(resultSet.getObject("ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setCreditLegAccount(resultSet.getObject("CREDIT_LEG_ACCOUNT", String.class));
object.setCreditLegAmount(resultSet.getObject("CREDIT_LEG_AMOUNT", BigDecimal.class));
object.setCreditLegCurrencyCode(resultSet.getObject("CREDIT_LEG_CURRENCY_CODE", String.class));
object.setCreditLegDirection(resultSet.getObject("CREDIT_LEG_DIRECTION", Long.class));
object.setDebitLegAccount(resultSet.getObject("DEBIT_LEG_ACCOUNT", String.class));
object.setSender(resultSet.getObject("SENDER", String.class));
object.setAddressee(resultSet.getObject("ADDRESSEE", String.class));
object.setDocumentNumber(resultSet.getObject("DOCUMENT_NUMBER", String.class));
object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE"));
return object;
}
@Override
protected Object[] objectToField(OrderRegister object) {
Object[] args = new Object[]{
object.getId(),
TimeUtil.toDateFromInstant(object.getCreated()),
TimeUtil.toDateFromInstant(object.getUpdated()),
object.getCreditLegAccount(),
object.getCreditLegAmount(),
object.getCreditLegCurrencyCode(),
object.getCreditLegDirection(),
object.getDebitLegAccount(),
object.getSender(),
object.getAddressee(),
object.getDocumentNumber(),
TimeUtil.toDateFromLocalDate(object.getClearingDate()),
};
return args;
}
}

75
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/SDf16MapStore.java
View file

@ -1,75 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.sdf.SDf16;
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 SDf16MapStore extends TemplateMapStore<SDf16> {
public SDf16MapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_SDf16;
}
@Override
public String getTableName() {
return "S_DF16";
}
@Override
public String[] getFields() {
return new String[]{
"ID", "ACCOUNT", "SUM", "MARKET", "TYPE", "INN", "BIC", "SPEC", "NUMBER", "FILE_NAME", "GENERATION_TIME", "GENERATION_ID"
};
}
@Override
public SDf16 objectReader(ResultSet resultSet) throws SQLException {
SDf16 object = new SDf16();
object.setId(resultSet.getObject("ID", Long.class));
object.setAccount(resultSet.getObject("ACCOUNT", String.class));
object.setSum(resultSet.getObject("SUM", BigDecimal.class));
object.setMarket(resultSet.getObject("MARKET", String.class));
object.setType(resultSet.getObject("TYPE", String.class));
object.setInn(resultSet.getObject("INN", BigDecimal.class));
object.setBic(resultSet.getObject("BIC", BigDecimal.class));
object.setSpec(resultSet.getObject("SPEC", String.class));
object.setNumber(resultSet.getObject("NUMBER", BigDecimal.class));
object.setFileName(resultSet.getObject("FILE_NAME", String.class));
object.setGenerationTime(getInstantFromTimestamp(resultSet, "GENERATION_TIME"));
object.setGenerationId(resultSet.getObject("GENERATION_ID", Long.class));
return object;
}
@Override
public Object[] objectToField(SDf16 object) {
Object[] args = new Object[]{
object.getId(),
object.getAccount(),
object.getSum(),
object.getMarket(),
object.getType(),
object.getInn(),
object.getBic(),
object.getSpec(),
object.getNumber(),
object.getFileName(),
TimeUtil.toDateFromInstant(object.getGenerationTime()),
object.getGenerationId()
};
return args;
}
}

77
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/SDf17MapStore.java
View file

@ -1,77 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.sdf.SDf17;
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 SDf17MapStore extends TemplateMapStore<SDf17> {
public SDf17MapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_SDf17;
}
@Override
public String getTableName() {
return "S_DF17";
}
@Override
public String[] getFields() {
return new String[]{
"ID", "ACCOUNT", "SUM", "MARKET", "TYPE", "INN", "BIC", "SPEC", "NUMBER", "RESULT", "GENERATION_TIME", "GENERATION_ID", "IN_S_DF16_ID"
};
}
@Override
public SDf17 objectReader(ResultSet resultSet) throws SQLException {
SDf17 object = new SDf17();
object.setId(resultSet.getObject("ID", Long.class));
object.setAccount(resultSet.getObject("ACCOUNT", String.class));
object.setSum(resultSet.getObject("SUM", BigDecimal.class));
object.setMarket(resultSet.getObject("MARKET", String.class));
object.setType(resultSet.getObject("TYPE", String.class));
object.setInn(resultSet.getObject("INN", BigDecimal.class));
object.setBic(resultSet.getObject("BIC", BigDecimal.class));
object.setSpec(resultSet.getObject("SPEC", String.class));
object.setNumber(resultSet.getObject("NUMBER", BigDecimal.class));
object.setResult(resultSet.getObject("RESULT", BigDecimal.class));
object.setGenerationTime(getInstantFromTimestamp(resultSet, "GENERATION_TIME"));
object.setGenerationId(resultSet.getObject("GENERATION_ID", Long.class));
object.setInSDf16Id(resultSet.getObject("IN_S_DF16_ID", Long.class));
return object;
}
@Override
public Object[] objectToField(SDf17 object) {
Object[] args = new Object[]{
object.getId(),
object.getAccount(),
object.getSum(),
object.getMarket(),
object.getType(),
object.getInn(),
object.getBic(),
object.getSpec(),
object.getNumber(),
object.getResult(),
TimeUtil.toDateFromInstant(object.getGenerationTime()),
object.getGenerationId(),
object.getInSDf16Id()
};
return args;
}
}

67
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/SDf18MapStore.java
View file

@ -1,67 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.sdf.SDf18;
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 SDf18MapStore extends TemplateMapStore<SDf18> {
public SDf18MapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_SDf18;
}
@Override
public String getTableName() {
return "S_DF18";
}
@Override
public String[] getFields() {
return new String[]{
"ID", "ACCOUNT", "DEAL", "STATUS", "RESULT", "GENERATION_TIME", "GENERATION_ID", "IN_S_DF12_ID"
};
}
@Override
public SDf18 objectReader(ResultSet resultSet) throws SQLException {
SDf18 object = new SDf18();
object.setId(resultSet.getObject("ID", Long.class));
object.setAccount(resultSet.getObject("ACCOUNT", String.class));
object.setDeal(resultSet.getObject("DEAL", String.class));
object.setStatus(resultSet.getObject("STATUS", Long.class));
object.setResult(resultSet.getObject("RESULT", BigDecimal.class));
object.setGenerationTime(getInstantFromTimestamp(resultSet, "GENERATION_TIME"));
object.setGenerationId(resultSet.getObject("GENERATION_ID", Long.class));
object.setInSDf12Id(resultSet.getObject("IN_S_DF12_ID", Long.class));
return object;
}
@Override
public Object[] objectToField(SDf18 object) {
Object[] args = new Object[]{
object.getId(),
object.getAccount(),
object.getDeal(),
object.getStatus(),
object.getResult(),
TimeUtil.toDateFromInstant(object.getGenerationTime()),
object.getGenerationId(),
object.getInSDf12Id()
};
return args;
}
}

104
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/object/UncoveredDealRegisterMapStore.java
View file

@ -1,104 +0,0 @@
package ru.spcex.clearing.imdg.object;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import ru.clearing.classes.statics.data.register.UncoveredDealRegister;
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 UncoveredDealRegisterMapStore extends TemplateMapStore<UncoveredDealRegister> {
public UncoveredDealRegisterMapStore(JdbcTemplate jdbcTemplate) {
super(jdbcTemplate);
}
@Override
public String getTableName() {
return "UNCOVERED_DEAL_REGISTER";
}
@Override
public String getMapName() {
return IMDGDistributedNames.Map_UncoveredDealRegister;
}
@Override
public String[] getFields() {
return new String[]{"ID", "CREATED_AT", "UPDATED_AT",
"EXECUTION_ID",
"COMPANY_FULL_NAME",
"TRADING_DATE",
"EXCHANGE_EXECUTION_ID",
"EXCHANGE_EXECUTION_TIME",
"SECURITY_SYMBOL",
"SECURITY_FULL_NAME",
"SELLER_FULL_NAME",
"SELLER_CLEARING_CODE",
"SELLER_ACCOUNT",
"BUYER_FULL_NAME",
"BUYER_CLEARING_CODE",
"BUYER_ACCOUNT",
"AMOUNT",
"RESULT_STATUS",
"CLEARING_DATE",
};
}
@Override
protected UncoveredDealRegister objectReader(ResultSet resultSet) throws SQLException {
UncoveredDealRegister object = new UncoveredDealRegister();
object.setId(resultSet.getObject("ID", Long.class));
object.setCreated(getInstantFromTimestamp(resultSet, "CREATED_AT"));
object.setUpdated(getInstantFromTimestamp(resultSet, "UPDATED_AT"));
object.setExecutionId(resultSet.getObject("EXECUTION_ID", Long.class));
object.setCompanyFullName(resultSet.getObject("COMPANY_FULL_NAME", String.class));
object.setTradingDate(getLocalDateFromSqlDate(resultSet, "TRADING_DATE"));
object.setExchangeExecutionId(resultSet.getObject("EXCHANGE_EXECUTION_ID", Long.class));
object.setExchangeExecutionTime(getInstantFromTimestamp(resultSet, "EXCHANGE_EXECUTION_TIME"));
object.setSecuritySymbol(resultSet.getObject("SECURITY_SYMBOL", String.class));
object.setSecurityFullName(resultSet.getObject("SECURITY_FULL_NAME", String.class));
object.setSellerFullName(resultSet.getObject("SELLER_FULL_NAME", String.class));
object.setSellerClearingCode(resultSet.getObject("SELLER_CLEARING_CODE", String.class));
object.setSellerAccount(resultSet.getObject("SELLER_ACCOUNT", String.class));
object.setBuyerFullName(resultSet.getObject("BUYER_FULL_NAME", String.class));
object.setBuyerClearingCode(resultSet.getObject("BUYER_CLEARING_CODE", String.class));
object.setBuyerAccount(resultSet.getObject("BUYER_ACCOUNT", String.class));
object.setAmount(resultSet.getObject("AMOUNT", BigDecimal.class));
object.setResultStatus(resultSet.getObject("RESULT_STATUS", String.class));
object.setClearingDate(getLocalDateFromSqlDate(resultSet, "CLEARING_DATE"));
return object;
}
@Override
protected Object[] objectToField(UncoveredDealRegister object) {
Object[] args = new Object[]{
object.getId(),
TimeUtil.toDateFromInstant(object.getCreated()),
TimeUtil.toDateFromInstant(object.getUpdated()),
object.getExecutionId(),
object.getCompanyFullName(),
TimeUtil.toDateFromLocalDate(object.getTradingDate()),
object.getExchangeExecutionId(),
TimeUtil.toDateFromInstant(object.getExchangeExecutionTime()),
object.getSecuritySymbol(),
object.getSecurityFullName(),
object.getSellerFullName(),
object.getSellerClearingCode(),
object.getSellerAccount(),
object.getBuyerFullName(),
object.getBuyerClearingCode(),
object.getBuyerAccount(),
object.getAmount(),
object.getResultStatus(),
TimeUtil.toDateFromLocalDate(object.getClearingDate()),
};
return args;
}
}

30
clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/structure/RunnableMapNamesForTesting.java
View file

@ -13,8 +13,6 @@ import ru.clearing.classes.statics.data.instrument.issue.*;
import ru.clearing.classes.statics.data.journal.InDocumentJournal; import ru.clearing.classes.statics.data.journal.InDocumentJournal;
import ru.clearing.classes.statics.data.journal.ManagementJournal; import ru.clearing.classes.statics.data.journal.ManagementJournal;
import ru.clearing.classes.statics.data.journal.OutDocumentJournal; import ru.clearing.classes.statics.data.journal.OutDocumentJournal;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney;
import ru.clearing.classes.statics.data.messages.ErrorText; import ru.clearing.classes.statics.data.messages.ErrorText;
import ru.clearing.classes.statics.data.misc.*; import ru.clearing.classes.statics.data.misc.*;
import ru.clearing.classes.statics.data.payment.PaymentInstruction; import ru.clearing.classes.statics.data.payment.PaymentInstruction;
@ -148,10 +146,6 @@ public class RunnableMapNamesForTesting {
new SettingOperation("setQuantity", new Object[]{new BigDecimal("852.64")}), new SettingOperation("setQuantity", new Object[]{new BigDecimal("852.64")}),
new SettingOperation("setSettlementAmount", new Object[]{new BigDecimal("853.64")}))); new SettingOperation("setSettlementAmount", new Object[]{new BigDecimal("853.64")})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Launcher, Launcher.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Launcher, Launcher.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_LiabilitiesClaimsAssets, LiabilitiesClaimsAssets.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_LiabilitiesClaimsMoney, LiabilitiesClaimsMoney.class,
new SettingOperation("setClaimsAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("04.92")}),
new SettingOperation("setLiabilitiesAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("06.26")})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Listing, Listing.class, checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Listing, Listing.class,
new SettingOperation("setLotSize", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("21.11")}))); new SettingOperation("setLotSize", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("21.11")})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ManagementJournal, ManagementJournal.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ManagementJournal, ManagementJournal.class));
@ -191,10 +185,7 @@ public class RunnableMapNamesForTesting {
//dictionary //dictionary
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.class)); checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.class));
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_AllowedDictionary, AllowedDictionary.class)); checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_AllowedDictionary, AllowedDictionary.class));
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_BalanceAccountTypeDictionary, BalanceAccountTypeDictionary.class));
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ChargeDirectionDictionary, ChargeDirectionDictionary.class));
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ClearingCategoryDictionary, ClearingCategoryDictionary.class)); checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ClearingCategoryDictionary, ClearingCategoryDictionary.class));
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ClearingStatusDictionary, ClearingStatusDictionary.class));
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CompanyRoleDictionary, CompanyRoleDictionary.class)); checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CompanyRoleDictionary, CompanyRoleDictionary.class));
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CompanySymbolDictionary, CompanySymbolDictionary.class)); checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CompanySymbolDictionary, CompanySymbolDictionary.class));
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ConnectionStateDictionary, ConnectionStateDictionary.class)); checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ConnectionStateDictionary, ConnectionStateDictionary.class));
@ -248,28 +239,15 @@ public class RunnableMapNamesForTesting {
checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ClearingAccountTypeDictionary, ClearingAccountTypeDictionary.class)); checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ClearingAccountTypeDictionary, ClearingAccountTypeDictionary.class));
//object //object
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_AdmittedDealRegister, AdmittedDealRegister.class,
new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_BankAccount, BankAccount.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_BankAccount, BankAccount.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ClearMemberRegister, ClearMemberRegister.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Contact, Contact.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Contact, Contact.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ContractRegister, ContractRegister.class, checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ContractRegister, ContractRegister.class,
new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}), new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}))); new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CoveredDealRegister, CoveredDealRegister.class,
new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Currency, Currency.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Currency, Currency.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_DealRegister, DealRegister.class,
new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class, checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class,
new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}), new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}), new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
@ -298,7 +276,6 @@ public class RunnableMapNamesForTesting {
//new SettingOperation("setNominalValue", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("25.25")}) //new SettingOperation("setNominalValue", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("25.25")})
)); ));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Notification, Notification.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Notification, Notification.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_OrderRegister, OrderRegister.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_OutDocumentJournal, OutDocumentJournal.class, checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_OutDocumentJournal, OutDocumentJournal.class,
new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("28.28")}))); new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("28.28")})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class));
@ -318,9 +295,6 @@ public class RunnableMapNamesForTesting {
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf11, SDf11.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf11, SDf11.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf12, SDf12.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf12, SDf12.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf13, SDf13.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf13, SDf13.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf16, SDf16.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf17, SDf17.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf18, SDf18.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Session, Session.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Session, Session.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_STrades, STrades.class, checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_STrades, STrades.class,
new SettingOperation("setQty", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}), new SettingOperation("setQty", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
@ -329,10 +303,6 @@ public class RunnableMapNamesForTesting {
new SettingOperation("setQty", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)}), new SettingOperation("setQty", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)}),
new SettingOperation("setValue", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)}) new SettingOperation("setValue", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)})
)); ));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UncoveredDealRegister, UncoveredDealRegister.class,
new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserRoleSession, UserRoleSession.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserRoleSession, UserRoleSession.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserSettings, UserSettings.class)); checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserSettings, UserSettings.class));
checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_VerificationResult, VerificationResult.class, checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_VerificationResult, VerificationResult.class,

63
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/AdmittedDealRegisterService.java
View file

@ -1,63 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.producer.Producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.register.AdmittedDealRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.AdmittedDealRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
@Service
public class AdmittedDealRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<AdmittedDealRegister> admittedDealRegisterMap;
@Autowired
public AdmittedDealRegisterService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.admittedDealRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_AdmittedDealRegister, AdmittedDealRegister.class);
}
@Override
public void afterPropertiesSet() {
callback(AdmittedDealRegisterNewRequest.class)
.setConsumer(this::admittedDealRegisterNew)
.forDestination(Consts.REGISTRY_ADMITTED_DEAL_REGISTER_NEW, callbacks::put);
init();
}
public void admittedDealRegisterNew(BaseRequest<AdmittedDealRegisterNewRequest> userRequest) {
AdmittedDealRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("AdmittedDealRegisterNewRequest received");
AdmittedDealRegister register = new AdmittedDealRegister();
register.setExecutionId(req.getExecutionId());
register.setCompanyFullName(req.getCompanyFullName());
register.setTradingDate(req.getTradingDate());
register.setExchangeExecutionId(req.getExchangeExecutionId());
register.setExchangeExecutionTime(req.getExchangeExecutionTime());
register.setSecuritySymbol(req.getSecuritySymbol());
register.setSecurityFullName(req.getSecurityFullName());
register.setSellerFullName(req.getSellerFullName());
register.setSellerClearingCode(req.getSellerClearingCode());
register.setSellerAccount(req.getSellerAccount());
register.setBuyerFullName(req.getBuyerFullName());
register.setBuyerClearingCode(req.getBuyerClearingCode());
register.setBuyerAccount(req.getBuyerAccount());
register.setAmount(req.getAmount());
register.setClearingDate(req.getClearingDate());
admittedDealRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
}
}

62
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/BalanceRegisterService.java
View file

@ -1,62 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.producer.Producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.misc.BalanceRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.BalanceRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
@Service
public class BalanceRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<BalanceRegister> balanceRegisterMap;
@Autowired
public BalanceRegisterService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.balanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_BalanceRegister, BalanceRegister.class);
}
@Override
public void afterPropertiesSet() {
callback(BalanceRegisterNewRequest.class)
.setConsumer(this::balanceRegisterNew)
.forDestination(Consts.REGISTRY_BALANCE_REGISTER_NEW, callbacks::put);
init();
}
public void balanceRegisterNew(BaseRequest<BalanceRegisterNewRequest> userRequest) {
BalanceRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("BalanceRegisterNewRequest received");
BalanceRegister register = new BalanceRegister();
register.setsDf01Date(req.getsDf01Date());
register.setCurrencyCode(req.getCurrencyCode());
register.setSetHouseName(req.getSetHouseName());
register.setAccount(req.getAccount());
register.setInfoAccount(req.getInfoAccount());
register.setRemainderSum(req.getRemainderSum());
register.setBlockedSum(req.getBlockedSum());
register.setUnblockedSum(req.getUnblockedSum());
register.setInn(req.getInn());
register.setMarket(req.getMarket());
register.setFullName(req.getFullName());
register.setTypeRemains(req.getTypeRemains());
register.setDocNumber(req.getDocNumber());
register.setCompanyId(req.getCompanyId());
balanceRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
}
}

51
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ClearMemberRegisterChangeService.java
View file

@ -1,51 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.producer.Producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.register.ClearMemberRegisterChange;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.ClearMemberRegisterChangeNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
@Service
public class ClearMemberRegisterChangeService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<ClearMemberRegisterChange> clearMemberRegisterChangeMap;
@Autowired
public ClearMemberRegisterChangeService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.clearMemberRegisterChangeMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearMemberRegisterChange, ClearMemberRegisterChange.class);
}
@Override
public void afterPropertiesSet() {
callback(ClearMemberRegisterChangeNewRequest.class)
.setConsumer(this::clearMemberRegisterChangeNew)
.forDestination(Consts.REGISTRY_CLEAR_MEMBER_REGISTER_CHANGE_NEW, callbacks::put);
init();
}
public void clearMemberRegisterChangeNew(BaseRequest<ClearMemberRegisterChangeNewRequest> userRequest) {
ClearMemberRegisterChangeNewRequest req = userRequest.getRequestPayload();
log.debug("ClearMemberRegisterChangeNewRequest received");
ClearMemberRegisterChange register = new ClearMemberRegisterChange();
register.setDate(req.getDate());
register.setComment(req.getComment());
register.setClearingCode(req.getClearingCode());
clearMemberRegisterChangeMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
}
}

73
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ClearMemberRegisterService.java
View file

@ -1,73 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.producer.Producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.misc.ClearMemberRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.ClearMemberRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
@Service
public class ClearMemberRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<ClearMemberRegister> clearMemberRegisterMap;
@Autowired
public ClearMemberRegisterService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.clearMemberRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearMemberRegister, ClearMemberRegister.class);
}
@Override
public void afterPropertiesSet() {
callback(ClearMemberRegisterNewRequest.class)
.setConsumer(this::clearMemberRegisterNew)
.forDestination(Consts.REGISTRY_CLEAR_MEMBER_REGISTER_NEW, callbacks::put);
init();
}
public void clearMemberRegisterNew(BaseRequest<ClearMemberRegisterNewRequest> userRequest) {
ClearMemberRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("ClearMemberRegisterNewRequest received");
ClearMemberRegister register = new ClearMemberRegister();
register.setTradingCode(req.getTradingCode());
register.setClearingCode(req.getClearingCode());
register.setFullName(req.getFullName());
register.setShortName(req.getShortName());
register.setCategoryList(req.getCategoryList());
register.setCorporationSole(req.getCorporationSole());
register.setAccount(req.getAccount());
register.setBank(req.getBank());
register.setBankName(req.getBankName());
register.setInn(req.getInn());
register.setBic(req.getBic());
register.setOgrn(req.getOgrn());
register.setCpp(req.getCpp());
register.setOcpo(req.getOcpo());
register.setContractNumber(req.getContractNumber());
register.setContractDate(req.getContractDate());
register.setRegistrationDate(req.getRegistrationDate());
register.setSystemDate(req.getSystemDate());
register.setAccessDate(req.getAccessDate());
register.setSuspentionDate(req.getSuspentionDate());
register.setReopeningDate(req.getReopeningDate());
register.setCloseDate(req.getCloseDate());
register.setExclusionDate(req.getExclusionDate());
register.setAddress(req.getAddress());
register.setEmail(req.getEmail());
clearMemberRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
}
}

63
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/CoveredDealRegisterService.java
View file

@ -1,63 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.producer.Producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.register.CoveredDealRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.CoveredDealRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
@Service
public class CoveredDealRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<CoveredDealRegister> coveredDealRegisterMap;
@Autowired
public CoveredDealRegisterService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.coveredDealRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CoveredDealRegister, CoveredDealRegister.class);
}
@Override
public void afterPropertiesSet() {
callback(CoveredDealRegisterNewRequest.class)
.setConsumer(this::coveredDealRegisterNew)
.forDestination(Consts.REGISTRY_COVERED_DEAL_REGISTER_NEW, callbacks::put);
init();
}
public void coveredDealRegisterNew(BaseRequest<CoveredDealRegisterNewRequest> userRequest) {
CoveredDealRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("CoveredDealRegisterNewRequest received");
CoveredDealRegister register = new CoveredDealRegister();
register.setExecutionId(req.getExecutionId());
register.setCompanyFullName(req.getCompanyFullName());
register.setTradingDate(req.getTradingDate());
register.setExchangeExecutionId(req.getExchangeExecutionId());
register.setExchangeExecutionTime(req.getExchangeExecutionTime());
register.setSecuritySymbol(req.getSecuritySymbol());
register.setSecurityFullName(req.getSecurityFullName());
register.setSellerFullName(req.getSellerFullName());
register.setSellerClearingCode(req.getSellerClearingCode());
register.setSellerAccount(req.getSellerAccount());
register.setBuyerFullName(req.getBuyerFullName());
register.setBuyerClearingCode(req.getBuyerClearingCode());
register.setBuyerAccount(req.getBuyerAccount());
register.setAmount(req.getAmount());
register.setClearingDate(req.getClearingDate());
coveredDealRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
}
}

56
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/OrderRegisterService.java
View file

@ -1,56 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.producer.Producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.register.OrderRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.OrderRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
@Service
public class OrderRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<OrderRegister> orderRegisterMap;
@Autowired
public OrderRegisterService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.orderRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_OrderRegister, OrderRegister.class);
}
@Override
public void afterPropertiesSet() {
callback(OrderRegisterNewRequest.class)
.setConsumer(this::orderRegisterNew)
.forDestination(Consts.REGISTRY_ORDER_REGISTER_NEW, callbacks::put);
init();
}
public void orderRegisterNew(BaseRequest<OrderRegisterNewRequest> userRequest) {
OrderRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("OrderRegisterNewRequest received");
OrderRegister register = new OrderRegister();
register.setCreditLegAccount(req.getCreditLegAccount());
register.setCreditLegAmount(req.getCreditLegAmount());
register.setCreditLegCurrencyCode(req.getCreditLegCurrencyCode());
register.setCreditLegDirection(req.getCreditLegDirection());
register.setDebitLegAccount(req.getDebitLegAccount());
register.setSender(req.getSender());
register.setAddressee(req.getAddressee());
register.setDocumentNumber(req.getDocumentNumber());
register.setClearingDate(req.getClearingDate());
orderRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
}
}

63
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/UncoveredDealRegisterService.java
View file

@ -1,63 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.producer.Producer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.register.UncoveredDealRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.UncoveredDealRegisterNewRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
@Service
public class UncoveredDealRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<UncoveredDealRegister> uncoveredDealRegisterMap;
@Autowired
public UncoveredDealRegisterService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.uncoveredDealRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_UncoveredDealRegister, UncoveredDealRegister.class);
}
@Override
public void afterPropertiesSet() {
callback(UncoveredDealRegisterNewRequest.class)
.setConsumer(this::uncoveredDealRegisterNew)
.forDestination(Consts.REGISTRY_UNCOVERED_DEAL_REGISTER_NEW, callbacks::put);
init();
}
public void uncoveredDealRegisterNew(BaseRequest<UncoveredDealRegisterNewRequest> userRequest) {
UncoveredDealRegisterNewRequest req = userRequest.getRequestPayload();
log.debug("UncoveredDealRegisterNewRequest received");
UncoveredDealRegister register = new UncoveredDealRegister();
register.setExecutionId(req.getExecutionId());
register.setCompanyFullName(req.getCompanyFullName());
register.setTradingDate(req.getTradingDate());
register.setExchangeExecutionId(req.getExchangeExecutionId());
register.setExchangeExecutionTime(req.getExchangeExecutionTime());
register.setSecuritySymbol(req.getSecuritySymbol());
register.setSecurityFullName(req.getSecurityFullName());
register.setSellerFullName(req.getSellerFullName());
register.setSellerClearingCode(req.getSellerClearingCode());
register.setSellerAccount(req.getSellerAccount());
register.setBuyerFullName(req.getBuyerFullName());
register.setBuyerClearingCode(req.getBuyerClearingCode());
register.setBuyerAccount(req.getBuyerAccount());
register.setAmount(req.getAmount());
register.setResultStatus(req.getResultStatus());
register.setClearingDate(req.getClearingDate());
uncoveredDealRegisterMap.insert(register);
log.debug("successfully processed, id {}", register.getId());
}
}

118
clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/AdmittedDealRegisterServiceTest.java
View file

@ -1,118 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.register.AdmittedDealRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.AdmittedDealRegisterNewRequest;
import ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.registry.config.KafkaConfigTest;
import ru.spcex.clearing.registry.utils.MatcherFactory;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
import static ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration.currentID;
import static ru.spcex.clearing.registry.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.registry.utils.TestUtils.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
AdmittedDealRegisterService.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
class AdmittedDealRegisterServiceTest {
public static final MatcherFactory.Matcher<AdmittedDealRegister> ADMITTED_DEAL_REGISTER_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final String TOPIC_REGISTRY_ADMITTED_DEAL_REGISTER_NEW = Consts.REGISTRY_ADMITTED_DEAL_REGISTER_NEW;
private static final Long ID = currentID.getAndIncrement();
@Autowired
AdmittedDealRegisterService admittedDealRegisterService;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
private Imdg<AdmittedDealRegister> admittedDealRegisterMap;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> mockProducer;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
this.admittedDealRegisterMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_AdmittedDealRegister, AdmittedDealRegister.class);
}
/**
* {@link AdmittedDealRegisterService#admittedDealRegisterNew(BaseRequest)} <br>
* Тест проверяет создание сущности {@link AdmittedDealRegister} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link AdmittedDealRegisterNewRequest}:<br>
*/
@Test
void admittedDealRegisterNew() {
//ARRANGE
Long executionId = 1234L;
AdmittedDealRegisterNewRequest admittedDealRegisterNewRequest = new AdmittedDealRegisterNewRequest();
admittedDealRegisterNewRequest.setExecutionId(executionId);
admittedDealRegisterNewRequest.setCompanyFullName("companyFullName");
admittedDealRegisterNewRequest.setTradingDate(LocalDate.now());
admittedDealRegisterNewRequest.setExchangeExecutionId(1L);
admittedDealRegisterNewRequest.setExchangeExecutionTime(Instant.now());
admittedDealRegisterNewRequest.setSecuritySymbol("symbol");
admittedDealRegisterNewRequest.setSecurityFullName("full name");
admittedDealRegisterNewRequest.setSellerFullName("full name");
admittedDealRegisterNewRequest.setSellerClearingCode("code");
admittedDealRegisterNewRequest.setSellerAccount("1561658");
admittedDealRegisterNewRequest.setBuyerFullName("full name");
admittedDealRegisterNewRequest.setBuyerClearingCode("ClearingCode");
admittedDealRegisterNewRequest.setBuyerAccount("65464643");
admittedDealRegisterNewRequest.setAmount(new BigDecimal(12));
admittedDealRegisterNewRequest.setClearingDate(LocalDate.now());
AdmittedDealRegister predictableAdmittedDealRegister = new AdmittedDealRegister();
predictableAdmittedDealRegister.setExecutionId(admittedDealRegisterNewRequest.getExecutionId());
predictableAdmittedDealRegister.setCompanyFullName(admittedDealRegisterNewRequest.getCompanyFullName());
predictableAdmittedDealRegister.setTradingDate(admittedDealRegisterNewRequest.getTradingDate());
predictableAdmittedDealRegister.setExchangeExecutionId(admittedDealRegisterNewRequest.getExchangeExecutionId());
predictableAdmittedDealRegister.setExchangeExecutionTime(admittedDealRegisterNewRequest.getExchangeExecutionTime());
predictableAdmittedDealRegister.setSecuritySymbol(admittedDealRegisterNewRequest.getSecuritySymbol());
predictableAdmittedDealRegister.setSecurityFullName(admittedDealRegisterNewRequest.getSecurityFullName());
predictableAdmittedDealRegister.setSellerFullName(admittedDealRegisterNewRequest.getSellerFullName());
predictableAdmittedDealRegister.setSellerClearingCode(admittedDealRegisterNewRequest.getSellerClearingCode());
predictableAdmittedDealRegister.setSellerAccount(admittedDealRegisterNewRequest.getSellerAccount());
predictableAdmittedDealRegister.setBuyerFullName(admittedDealRegisterNewRequest.getBuyerFullName());
predictableAdmittedDealRegister.setBuyerClearingCode(admittedDealRegisterNewRequest.getBuyerClearingCode());
predictableAdmittedDealRegister.setBuyerAccount(admittedDealRegisterNewRequest.getBuyerAccount());
predictableAdmittedDealRegister.setAmount(admittedDealRegisterNewRequest.getAmount());
predictableAdmittedDealRegister.setClearingDate(admittedDealRegisterNewRequest.getClearingDate());
//ACT
String jsonString = getJsonStringForNew(admittedDealRegisterNewRequest, ID);
addRecordToKafka((MockConsumer) admittedDealRegisterService.getConsumer(), TOPIC_REGISTRY_ADMITTED_DEAL_REGISTER_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
AdmittedDealRegister resultNew = admittedDealRegisterMap.getSingleObjectBySQL(String.format("executionId = %d", executionId));
predictableAdmittedDealRegister.setId(resultNew.getId());
ADMITTED_DEAL_REGISTER_MATCHER.assertMatch(resultNew, predictableAdmittedDealRegister);
}
}

113
clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/BalanceRegisterServiceTest.java
View file

@ -1,113 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.misc.BalanceRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.BalanceRegisterNewRequest;
import ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.registry.config.KafkaConfigTest;
import ru.spcex.clearing.registry.utils.MatcherFactory;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.time.Instant;
import static ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration.currentID;
import static ru.spcex.clearing.registry.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.registry.utils.TestUtils.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
BalanceRegisterService.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
class BalanceRegisterServiceTest {
public static final MatcherFactory.Matcher<BalanceRegister> ADMITTED_DEAL_REGISTER_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final String TOPIC_REGISTRY_BALANCE_REGISTER_NEW = Consts.REGISTRY_BALANCE_REGISTER_NEW;
private static final Long ID = currentID.getAndIncrement();
@Autowired
BalanceRegisterService balanceRegisterService;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
private Imdg<BalanceRegister> balanceRegisterMap;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> mockProducer;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
this.balanceRegisterMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_BalanceRegister, BalanceRegister.class);
}
/**
* {@link BalanceRegisterService#balanceRegisterNew(BaseRequest)} <br>
* Тест проверяет создание сущности {@link BalanceRegister} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link BalanceRegisterNewRequest}:<br>
*/
@Test
void balanceRegisterNew() {
//ARRANGE
Long companyId = 1234L;
BalanceRegisterNewRequest balanceRegisterNewRequest = new BalanceRegisterNewRequest();
balanceRegisterNewRequest.setsDf01Date(Instant.now());
balanceRegisterNewRequest.setCurrencyCode("currencyCode");
balanceRegisterNewRequest.setSetHouseName("houseName");
balanceRegisterNewRequest.setAccount("121546854");
balanceRegisterNewRequest.setInfoAccount("account");
balanceRegisterNewRequest.setRemainderSum(new BigDecimal(76));
balanceRegisterNewRequest.setBlockedSum(new BigDecimal(16));
balanceRegisterNewRequest.setUnblockedSum(new BigDecimal(46));
balanceRegisterNewRequest.setInn("inn");
balanceRegisterNewRequest.setMarket(12L);
balanceRegisterNewRequest.setFullName("fullName");
balanceRegisterNewRequest.setTypeRemains("typeRemains");
balanceRegisterNewRequest.setDocNumber("docNumber");
balanceRegisterNewRequest.setCompanyId(companyId);
BalanceRegister predictableBalanceRegister = new BalanceRegister();
predictableBalanceRegister.setsDf01Date(balanceRegisterNewRequest.getsDf01Date());
predictableBalanceRegister.setCurrencyCode(balanceRegisterNewRequest.getCurrencyCode());
predictableBalanceRegister.setSetHouseName(balanceRegisterNewRequest.getSetHouseName());
predictableBalanceRegister.setAccount(balanceRegisterNewRequest.getAccount());
predictableBalanceRegister.setInfoAccount(balanceRegisterNewRequest.getInfoAccount());
predictableBalanceRegister.setRemainderSum(balanceRegisterNewRequest.getRemainderSum());
predictableBalanceRegister.setBlockedSum(balanceRegisterNewRequest.getBlockedSum());
predictableBalanceRegister.setUnblockedSum(balanceRegisterNewRequest.getUnblockedSum());
predictableBalanceRegister.setInn(balanceRegisterNewRequest.getInn());
predictableBalanceRegister.setMarket(balanceRegisterNewRequest.getMarket());
predictableBalanceRegister.setFullName(balanceRegisterNewRequest.getFullName());
predictableBalanceRegister.setTypeRemains(balanceRegisterNewRequest.getTypeRemains());
predictableBalanceRegister.setDocNumber(balanceRegisterNewRequest.getDocNumber());
predictableBalanceRegister.setCompanyId(balanceRegisterNewRequest.getCompanyId());
//ACT
String jsonString = getJsonStringForNew(balanceRegisterNewRequest, ID);
addRecordToKafka((MockConsumer) balanceRegisterService.getConsumer(), TOPIC_REGISTRY_BALANCE_REGISTER_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
BalanceRegister resultNew = balanceRegisterMap.getSingleObjectBySQL(String.format("companyId = %d", companyId));
predictableBalanceRegister.setId(resultNew.getId());
ADMITTED_DEAL_REGISTER_MATCHER.assertMatch(resultNew, predictableBalanceRegister);
}
}

90
clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ClearMemberRegisterChangeServiceTest.java
View file

@ -1,90 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.register.ClearMemberRegisterChange;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.ClearMemberRegisterChangeNewRequest;
import ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.registry.config.KafkaConfigTest;
import ru.spcex.clearing.registry.utils.MatcherFactory;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.time.Instant;
import static ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration.currentID;
import static ru.spcex.clearing.registry.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.registry.utils.TestUtils.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
ClearMemberRegisterChangeService.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
class ClearMemberRegisterChangeServiceTest {
public static final MatcherFactory.Matcher<ClearMemberRegisterChange> CLEAR_MEMBER_REGISTER_CHANGE_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final String TOPIC_REGISTRY_CLEAR_MEMBER_REGISTER_CHANGE_NEW = Consts.REGISTRY_CLEAR_MEMBER_REGISTER_CHANGE_NEW;
private static final Long ID = currentID.getAndIncrement();
@Autowired
ClearMemberRegisterChangeService clearMemberRegisterChangeService;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
private Imdg<ClearMemberRegisterChange> clearMemberRegisterChangeMap;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> mockProducer;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
this.clearMemberRegisterChangeMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClearMemberRegisterChange, ClearMemberRegisterChange.class);
}
/**
* {@link ClearMemberRegisterChangeService#clearMemberRegisterChangeNew(BaseRequest)} <br>
* Тест проверяет создание сущности {@link ClearMemberRegisterChange} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link ClearMemberRegisterChangeNewRequest}:<br>
*/
@Test
void clearMemberRegisterChangeNew() {
//ARRANGE
String comment = "comment";
ClearMemberRegisterChangeNewRequest clearMemberRegisterChangeNewRequest = new ClearMemberRegisterChangeNewRequest();
clearMemberRegisterChangeNewRequest.setDate(Instant.now());
clearMemberRegisterChangeNewRequest.setComment("comment");
clearMemberRegisterChangeNewRequest.setClearingCode("clearingCode");
ClearMemberRegisterChange predictableClearMemberRegisterChange = new ClearMemberRegisterChange();
predictableClearMemberRegisterChange.setDate(clearMemberRegisterChangeNewRequest.getDate());
predictableClearMemberRegisterChange.setComment(clearMemberRegisterChangeNewRequest.getComment());
predictableClearMemberRegisterChange.setClearingCode(clearMemberRegisterChangeNewRequest.getClearingCode());
//ACT
String jsonString = getJsonStringForNew(clearMemberRegisterChangeNewRequest, ID);
addRecordToKafka((MockConsumer) clearMemberRegisterChangeService.getConsumer(), TOPIC_REGISTRY_CLEAR_MEMBER_REGISTER_CHANGE_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
ClearMemberRegisterChange resultNew = clearMemberRegisterChangeMap.getSingleObjectBySQL(String.format("comment = %s", comment));
predictableClearMemberRegisterChange.setId(resultNew.getId());
CLEAR_MEMBER_REGISTER_CHANGE_MATCHER.assertMatch(resultNew, predictableClearMemberRegisterChange);
}
}

135
clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ClearMemberRegisterServiceTest.java
View file

@ -1,135 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.misc.ClearMemberRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.ClearMemberRegisterNewRequest;
import ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.registry.config.KafkaConfigTest;
import ru.spcex.clearing.registry.utils.MatcherFactory;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.time.Instant;
import java.time.LocalDate;
import static ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration.currentID;
import static ru.spcex.clearing.registry.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.registry.utils.TestUtils.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
ClearMemberRegisterService.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
class ClearMemberRegisterServiceTest {
public static final MatcherFactory.Matcher<ClearMemberRegister> CLEAR_MEMBER_REGISTER_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final String TOPIC_REGISTRY_CLEAR_MEMBER_REGISTER_NEW = Consts.REGISTRY_CLEAR_MEMBER_REGISTER_NEW;
private static final Long ID = currentID.getAndIncrement();
@Autowired
ClearMemberRegisterService clearMemberRegisterService;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
private Imdg<ClearMemberRegister> clearMemberRegisterMap;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> mockProducer;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
this.clearMemberRegisterMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClearMemberRegister, ClearMemberRegister.class);
}
/**
* {@link ClearMemberRegisterService#clearMemberRegisterNew(BaseRequest)} <br>
* Тест проверяет создание сущности {@link ClearMemberRegister} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link ClearMemberRegisterNewRequest}:<br>
*/
@Test
void clearMemberRegisterNew() {
//ARRANGE
Long bank = 1234L;
ClearMemberRegisterNewRequest clearMemberRegisterNewRequest = new ClearMemberRegisterNewRequest();
clearMemberRegisterNewRequest.setTradingCode("tradingCode");
clearMemberRegisterNewRequest.setClearingCode("clearingCode");
clearMemberRegisterNewRequest.setFullName("fullName");
clearMemberRegisterNewRequest.setShortName("shortName");
clearMemberRegisterNewRequest.setCategoryList("categoryList");
clearMemberRegisterNewRequest.setCorporationSole("corporationSole");
clearMemberRegisterNewRequest.setAccount("1246984698");
clearMemberRegisterNewRequest.setBank(bank);
clearMemberRegisterNewRequest.setBankName("bankName");
clearMemberRegisterNewRequest.setInn("inn");
clearMemberRegisterNewRequest.setBic("bic");
clearMemberRegisterNewRequest.setOgrn("ogrn");
clearMemberRegisterNewRequest.setCpp("cpp");
clearMemberRegisterNewRequest.setOcpo("ocpo");
clearMemberRegisterNewRequest.setContractNumber("contractNumber");
clearMemberRegisterNewRequest.setContractDate(LocalDate.now());
clearMemberRegisterNewRequest.setRegistrationDate(LocalDate.now());
clearMemberRegisterNewRequest.setSystemDate(LocalDate.now());
clearMemberRegisterNewRequest.setAccessDate(Instant.now());
clearMemberRegisterNewRequest.setSuspentionDate(Instant.now());
clearMemberRegisterNewRequest.setReopeningDate(Instant.now());
clearMemberRegisterNewRequest.setCloseDate(Instant.now());
clearMemberRegisterNewRequest.setExclusionDate(Instant.now());
clearMemberRegisterNewRequest.setAddress("address");
clearMemberRegisterNewRequest.setEmail("email");
ClearMemberRegister predictableClearMemberRegister = new ClearMemberRegister();
predictableClearMemberRegister.setTradingCode(clearMemberRegisterNewRequest.getTradingCode());
predictableClearMemberRegister.setClearingCode(clearMemberRegisterNewRequest.getClearingCode());
predictableClearMemberRegister.setFullName(clearMemberRegisterNewRequest.getFullName());
predictableClearMemberRegister.setShortName(clearMemberRegisterNewRequest.getShortName());
predictableClearMemberRegister.setCategoryList(clearMemberRegisterNewRequest.getCategoryList());
predictableClearMemberRegister.setCorporationSole(clearMemberRegisterNewRequest.getCorporationSole());
predictableClearMemberRegister.setAccount(clearMemberRegisterNewRequest.getAccount());
predictableClearMemberRegister.setBank(clearMemberRegisterNewRequest.getBank());
predictableClearMemberRegister.setBankName(clearMemberRegisterNewRequest.getBankName());
predictableClearMemberRegister.setInn(clearMemberRegisterNewRequest.getInn());
predictableClearMemberRegister.setBic(clearMemberRegisterNewRequest.getBic());
predictableClearMemberRegister.setOgrn(clearMemberRegisterNewRequest.getOgrn());
predictableClearMemberRegister.setCpp(clearMemberRegisterNewRequest.getCpp());
predictableClearMemberRegister.setOcpo(clearMemberRegisterNewRequest.getOcpo());
predictableClearMemberRegister.setContractNumber(clearMemberRegisterNewRequest.getContractNumber());
predictableClearMemberRegister.setContractDate(clearMemberRegisterNewRequest.getContractDate());
predictableClearMemberRegister.setRegistrationDate(clearMemberRegisterNewRequest.getRegistrationDate());
predictableClearMemberRegister.setSystemDate(clearMemberRegisterNewRequest.getSystemDate());
predictableClearMemberRegister.setAccessDate(clearMemberRegisterNewRequest.getAccessDate());
predictableClearMemberRegister.setSuspentionDate(clearMemberRegisterNewRequest.getSuspentionDate());
predictableClearMemberRegister.setReopeningDate(clearMemberRegisterNewRequest.getReopeningDate());
predictableClearMemberRegister.setCloseDate(clearMemberRegisterNewRequest.getCloseDate());
predictableClearMemberRegister.setExclusionDate(clearMemberRegisterNewRequest.getExclusionDate());
predictableClearMemberRegister.setAddress(clearMemberRegisterNewRequest.getAddress());
predictableClearMemberRegister.setEmail(clearMemberRegisterNewRequest.getEmail());
//ACT
String jsonString = getJsonStringForNew(clearMemberRegisterNewRequest, ID);
addRecordToKafka((MockConsumer) clearMemberRegisterService.getConsumer(), TOPIC_REGISTRY_CLEAR_MEMBER_REGISTER_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
ClearMemberRegister resultNew = clearMemberRegisterMap.getSingleObjectBySQL(String.format("bank = %d", bank));
predictableClearMemberRegister.setId(resultNew.getId());
CLEAR_MEMBER_REGISTER_MATCHER.assertMatch(resultNew, predictableClearMemberRegister);
}
}

116
clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/CoveredDealRegisterServiceTest.java
View file

@ -1,116 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.register.CoveredDealRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.CoveredDealRegisterNewRequest;
import ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.registry.config.KafkaConfigTest;
import ru.spcex.clearing.registry.utils.MatcherFactory;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
import static ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration.currentID;
import static ru.spcex.clearing.registry.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.registry.utils.TestUtils.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
CoveredDealRegisterService.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
class CoveredDealRegisterServiceTest {
public static final MatcherFactory.Matcher<CoveredDealRegister> COVERED_DEAL_REGISTER_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final String TOPIC_REGISTRY_COVERED_DEAL_REGISTER_NEW = Consts.REGISTRY_COVERED_DEAL_REGISTER_NEW;
private static final Long ID = currentID.getAndIncrement();
@Autowired
CoveredDealRegisterService coveredDealRegisterService;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
private Imdg<CoveredDealRegister> coveredDealRegisterMap;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> mockProducer;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
this.coveredDealRegisterMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_CoveredDealRegister, CoveredDealRegister.class);
}
/**
* {@link CoveredDealRegisterService#coveredDealRegisterNew(BaseRequest)} <br>
* Тест проверяет создание сущности {@link CoveredDealRegister} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link CoveredDealRegisterNewRequest}:<br>
*/
@Test
void coveredDealRegisterNew() {
//ARRANGE
Long executionId = 1234L;
CoveredDealRegisterNewRequest coveredDealRegisterNewRequest = new CoveredDealRegisterNewRequest();
coveredDealRegisterNewRequest.setExecutionId(executionId);
coveredDealRegisterNewRequest.setCompanyFullName("companyFullName");
coveredDealRegisterNewRequest.setTradingDate(LocalDate.now());
coveredDealRegisterNewRequest.setExchangeExecutionId(1212L);
coveredDealRegisterNewRequest.setExchangeExecutionTime(Instant.now());
coveredDealRegisterNewRequest.setSecuritySymbol("securitySymbol");
coveredDealRegisterNewRequest.setSecurityFullName("fullName");
coveredDealRegisterNewRequest.setSellerFullName("sellerFullName");
coveredDealRegisterNewRequest.setSellerClearingCode("sellerClearingCode");
coveredDealRegisterNewRequest.setSellerAccount("sellerAccount");
coveredDealRegisterNewRequest.setBuyerFullName("buyerFullName");
coveredDealRegisterNewRequest.setBuyerClearingCode("buyerClearingCode");
coveredDealRegisterNewRequest.setBuyerAccount("buyerAccount");
coveredDealRegisterNewRequest.setAmount(new BigDecimal(412));
coveredDealRegisterNewRequest.setClearingDate(LocalDate.now());
CoveredDealRegister predictableCoveredDealRegister = new CoveredDealRegister();
predictableCoveredDealRegister.setExecutionId(coveredDealRegisterNewRequest.getExecutionId());
predictableCoveredDealRegister.setCompanyFullName(coveredDealRegisterNewRequest.getCompanyFullName());
predictableCoveredDealRegister.setTradingDate(coveredDealRegisterNewRequest.getTradingDate());
predictableCoveredDealRegister.setExchangeExecutionId(coveredDealRegisterNewRequest.getExchangeExecutionId());
predictableCoveredDealRegister.setExchangeExecutionTime(coveredDealRegisterNewRequest.getExchangeExecutionTime());
predictableCoveredDealRegister.setSecuritySymbol(coveredDealRegisterNewRequest.getSecuritySymbol());
predictableCoveredDealRegister.setSecurityFullName(coveredDealRegisterNewRequest.getSecurityFullName());
predictableCoveredDealRegister.setSellerFullName(coveredDealRegisterNewRequest.getSellerFullName());
predictableCoveredDealRegister.setSellerClearingCode(coveredDealRegisterNewRequest.getSellerClearingCode());
predictableCoveredDealRegister.setSellerAccount(coveredDealRegisterNewRequest.getSellerAccount());
predictableCoveredDealRegister.setBuyerFullName(coveredDealRegisterNewRequest.getBuyerFullName());
predictableCoveredDealRegister.setBuyerClearingCode(coveredDealRegisterNewRequest.getBuyerClearingCode());
predictableCoveredDealRegister.setBuyerAccount(coveredDealRegisterNewRequest.getBuyerAccount());
predictableCoveredDealRegister.setAmount(coveredDealRegisterNewRequest.getAmount());
predictableCoveredDealRegister.setClearingDate(coveredDealRegisterNewRequest.getClearingDate());
//ACT
String jsonString = getJsonStringForNew(coveredDealRegisterNewRequest, ID);
addRecordToKafka((MockConsumer) coveredDealRegisterService.getConsumer(), TOPIC_REGISTRY_COVERED_DEAL_REGISTER_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
CoveredDealRegister resultNew = coveredDealRegisterMap.getSingleObjectBySQL(String.format("executionId = %d", executionId));
predictableCoveredDealRegister.setId(resultNew.getId());
COVERED_DEAL_REGISTER_MATCHER.assertMatch(resultNew, predictableCoveredDealRegister);
}
}

105
clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/OrderRegisterServiceTest.java
View file

@ -1,105 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.register.OrderRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.OrderRegisterNewRequest;
import ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.registry.config.KafkaConfigTest;
import ru.spcex.clearing.registry.utils.MatcherFactory;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.time.LocalDate;
import static ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration.currentID;
import static ru.spcex.clearing.registry.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.registry.utils.TestUtils.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
OrderRegisterService.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
class OrderRegisterServiceTest {
public static final MatcherFactory.Matcher<OrderRegister> ORDER_REGISTER_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final String TOPIC_REGISTRY_ORDER_REGISTER_NEW = Consts.REGISTRY_ORDER_REGISTER_NEW;
private static final Long ID = currentID.getAndIncrement();
@Autowired
OrderRegisterService orderRegisterService;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
private Imdg<OrderRegister> orderRegisterMap;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> mockProducer;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
this.orderRegisterMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_OrderRegister, OrderRegister.class);
}
/**
* {@link OrderRegisterService#orderRegisterNew(BaseRequest)} <br>
* Тест проверяет создание сущности {@link OrderRegister} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link OrderRegisterNewRequest}:<br>
*/
@Test
void orderRegisterNew() {
//ARRANGE
Long creditLegDirection = 1234L;
OrderRegisterNewRequest req = new OrderRegisterNewRequest();
req.setCreditLegAccount("creditLegAccount");
req.setCreditLegAmount(new BigDecimal(0));
req.setCreditLegCurrencyCode("creditLegCurrencyCode");
req.setCreditLegDirection(creditLegDirection);
req.setDebitLegAccount(req.getDebitLegAccount());
req.setSender(req.getSender());
req.setAddressee(req.getAddressee());
req.setDocumentNumber(req.getDocumentNumber());
req.setClearingDate(req.getClearingDate());
req.setClearingDate(LocalDate.now());
OrderRegister predictableOrderRegister = new OrderRegister();
predictableOrderRegister.setCreditLegAccount(req.getCreditLegAccount());
predictableOrderRegister.setCreditLegAmount(req.getCreditLegAmount());
predictableOrderRegister.setCreditLegCurrencyCode(req.getCreditLegCurrencyCode());
predictableOrderRegister.setCreditLegDirection(req.getCreditLegDirection());
predictableOrderRegister.setDebitLegAccount(req.getDebitLegAccount());
predictableOrderRegister.setSender(req.getSender());
predictableOrderRegister.setAddressee(req.getAddressee());
predictableOrderRegister.setDocumentNumber(req.getDocumentNumber());
predictableOrderRegister.setClearingDate(req.getClearingDate());
predictableOrderRegister.setClearingDate(req.getClearingDate());
//ACT
String jsonString = getJsonStringForNew(req, ID);
addRecordToKafka((MockConsumer) orderRegisterService.getConsumer(), TOPIC_REGISTRY_ORDER_REGISTER_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
OrderRegister resultNew = orderRegisterMap.getSingleObjectBySQL(String.format("creditLegDirection = %d", creditLegDirection));
predictableOrderRegister.setId(resultNew.getId());
ORDER_REGISTER_MATCHER.assertMatch(resultNew, predictableOrderRegister);
}
}

118
clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/UncoveredDealRegisterServiceTest.java
View file

@ -1,118 +0,0 @@
package ru.spcex.clearing.registry.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.register.UncoveredDealRegister;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.registry.UncoveredDealRegisterNewRequest;
import ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration;
import ru.spcex.clearing.registry.config.KafkaConfigTest;
import ru.spcex.clearing.registry.utils.MatcherFactory;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
import static ru.spcex.clearing.registry.config.HazelcastServiceTestConfiguration.currentID;
import static ru.spcex.clearing.registry.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.registry.utils.TestUtils.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
UncoveredDealRegisterService.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
class UncoveredDealRegisterServiceTest {
public static final MatcherFactory.Matcher<UncoveredDealRegister> UNCOVERED_DEAL_REGISTER_MATCHER = usingIgnoringFieldsComparator();
private static final int PARTITION = 0;
private static final String TOPIC_REGISTRY_UNCOVERED_DEAL_REGISTER_NEW = Consts.REGISTRY_UNCOVERED_DEAL_REGISTER_NEW;
private static final Long ID = currentID.getAndIncrement();
@Autowired
UncoveredDealRegisterService uncoveredDealRegisterService;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
private Imdg<UncoveredDealRegister> uncoveredDealRegisterMap;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> mockProducer;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
this.uncoveredDealRegisterMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_UncoveredDealRegister, UncoveredDealRegister.class);
}
/**
* {@link UncoveredDealRegisterService#uncoveredDealRegisterNew(BaseRequest)} <br>
* Тест проверяет создание сущности {@link UncoveredDealRegister} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link UncoveredDealRegisterNewRequest}:<br>
*/
@Test
void uncoveredDealRegisterNew() {
//ARRANGE
Long executionId = 1234L;
UncoveredDealRegisterNewRequest req = new UncoveredDealRegisterNewRequest();
req.setExecutionId(executionId);
req.setCompanyFullName("companyFullName");
req.setTradingDate(LocalDate.now());
req.setExchangeExecutionId(121L);
req.setExchangeExecutionTime(Instant.now());
req.setSecuritySymbol("securitySymbol");
req.setSecurityFullName("fullName");
req.setSellerFullName("sellerFullName");
req.setSellerClearingCode("sellerClearingCode");
req.setSellerAccount("sellerAccount");
req.setBuyerFullName("buyerFullName");
req.setBuyerClearingCode("clearingCode");
req.setBuyerAccount("buyerAccount");
req.setAmount(new BigDecimal(21));
req.setResultStatus("resultStatus");
req.setClearingDate(LocalDate.now());
UncoveredDealRegister predictableUncoveredDealRegister = new UncoveredDealRegister();
predictableUncoveredDealRegister.setExecutionId(req.getExecutionId());
predictableUncoveredDealRegister.setCompanyFullName(req.getCompanyFullName());
predictableUncoveredDealRegister.setTradingDate(req.getTradingDate());
predictableUncoveredDealRegister.setExchangeExecutionId(req.getExchangeExecutionId());
predictableUncoveredDealRegister.setExchangeExecutionTime(req.getExchangeExecutionTime());
predictableUncoveredDealRegister.setSecuritySymbol(req.getSecuritySymbol());
predictableUncoveredDealRegister.setSecurityFullName(req.getSecurityFullName());
predictableUncoveredDealRegister.setSellerFullName(req.getSellerFullName());
predictableUncoveredDealRegister.setSellerClearingCode(req.getSellerClearingCode());
predictableUncoveredDealRegister.setSellerAccount(req.getSellerAccount());
predictableUncoveredDealRegister.setBuyerFullName(req.getBuyerFullName());
predictableUncoveredDealRegister.setBuyerClearingCode(req.getBuyerClearingCode());
predictableUncoveredDealRegister.setBuyerAccount(req.getBuyerAccount());
predictableUncoveredDealRegister.setAmount(req.getAmount());
predictableUncoveredDealRegister.setResultStatus(req.getResultStatus());
predictableUncoveredDealRegister.setClearingDate(req.getClearingDate());
//ACT
String jsonString = getJsonStringForNew(req, ID);
addRecordToKafka((MockConsumer) uncoveredDealRegisterService.getConsumer(), TOPIC_REGISTRY_UNCOVERED_DEAL_REGISTER_NEW, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
UncoveredDealRegister resultNew = uncoveredDealRegisterMap.getSingleObjectBySQL(String.format("executionId = %d", executionId));
predictableUncoveredDealRegister.setId(resultNew.getId());
UNCOVERED_DEAL_REGISTER_MATCHER.assertMatch(resultNew, predictableUncoveredDealRegister);
}
}

1
clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/KeyRateService.java
View file

@ -19,6 +19,7 @@ import ru.spcex.platform.enumeration.Status;
import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgProvider;
@Deprecated // KeyRate was deleted
@Service @Service
public class KeyRateService extends QueueConsumer implements InitializingBean { public class KeyRateService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass()); private final Logger log = LoggerFactory.getLogger(getClass());

1
clearing-parent/utility-service/src/test/java/ru/spcex/clearing/utility/service/KeyRateFactory.java
View file

@ -8,6 +8,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.utilities.KeyRateUpdateRe
import java.math.BigDecimal; import java.math.BigDecimal;
import java.time.LocalDate; import java.time.LocalDate;
@Deprecated
class KeyRateFactory { class KeyRateFactory {
LocalDate startDate = LocalDate.ofEpochDay(0); LocalDate startDate = LocalDate.ofEpochDay(0);
LocalDate endDate = LocalDate.ofEpochDay(0); LocalDate endDate = LocalDate.ofEpochDay(0);

1
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/BalanceAccountType.java
View file

@ -2,6 +2,7 @@ package ru.spcex.platform.enumeration;
import ru.spcex.platform.utils.enumeration.IEnumKey; import ru.spcex.platform.utils.enumeration.IEnumKey;
@Deprecated // Словарь balanceAccountTypeDictionary удалён
public enum BalanceAccountType implements IEnumKey { public enum BalanceAccountType implements IEnumKey {
Active("ACTV"), Blocked("BLKD"); Active("ACTV"), Blocked("BLKD");

1
platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/ClearingStatus.java
View file

@ -2,6 +2,7 @@ package ru.spcex.platform.enumeration;
import ru.spcex.platform.utils.enumeration.IEnumKey; import ru.spcex.platform.utils.enumeration.IEnumKey;
@Deprecated // словарь ClearingStatusDictionary удалён
public enum ClearingStatus implements IEnumKey { public enum ClearingStatus implements IEnumKey {
OK("OK"), OK("OK"),
FAIL("FAIL"), FAIL("FAIL"),

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

@ -11,6 +11,7 @@ public final class IMDGDistributedNames {
public static final String Map_Contact = "Map_Contact"; public static final String Map_Contact = "Map_Contact";
public static final String Map_ProfileDocument = "Map_ProfileDocument"; public static final String Map_ProfileDocument = "Map_ProfileDocument";
public static final String Map_Account = "Map_Account"; public static final String Map_Account = "Map_Account";
@Deprecated
public static final String Map_AccountBalance = "Map_AccountBalance"; public static final String Map_AccountBalance = "Map_AccountBalance";
public static final String Map_AccountHistory = "Map_AccountHistory"; public static final String Map_AccountHistory = "Map_AccountHistory";
public static final String Map_AccountBalanceHistory = "Map_AccountBalanceHistory"; public static final String Map_AccountBalanceHistory = "Map_AccountBalanceHistory";
@ -50,11 +51,14 @@ public final class IMDGDistributedNames {
public static final String Map_SDf10 = "Map_SDf10"; public static final String Map_SDf10 = "Map_SDf10";
public static final String Map_SDf11 = "Map_SDf11"; public static final String Map_SDf11 = "Map_SDf11";
public static final String Map_SDf13 = "Map_SDf13"; public static final String Map_SDf13 = "Map_SDf13";
@Deprecated
public static final String Map_SDf17 = "Map_SDf17"; public static final String Map_SDf17 = "Map_SDf17";
@Deprecated
public static final String Map_SDf16 = "Map_SDf16"; public static final String Map_SDf16 = "Map_SDf16";
public static final String Map_SDf08 = "Map_SDf08"; public static final String Map_SDf08 = "Map_SDf08";
public static final String Map_SDf09 = "Map_SDf09"; public static final String Map_SDf09 = "Map_SDf09";
public static final String Map_SDf12 = "Map_SDf12"; public static final String Map_SDf12 = "Map_SDf12";
@Deprecated
public static final String Map_SDf18 = "Map_SDf18"; public static final String Map_SDf18 = "Map_SDf18";
public static final String Map_SDf51 = "Map_sDf51"; public static final String Map_SDf51 = "Map_sDf51";
public static final String Map_SDf52 = "Map_sDf52"; public static final String Map_SDf52 = "Map_sDf52";
@ -71,7 +75,7 @@ public final class IMDGDistributedNames {
public static final String Map_OrganizationTypeDictionary = "Map_OrganizationTypeDictionary"; public static final String Map_OrganizationTypeDictionary = "Map_OrganizationTypeDictionary";
public static final String Map_WorkflowStatusDictionary = "Map_WorkflowStatusDictionary"; public static final String Map_WorkflowStatusDictionary = "Map_WorkflowStatusDictionary";
public static final String Map_AccountTypeDictionary = "Map_AccountTypeDictionary"; public static final String Map_AccountTypeDictionary = "Map_AccountTypeDictionary";
public static final String Map_BalanceAccountTypeDictionary = "Map_BalanceAccountTypeDictionary"; @Deprecated
public static final String Map_ClearingStatusDictionary = "Map_ClearingStatusDictionary"; public static final String Map_ClearingStatusDictionary = "Map_ClearingStatusDictionary";
public static final String Map_CurrencyCodeDictionary = "Map_CurrencyCodeDictionary"; public static final String Map_CurrencyCodeDictionary = "Map_CurrencyCodeDictionary";
public static final String Map_ErrorCodeDictionary = "Map_ErrorCodeDictionary"; public static final String Map_ErrorCodeDictionary = "Map_ErrorCodeDictionary";
@ -90,7 +94,6 @@ public final class IMDGDistributedNames {
public static final String Map_StatementTypeDictionary = "Map_StatementTypeDictionary"; public static final String Map_StatementTypeDictionary = "Map_StatementTypeDictionary";
public static final String Map_TermTypeDictionary = "Map_TermTypeDictionary"; public static final String Map_TermTypeDictionary = "Map_TermTypeDictionary";
public static final String Map_CourierTypeDictionary = "Map_CourierTypeDictionary"; public static final String Map_CourierTypeDictionary = "Map_CourierTypeDictionary";
public static final String Map_ChargeDirectionDictionary = "Map_ChargeDirectionDictionary";
public static final String Map_TaskDictionary = "Map_TaskDictionary"; public static final String Map_TaskDictionary = "Map_TaskDictionary";
public static final String Map_TaskStatusDictionary = "Map_TaskStatusDictionary"; public static final String Map_TaskStatusDictionary = "Map_TaskStatusDictionary";
public static final String Map_DayStatusDictionary = "Map_DayStatusDictionary"; public static final String Map_DayStatusDictionary = "Map_DayStatusDictionary";
@ -99,6 +102,7 @@ public final class IMDGDistributedNames {
public static final String Map_UserRoleDictionary = "Map_UserRoleDictionary"; public static final String Map_UserRoleDictionary = "Map_UserRoleDictionary";
public static final String Map_UserSettings = "Map_UserSettings"; public static final String Map_UserSettings = "Map_UserSettings";
public static final String Map_UserRoleSession = "Map_UserRoleSession"; public static final String Map_UserRoleSession = "Map_UserRoleSession";
@Deprecated
public static final String Map_KeyRate = "Map_KeyRate"; public static final String Map_KeyRate = "Map_KeyRate";
public static final String Map_MoneyMarketSecurity = "Map_MoneyMarketSecurity"; public static final String Map_MoneyMarketSecurity = "Map_MoneyMarketSecurity";
public static final String Map_Currency = "Map_Currency"; public static final String Map_Currency = "Map_Currency";
@ -107,20 +111,14 @@ public final class IMDGDistributedNames {
public static final String Map_Session = "Map_Session"; public static final String Map_Session = "Map_Session";
public static final String Map_SessionHistory = "Map_SessionHistory"; public static final String Map_SessionHistory = "Map_SessionHistory";
public static final String Map_Notification = "Map_Notification"; public static final String Map_Notification = "Map_Notification";
@Deprecated
public static final String Map_LiabilitiesClaimsAssets = "Map_LiabilitiesClaimsAssets"; public static final String Map_LiabilitiesClaimsAssets = "Map_LiabilitiesClaimsAssets";
@Deprecated
public static final String Map_LiabilitiesClaimsMoney = "Map_LiabilitiesClaimsMoney"; public static final String Map_LiabilitiesClaimsMoney = "Map_LiabilitiesClaimsMoney";
public static final String Map_ClearMemberRegister = "Map_ClearMemberRegister";
public static final String Map_ClearMemberRegisterChange = "Map_ClearMemberRegisterChange";
public static final String Map_BalanceRegister = "Map_BalanceRegister";
public static final String Map_ExecutionDeposit = "Map_ExecutionDeposit"; public static final String Map_ExecutionDeposit = "Map_ExecutionDeposit";
public static final String Map_ExecutionDepositHistory = "Map_ExecutionDepositHistory"; public static final String Map_ExecutionDepositHistory = "Map_ExecutionDepositHistory";
public static final String Map_DealRegister = "Map_DealRegister";
public static final String Map_AdmittedDealRegister = "Map_AdmittedDealRegister";
public static final String Map_CoveredDealRegister = "Map_CoveredDealRegister";
public static final String Map_UncoveredDealRegister = "Map_UncoveredDealRegister";
public static final String Map_ReportRegister = "Map_ReportRegister"; public static final String Map_ReportRegister = "Map_ReportRegister";
public static final String Map_ContractRegister = "Map_ContractRegister"; public static final String Map_ContractRegister = "Map_ContractRegister";
public static final String Map_OrderRegister = "Map_OrderRegister";
public static final String Map_VerificationResult = "Map_VerificationResult"; public static final String Map_VerificationResult = "Map_VerificationResult";
public static final String Map_STrades = "Map_STrades"; public static final String Map_STrades = "Map_STrades";
public static final String Map_SectionDictionary = "Map_SectionDictionary"; public static final String Map_SectionDictionary = "Map_SectionDictionary";

211
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/registry/AdmittedDealRegisterNewRequest.java
View file

@ -1,211 +0,0 @@
package ru.spcex.clearing.platform.messaging.domain.cud.registry;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.InstantDateTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.InstantDateTimeSerializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
public class AdmittedDealRegisterNewRequest {
@JsonProperty
public Long executionId;
@JsonProperty
public String companyFullName;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate tradingDate;
@JsonProperty
public Long exchangeExecutionId;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
public Instant exchangeExecutionTime;
@JsonProperty
public String securitySymbol;
@JsonProperty
public String securityFullName;
@JsonProperty
public String sellerFullName;
@JsonProperty
public String sellerClearingCode;
@JsonProperty
public String sellerAccount;
@JsonProperty
public String buyerFullName;
@JsonProperty
public String buyerClearingCode;
@JsonProperty
public String buyerAccount;
@JsonProperty
public BigDecimal amount;
@JsonProperty
public Long id;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
public Instant createdAt;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
public Instant updatedAt;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate clearingDate;
public Long getExecutionId() {
return executionId;
}
public void setExecutionId(Long executionId) {
this.executionId = executionId;
}
public String getCompanyFullName() {
return companyFullName;
}
public void setCompanyFullName(String companyFullName) {
this.companyFullName = companyFullName;
}
public LocalDate getTradingDate() {
return tradingDate;
}
public void setTradingDate(LocalDate tradingDate) {
this.tradingDate = tradingDate;
}
public Long getExchangeExecutionId() {
return exchangeExecutionId;
}
public void setExchangeExecutionId(Long exchangeExecutionId) {
this.exchangeExecutionId = exchangeExecutionId;
}
public Instant getExchangeExecutionTime() {
return exchangeExecutionTime;
}
public void setExchangeExecutionTime(Instant exchangeExecutionTime) {
this.exchangeExecutionTime = exchangeExecutionTime;
}
public String getSecuritySymbol() {
return securitySymbol;
}
public void setSecuritySymbol(String securitySymbol) {
this.securitySymbol = securitySymbol;
}
public String getSecurityFullName() {
return securityFullName;
}
public void setSecurityFullName(String securityFullName) {
this.securityFullName = securityFullName;
}
public String getSellerFullName() {
return sellerFullName;
}
public void setSellerFullName(String sellerFullName) {
this.sellerFullName = sellerFullName;
}
public String getSellerClearingCode() {
return sellerClearingCode;
}
public void setSellerClearingCode(String sellerClearingCode) {
this.sellerClearingCode = sellerClearingCode;
}
public String getSellerAccount() {
return sellerAccount;
}
public void setSellerAccount(String sellerAccount) {
this.sellerAccount = sellerAccount;
}
public String getBuyerFullName() {
return buyerFullName;
}
public void setBuyerFullName(String buyerFullName) {
this.buyerFullName = buyerFullName;
}
public String getBuyerClearingCode() {
return buyerClearingCode;
}
public void setBuyerClearingCode(String buyerClearingCode) {
this.buyerClearingCode = buyerClearingCode;
}
public String getBuyerAccount() {
return buyerAccount;
}
public void setBuyerAccount(String buyerAccount) {
this.buyerAccount = buyerAccount;
}
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Instant getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Instant createdAt) {
this.createdAt = createdAt;
}
public Instant getUpdatedAt() {
return updatedAt;
}
public void setUpdatedAt(Instant updatedAt) {
this.updatedAt = updatedAt;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

44
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/registry/ClearMemberRegisterChangeNewRequest.java
View file

@ -1,44 +0,0 @@
package ru.spcex.clearing.platform.messaging.domain.cud.registry;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.InstantDateTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.InstantDateTimeSerializer;
import java.time.Instant;
public class ClearMemberRegisterChangeNewRequest {
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant date;
@JsonProperty
private String clearingCode;
@JsonProperty
private String comment;
public Instant getDate() {
return date;
}
public void setDate(Instant date) {
this.date = date;
}
public String getClearingCode() {
return clearingCode;
}
public void setClearingCode(String clearingCode) {
this.clearingCode = clearingCode;
}
public String getComment() {
return comment;
}
public void setComment(String comment) {
this.comment = comment;
}
}

343
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/registry/ClearMemberRegisterNewRequest.java
View file

@ -1,343 +0,0 @@
package ru.spcex.clearing.platform.messaging.domain.cud.registry;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.InstantDateTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.InstantDateTimeSerializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import java.time.Instant;
import java.time.LocalDate;
public class ClearMemberRegisterNewRequest {
@JsonProperty
private String tradingCode;
@JsonProperty
private String clearingCode;
@JsonProperty
private String fullName;
@JsonProperty
private String shortName;
@JsonProperty
private String categoryList;
@JsonProperty
private String corporationSole;
@JsonProperty
private String account;
@JsonProperty
private Long bank;
@JsonProperty
private String bankName;
@JsonProperty
private String inn;
@JsonProperty
private String bic;
@JsonProperty
private String ogrn;
@JsonProperty
private String cpp;
@JsonProperty
private String ocpo;
@JsonProperty
private String contractNumber;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
private LocalDate contractDate;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
private LocalDate registrationDate;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
private LocalDate systemDate;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant accessDate;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant suspentionDate;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant reopeningDate;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant closeDate;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant exclusionDate;
@JsonProperty
private String address;
@JsonProperty
private String email;
@JsonProperty
private Long id;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant createdAt;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant updatedAt;
public String getTradingCode() {
return tradingCode;
}
public void setTradingCode(String tradingCode) {
this.tradingCode = tradingCode;
}
public String getClearingCode() {
return clearingCode;
}
public void setClearingCode(String clearingCode) {
this.clearingCode = clearingCode;
}
public String getFullName() {
return fullName;
}
public void setFullName(String fullName) {
this.fullName = fullName;
}
public String getShortName() {
return shortName;
}
public void setShortName(String shortName) {
this.shortName = shortName;
}
public String getCategoryList() {
return categoryList;
}
public void setCategoryList(String categoryList) {
this.categoryList = categoryList;
}
public String getCorporationSole() {
return corporationSole;
}
public void setCorporationSole(String corporationSole) {
this.corporationSole = corporationSole;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public Long getBank() {
return bank;
}
public void setBank(Long bank) {
this.bank = bank;
}
public String getBankName() {
return bankName;
}
public void setBankName(String bankName) {
this.bankName = bankName;
}
public String getInn() {
return inn;
}
public void setInn(String inn) {
this.inn = inn;
}
public String getBic() {
return bic;
}
public void setBic(String bic) {
this.bic = bic;
}
public String getOgrn() {
return ogrn;
}
public void setOgrn(String ogrn) {
this.ogrn = ogrn;
}
public String getCpp() {
return cpp;
}
public void setCpp(String cpp) {
this.cpp = cpp;
}
public String getOcpo() {
return ocpo;
}
public void setOcpo(String ocpo) {
this.ocpo = ocpo;
}
public String getContractNumber() {
return contractNumber;
}
public void setContractNumber(String contractNumber) {
this.contractNumber = contractNumber;
}
public LocalDate getContractDate() {
return contractDate;
}
public void setContractDate(LocalDate contractDate) {
this.contractDate = contractDate;
}
public LocalDate getRegistrationDate() {
return registrationDate;
}
public void setRegistrationDate(LocalDate registrationDate) {
this.registrationDate = registrationDate;
}
public LocalDate getSystemDate() {
return systemDate;
}
public void setSystemDate(LocalDate systemDate) {
this.systemDate = systemDate;
}
public Instant getAccessDate() {
return accessDate;
}
public void setAccessDate(Instant accessDate) {
this.accessDate = accessDate;
}
public Instant getSuspentionDate() {
return suspentionDate;
}
public void setSuspentionDate(Instant suspentionDate) {
this.suspentionDate = suspentionDate;
}
public Instant getReopeningDate() {
return reopeningDate;
}
public void setReopeningDate(Instant reopeningDate) {
this.reopeningDate = reopeningDate;
}
public Instant getCloseDate() {
return closeDate;
}
public void setCloseDate(Instant closeDate) {
this.closeDate = closeDate;
}
public Instant getExclusionDate() {
return exclusionDate;
}
public void setExclusionDate(Instant exclusionDate) {
this.exclusionDate = exclusionDate;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Instant getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Instant createdAt) {
this.createdAt = createdAt;
}
public Instant getUpdatedAt() {
return updatedAt;
}
public void setUpdatedAt(Instant updatedAt) {
this.updatedAt = updatedAt;
}
}

225
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/registry/CoveredDealRegisterNewRequest.java
View file

@ -1,225 +0,0 @@
package ru.spcex.clearing.platform.messaging.domain.cud.registry;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.InstantDateTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.InstantDateTimeSerializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
public class CoveredDealRegisterNewRequest {
@JsonProperty
public Long executionId;
@JsonProperty
public String companyFullName;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate tradingDate;
@JsonProperty
public Long exchangeExecutionId;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
public Instant exchangeExecutionTime; //todo clarify is timestamp suitable for this request or not
@JsonProperty
public String securitySymbol;
@JsonProperty
public String securityFullName;
@JsonProperty
public String sellerFullName;
@JsonProperty
public String sellerClearingCode;
@JsonProperty
public String sellerAccount;
@JsonProperty
public String buyerFullName;
@JsonProperty
public String buyerClearingCode;
@JsonProperty
public String buyerAccount;
@JsonProperty
public BigDecimal amount;
@JsonProperty
public Long id;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
public Instant createdAt;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
public Instant updatedAt;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate clearingDate;
public Long getExecutionId() {
return executionId;
}
public void setExecutionId(Long executionId) {
this.executionId = executionId;
}
public String getCompanyFullName() {
return companyFullName;
}
public void setCompanyFullName(String companyFullName) {
this.companyFullName = companyFullName;
}
public LocalDate getTradingDate() {
return tradingDate;
}
public void setTradingDate(LocalDate tradingDate) {
this.tradingDate = tradingDate;
}
public Long getExchangeExecutionId() {
return exchangeExecutionId;
}
public void setExchangeExecutionId(Long exchangeExecutionId) {
this.exchangeExecutionId = exchangeExecutionId;
}
public Instant getExchangeExecutionTime() {
return exchangeExecutionTime;
}
public void setExchangeExecutionTime(Instant exchangeExecutionTime) {
this.exchangeExecutionTime = exchangeExecutionTime;
}
public String getSecuritySymbol() {
return securitySymbol;
}
public void setSecuritySymbol(String securitySymbol) {
this.securitySymbol = securitySymbol;
}
public String getSecurityFullName() {
return securityFullName;
}
public void setSecurityFullName(String securityFullName) {
this.securityFullName = securityFullName;
}
public String getSellerFullName() {
return sellerFullName;
}
public void setSellerFullName(String sellerFullName) {
this.sellerFullName = sellerFullName;
}
public String getSellerClearingCode() {
return sellerClearingCode;
}
public void setSellerClearingCode(String sellerClearingCode) {
this.sellerClearingCode = sellerClearingCode;
}
public String getSellerAccount() {
return sellerAccount;
}
public void setSellerAccount(String sellerAccount) {
this.sellerAccount = sellerAccount;
}
public String getBuyerFullName() {
return buyerFullName;
}
public void setBuyerFullName(String buyerFullName) {
this.buyerFullName = buyerFullName;
}
public String getBuyerClearingCode() {
return buyerClearingCode;
}
public void setBuyerClearingCode(String buyerClearingCode) {
this.buyerClearingCode = buyerClearingCode;
}
public String getBuyerAccount() {
return buyerAccount;
}
public void setBuyerAccount(String buyerAccount) {
this.buyerAccount = buyerAccount;
}
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Instant getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Instant createdAt) {
this.createdAt = createdAt;
}
public Instant getUpdatedAt() {
return updatedAt;
}
public void setUpdatedAt(Instant updatedAt) {
this.updatedAt = updatedAt;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

155
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/registry/OrderRegisterNewRequest.java
View file

@ -1,155 +0,0 @@
package ru.spcex.clearing.platform.messaging.domain.cud.registry;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.InstantDateTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.InstantDateTimeSerializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
public class OrderRegisterNewRequest {
@JsonProperty
private String creditLegAccount;
@JsonProperty
private BigDecimal creditLegAmount;
@JsonProperty
private String creditLegCurrencyCode;
@JsonProperty
private Long creditLegDirection;
@JsonProperty
private String debitLegAccount;
@JsonProperty
private String sender;
@JsonProperty
private String addressee;
@JsonProperty
private String documentNumber;
@JsonProperty
private Long id;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant createdAt;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant updatedAt;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
private LocalDate clearingDate;
public String getCreditLegAccount() {
return creditLegAccount;
}
public void setCreditLegAccount(String creditLegAccount) {
this.creditLegAccount = creditLegAccount;
}
public BigDecimal getCreditLegAmount() {
return creditLegAmount;
}
public void setCreditLegAmount(BigDecimal creditLegAmount) {
this.creditLegAmount = creditLegAmount;
}
public String getCreditLegCurrencyCode() {
return creditLegCurrencyCode;
}
public void setCreditLegCurrencyCode(String creditLegCurrencyCode) {
this.creditLegCurrencyCode = creditLegCurrencyCode;
}
public Long getCreditLegDirection() {
return creditLegDirection;
}
public void setCreditLegDirection(Long creditLegDirection) {
this.creditLegDirection = creditLegDirection;
}
public String getDebitLegAccount() {
return debitLegAccount;
}
public void setDebitLegAccount(String debitLegAccount) {
this.debitLegAccount = debitLegAccount;
}
public String getSender() {
return sender;
}
public void setSender(String sender) {
this.sender = sender;
}
public String getAddressee() {
return addressee;
}
public void setAddressee(String addressee) {
this.addressee = addressee;
}
public String getDocumentNumber() {
return documentNumber;
}
public void setDocumentNumber(String documentNumber) {
this.documentNumber = documentNumber;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Instant getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Instant createdAt) {
this.createdAt = createdAt;
}
public Instant getUpdatedAt() {
return updatedAt;
}
public void setUpdatedAt(Instant updatedAt) {
this.updatedAt = updatedAt;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

235
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/registry/UncoveredDealRegisterNewRequest.java
View file

@ -1,235 +0,0 @@
package ru.spcex.clearing.platform.messaging.domain.cud.registry;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.InstantDateTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.InstantDateTimeSerializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
public class UncoveredDealRegisterNewRequest {
@JsonProperty
private Long executionId;
@JsonProperty
private String companyFullName;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
private LocalDate tradingDate;
@JsonProperty
private Long exchangeExecutionId;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant exchangeExecutionTime;
@JsonProperty
private String securitySymbol;
@JsonProperty
private String securityFullName;
@JsonProperty
private String sellerFullName;
@JsonProperty
private String sellerClearingCode;
@JsonProperty
private String sellerAccount;
@JsonProperty
private String buyerFullName;
@JsonProperty
private String buyerClearingCode;
@JsonProperty
private String buyerAccount;
@JsonProperty
private BigDecimal amount;
@JsonProperty
private String resultStatus;
@JsonProperty
private Long id;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant createdAt;
@JsonSerialize(using = InstantDateTimeSerializer.class)
@JsonDeserialize(using = InstantDateTimeDeserializer.class)
@JsonProperty
private Instant updatedAt;
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
private LocalDate clearingDate;
public Long getExecutionId() {
return executionId;
}
public void setExecutionId(Long executionId) {
this.executionId = executionId;
}
public String getCompanyFullName() {
return companyFullName;
}
public void setCompanyFullName(String companyFullName) {
this.companyFullName = companyFullName;
}
public LocalDate getTradingDate() {
return tradingDate;
}
public void setTradingDate(LocalDate tradingDate) {
this.tradingDate = tradingDate;
}
public Long getExchangeExecutionId() {
return exchangeExecutionId;
}
public void setExchangeExecutionId(Long exchangeExecutionId) {
this.exchangeExecutionId = exchangeExecutionId;
}
public Instant getExchangeExecutionTime() {
return exchangeExecutionTime;
}
public void setExchangeExecutionTime(Instant exchangeExecutionTime) {
this.exchangeExecutionTime = exchangeExecutionTime;
}
public String getSecuritySymbol() {
return securitySymbol;
}
public void setSecuritySymbol(String securitySymbol) {
this.securitySymbol = securitySymbol;
}
public String getSecurityFullName() {
return securityFullName;
}
public void setSecurityFullName(String securityFullName) {
this.securityFullName = securityFullName;
}
public String getSellerFullName() {
return sellerFullName;
}
public void setSellerFullName(String sellerFullName) {
this.sellerFullName = sellerFullName;
}
public String getSellerClearingCode() {
return sellerClearingCode;
}
public void setSellerClearingCode(String sellerClearingCode) {
this.sellerClearingCode = sellerClearingCode;
}
public String getSellerAccount() {
return sellerAccount;
}
public void setSellerAccount(String sellerAccount) {
this.sellerAccount = sellerAccount;
}
public String getBuyerFullName() {
return buyerFullName;
}
public void setBuyerFullName(String buyerFullName) {
this.buyerFullName = buyerFullName;
}
public String getBuyerClearingCode() {
return buyerClearingCode;
}
public void setBuyerClearingCode(String buyerClearingCode) {
this.buyerClearingCode = buyerClearingCode;
}
public String getBuyerAccount() {
return buyerAccount;
}
public void setBuyerAccount(String buyerAccount) {
this.buyerAccount = buyerAccount;
}
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
public String getResultStatus() {
return resultStatus;
}
public void setResultStatus(String resultStatus) {
this.resultStatus = resultStatus;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Instant getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Instant createdAt) {
this.createdAt = createdAt;
}
public Instant getUpdatedAt() {
return updatedAt;
}
public void setUpdatedAt(Instant updatedAt) {
this.updatedAt = updatedAt;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
}

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

@ -8,7 +8,7 @@ import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSeria
import java.math.BigDecimal; import java.math.BigDecimal;
import java.time.LocalDate; import java.time.LocalDate;
@Deprecated
public class KeyRateNewRequest { public class KeyRateNewRequest {
@JsonProperty @JsonProperty
public BigDecimal keyRate; public BigDecimal keyRate;

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

@ -8,7 +8,7 @@ import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSeria
import java.math.BigDecimal; import java.math.BigDecimal;
import java.time.LocalDate; import java.time.LocalDate;
@Deprecated
public class KeyRateUpdateRequest { public class KeyRateUpdateRequest {
@JsonProperty @JsonProperty
public Long id; public Long id;