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

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

Browse source
This commit is contained in:
ialbert 2022-12-07 14:41:20 +03:00
parent c760bd4d20
commit e8af75ee78
12 changed files with 843 additions and 185 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/ClearingCalendarController.java
View file

@ -1,28 +1,38 @@
package ru.spcex.clearing.backendapi.controller.queue.scheduler;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.*;
import ru.clearing.classes.statics.data.scheduler.ClearingCalendar;
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.schedule.ClearingCalendarNewAction;
import ru.spcex.clearing.backendapi.controller.request.cud.schedule.ClearingCalendarUpdateAction;
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("/schedule/clearing-calendars")
public class ClearingCalendarController {
public class ClearingCalendarController extends AbstractQueueController {
private final IStateLoader stateLoader;
@Autowired
public ClearingCalendarController(IStateLoader stateLoader) {
public ClearingCalendarController(IStateLoader stateLoader, IOperator operator) {
super(operator);
this.stateLoader = stateLoader;
}
@ -36,4 +46,38 @@ public class ClearingCalendarController {
response.fromEntity(all);
return response;
}
@ApiOperation(value = "new planner clearing calendar.")
@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 ClearingCalendarNewAction clearingCalendarNewAction) throws ExecutionException, InterruptedException {
return processRequest(Consts.DESTINATION_CLEARING_CALENDAR_NEW, clearingCalendarNewAction);
}
@ApiOperation(value = "update clearing calendar.")
@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 ClearingCalendarUpdateAction clearingCalendarUpdateAction) throws ExecutionException, InterruptedException {
clearingCalendarUpdateAction.setId(id);
return processRequest(Consts.DESTINATION_CLEARING_CALENDAR_UPDATE, clearingCalendarUpdateAction);
}
@ApiOperation(value = "delete clearing calendar.")
@ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.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_CLEARING_CALENDAR_DELETE, deleteAction);
}
}

87
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/PlanerAllTodayController.java
View file

@ -1,87 +0,0 @@
package ru.spcex.clearing.backendapi.controller.queue.scheduler;
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.RequestBody;
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.scheduler.Scheduler;
import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
import ru.spcex.clearing.backendapi.controller.request.cud.schedule.SchedulerNewAction;
import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
import ru.clearing.classes.statics.data.scheduler.PlannerAllToday;
import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
import ru.spcex.clearing.backendapi.controller.response.entity.schedule.SchedulerBackendGetAll;
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("/schedule/planners-all-today")
public class PlanerAllTodayController extends AbstractQueueController {
private final IStateLoader stateLoader;
@Autowired
public PlanerAllTodayController(IStateLoader stateLoader, IOperator operator) {
super(operator);
this.stateLoader = stateLoader;
}
@ApiOperation(value = "get all PlannerAllToday objects.")
@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_PlannerAllToday, PlannerAllToday.class);
var response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
@ApiOperation(value = "create scheduler.")
@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 SchedulerNewAction schedulerNewAction) throws ExecutionException, InterruptedException {
return processRequest(Consts.DESTINATION_SCHEDULER_NEW, schedulerNewAction);
}
//
//@ApiOperation(value = "update money security.")
//@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 MoneyMarketSecurityUpdateAction moneySecurityUpdateAction) throws ExecutionException, InterruptedException {
// moneySecurityUpdateAction.setId(id);
// return processRequest(Consts.DESTINATION_MONEY_MARKET_SECURITY_UPDATE, moneySecurityUpdateAction);
//}
//
//@ApiOperation(value = "delete money security.")
//@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_MONEY_MARKET_SECURITY_DELETE, deleteAction);
//}
}

42
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/PlannerAllTodayController.java Normal file
View file

@ -0,0 +1,42 @@
package ru.spcex.clearing.backendapi.controller.queue.scheduler;
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.scheduler.PlannerAllToday;
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("/schedule/planners-all-today")
public class PlannerAllTodayController extends AbstractQueueController {
private final IStateLoader stateLoader;
@Autowired
public PlannerAllTodayController(IStateLoader stateLoader, IOperator operator) {
super(operator);
this.stateLoader = stateLoader;
}
@ApiOperation(value = "get all PlannerAllToday objects.")
@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_PlannerAllToday, PlannerAllToday.class);
var response = new CommonGetAllResponse();
response.fromEntity(all);
return response;
}
}

54
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/PlannerController.java
View file

@ -1,28 +1,38 @@
package ru.spcex.clearing.backendapi.controller.queue.scheduler;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.*;
import ru.clearing.classes.statics.data.scheduler.Planner;
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.schedule.PlannerNewAction;
import ru.spcex.clearing.backendapi.controller.request.cud.schedule.PlannerUpdateAction;
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("/schedule/planners")
public class PlannerController {
public class PlannerController extends AbstractQueueController {
private final IStateLoader stateLoader;
@Autowired
public PlannerController(IStateLoader stateLoader) {
public PlannerController(IOperator operator, IStateLoader stateLoader) {
super(operator);
this.stateLoader = stateLoader;
}
@ -36,4 +46,38 @@ public class PlannerController {
response.fromEntity(all);
return response;
}
@ApiOperation(value = "new planner.")
@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 PlannerNewAction plannerNewAction) throws ExecutionException, InterruptedException {
return processRequest(Consts.DESTINATION_PLANNER_NEW, plannerNewAction);
}
@ApiOperation(value = "update planner.")
@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 PlannerUpdateAction plannerUpdateAction) throws ExecutionException, InterruptedException {
plannerUpdateAction.setId(id);
return processRequest(Consts.DESTINATION_PLANNER_UPDATE, plannerUpdateAction);
}
@ApiOperation(value = "delete planner.")
@ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.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_PLANNER_DELETE, deleteAction);
}
}

54
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/PlannerTemplateController.java
View file

@ -1,28 +1,38 @@
package ru.spcex.clearing.backendapi.controller.queue.scheduler;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.*;
import ru.clearing.classes.statics.data.scheduler.PlannerTemplate;
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.schedule.PlannerTemplateNewAction;
import ru.spcex.clearing.backendapi.controller.request.cud.schedule.PlannerTemplateUpdateAction;
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("/schedule/planner-templates")
public class PlannerTemplateController {
public class PlannerTemplateController extends AbstractQueueController {
private final IStateLoader stateLoader;
@Autowired
public PlannerTemplateController(IStateLoader stateLoader) {
public PlannerTemplateController(IStateLoader stateLoader, IOperator operator) {
super(operator);
this.stateLoader = stateLoader;
}
@ -36,4 +46,38 @@ public class PlannerTemplateController {
response.fromEntity(all);
return response;
}
@ApiOperation(value = "new planner template.")
@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 PlannerTemplateNewAction plannerTemplateNewAction) throws ExecutionException, InterruptedException {
return processRequest(Consts.DESTINATION_PLANNER_TEMPLATE_NEW, plannerTemplateNewAction);
}
@ApiOperation(value = "update planner template.")
@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 PlannerTemplateUpdateAction plannerTemplateUpdateAction) throws ExecutionException, InterruptedException {
plannerTemplateUpdateAction.setId(id);
return processRequest(Consts.DESTINATION_PLANNER_TEMPLATE_UPDATE, plannerTemplateUpdateAction);
}
@ApiOperation(value = "delete planner template.")
@ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.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_PLANNER_TEMPLATE_DELETE, deleteAction);
}
}

83
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/ClearingCalendarNewAction.java Normal file
View file

@ -0,0 +1,83 @@
package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
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.schedule.ClearingCalendarNewRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.text.TextUtil;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class ClearingCalendarNewAction implements IAction<ClearingCalendarNewRequest> {
@ApiModelProperty(value = "Дата", example = "2022-12-25")
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate clearingDate;
@ApiModelProperty(value = "Компания", example = "1000")
@JsonProperty
public Long companyId;
@ApiModelProperty(value = "Статус", example = "ABCD")
@JsonProperty
public String dayStatus;
@Override
public ClearingCalendarNewRequest toRequest() {
ClearingCalendarNewRequest clearingCalendarNewRequest = new ClearingCalendarNewRequest();
clearingCalendarNewRequest.setClearingDate(clearingDate);
clearingCalendarNewRequest.setCompanyId(companyId);
clearingCalendarNewRequest.setDayStatus(dayStatus);
return clearingCalendarNewRequest;
}
@Override
public ActionType getActionType() {
return ActionType.NEW;
}
@Override
public Collection<EnumMessage> validate() {
List<EnumMessage> errors = new ArrayList<>();
if (clearingDate == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"clearingDate"));
}
if (TextUtil.isEmpty(dayStatus)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskStatus"));
}
return errors;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
public Long getCompanyId() {
return companyId;
}
public void setCompanyId(Long companyId) {
this.companyId = companyId;
}
public String getDayStatus() {
return dayStatus;
}
public void setDayStatus(String dayStatus) {
this.dayStatus = dayStatus;
}
}

101
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/ClearingCalendarUpdateAction.java Normal file
View file

@ -0,0 +1,101 @@
package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
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.schedule.ClearingCalendarUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import ru.spcex.platform.classes.base.interfaces.WithId;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.text.TextUtil;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class ClearingCalendarUpdateAction implements IAction<ClearingCalendarUpdateRequest>, WithId {
@ApiModelProperty(hidden = true)
@JsonProperty
public Long id;
@ApiModelProperty(value = "Дата", example = "2022-12-25")
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate clearingDate;
@ApiModelProperty(value = "Компания", example = "1000")
@JsonProperty
public Long companyId;
@ApiModelProperty(value = "Статус", example = "ABCD")
@JsonProperty
public String dayStatus;
@Override
public ClearingCalendarUpdateRequest toRequest() {
ClearingCalendarUpdateRequest clearingCalendarUpdateRequest = new ClearingCalendarUpdateRequest();
clearingCalendarUpdateRequest.setId(id);
clearingCalendarUpdateRequest.setClearingDate(clearingDate);
clearingCalendarUpdateRequest.setCompanyId(companyId);
clearingCalendarUpdateRequest.setDayStatus(dayStatus);
return clearingCalendarUpdateRequest;
}
@Override
public ActionType getActionType() {
return ActionType.UPDATE;
}
@Override
public Collection<EnumMessage> validate() {
List<EnumMessage> errors = new ArrayList<>();
if (id == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"id"));
}
if (clearingDate == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"clearingDate"));
}
if (TextUtil.isEmpty(dayStatus)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskStatus"));
}
return errors;
}
@Override
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
public Long getCompanyId() {
return companyId;
}
public void setCompanyId(Long companyId) {
this.companyId = companyId;
}
public String getDayStatus() {
return dayStatus;
}
public void setDayStatus(String dayStatus) {
this.dayStatus = dayStatus;
}
}

135
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerNewAction.java Normal file
View file

@ -0,0 +1,135 @@
package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
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.schedule.PlannerNewRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalTimeSerializer;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.text.TextUtil;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class PlannerNewAction implements IAction<PlannerNewRequest> {
@ApiModelProperty(value = "Идентификатор задачи", example = "ABCD")
@JsonProperty
private String task;
@ApiModelProperty(value = "Время", example = "16:30:00")
@JsonSerialize(using = LocalTimeSerializer.class)
@JsonDeserialize(using = LocalTimeDeserializer.class)
@JsonProperty
public LocalTime taskTime;
@ApiModelProperty(value = "Дата", example = "2022-12-25")
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate clearingDate;
@ApiModelProperty(value = "Секция", example = "ABCD")
@JsonProperty
public String market;
@ApiModelProperty(value = "Статус", example = "ABCD")
@JsonProperty
public String taskStatus;
@ApiModelProperty(value = "Инструмент", example = "1000")
@JsonProperty
public Long securityId;
@Override
public PlannerNewRequest toRequest() {
PlannerNewRequest plannerNewRequest = new PlannerNewRequest();
plannerNewRequest.setTask(task);
plannerNewRequest.setTaskTime(taskTime);
plannerNewRequest.setClearingDate(clearingDate);
plannerNewRequest.setMarket(market);
plannerNewRequest.setTaskStatus(taskStatus);
plannerNewRequest.setSecurityId(securityId);
return plannerNewRequest;
}
@Override
public ActionType getActionType() {
return ActionType.NEW;
}
@Override
public Collection<EnumMessage> validate() {
List<EnumMessage> errors = new ArrayList<>();
if (TextUtil.isEmpty(task)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"task"));
}
if (taskTime == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskTime"));
}
if (clearingDate == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"clearingDate"));
}
if (TextUtil.isEmpty(taskStatus)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskStatus"));
}
return errors;
}
public String getTask() {
return task;
}
public void setTask(String task) {
this.task = task;
}
public LocalTime getTaskTime() {
return taskTime;
}
public void setTaskTime(LocalTime taskTime) {
this.taskTime = taskTime;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
public String getMarket() {
return market;
}
public void setMarket(String market) {
this.market = market;
}
public String getTaskStatus() {
return taskStatus;
}
public void setTaskStatus(String taskStatus) {
this.taskStatus = taskStatus;
}
public Long getSecurityId() {
return securityId;
}
public void setSecurityId(Long securityId) {
this.securityId = securityId;
}
}

82
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerTemplateNewAction.java Normal file
View file

@ -0,0 +1,82 @@
package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
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.schedule.PlannerTemplateNewRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalTimeSerializer;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.text.TextUtil;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class PlannerTemplateNewAction implements IAction<PlannerTemplateNewRequest> {
@JsonProperty
public String task;
@JsonSerialize(using = LocalTimeSerializer.class)
@JsonDeserialize(using = LocalTimeDeserializer.class)
@JsonProperty
public LocalTime taskTime;
@JsonProperty
public String taskStatus;
@Override
public PlannerTemplateNewRequest toRequest() {
PlannerTemplateNewRequest plannerTemplateNewRequest = new PlannerTemplateNewRequest();
plannerTemplateNewRequest.setTask(task);
plannerTemplateNewRequest.setTaskTime(taskTime);
plannerTemplateNewRequest.setTaskStatus(taskStatus);
return plannerTemplateNewRequest;
}
@Override
public ActionType getActionType() {
return ActionType.NEW;
}
@Override
public Collection<EnumMessage> validate() {
List<EnumMessage> errors = new ArrayList<>();
if (TextUtil.isEmpty(task)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"task"));
}
if (taskTime == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskTime"));
}
if (TextUtil.isEmpty(taskStatus)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskStatus"));
}
return errors;
}
public String getTask() {
return task;
}
public void setTask(String task) {
this.task = task;
}
public LocalTime getTaskTime() {
return taskTime;
}
public void setTaskTime(LocalTime taskTime) {
this.taskTime = taskTime;
}
public String getTaskStatus() {
return taskStatus;
}
public void setTaskStatus(String taskStatus) {
this.taskStatus = taskStatus;
}
}

100
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerTemplateUpdateAction.java Normal file
View file

@ -0,0 +1,100 @@
package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
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.schedule.PlannerTemplateUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalTimeSerializer;
import ru.spcex.platform.classes.base.interfaces.WithId;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.text.TextUtil;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class PlannerTemplateUpdateAction implements IAction<PlannerTemplateUpdateRequest>, WithId {
@ApiModelProperty(hidden = true)
@JsonProperty
public Long id;
@JsonProperty
public String task;
@JsonSerialize(using = LocalTimeSerializer.class)
@JsonDeserialize(using = LocalTimeDeserializer.class)
@JsonProperty
public LocalTime taskTime;
@JsonProperty
public String taskStatus;
@Override
public PlannerTemplateUpdateRequest toRequest() {
PlannerTemplateUpdateRequest plannerTemplateUpdateRequest = new PlannerTemplateUpdateRequest();
plannerTemplateUpdateRequest.setId(id);
plannerTemplateUpdateRequest.setTask(task);
plannerTemplateUpdateRequest.setTaskTime(taskTime);
plannerTemplateUpdateRequest.setTaskStatus(taskStatus);
return plannerTemplateUpdateRequest;
}
@Override
public ActionType getActionType() {
return ActionType.UPDATE;
}
@Override
public Collection<EnumMessage> validate() {
List<EnumMessage> errors = new ArrayList<>();
if (id == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"id"));
}
if (TextUtil.isEmpty(task)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"task"));
}
if (taskTime == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskTime"));
}
if (TextUtil.isEmpty(taskStatus)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskStatus"));
}
return errors;
}
@Override
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTask() {
return task;
}
public void setTask(String task) {
this.task = task;
}
public LocalTime getTaskTime() {
return taskTime;
}
public void setTaskTime(LocalTime taskTime) {
this.taskTime = taskTime;
}
public String getTaskStatus() {
return taskStatus;
}
public void setTaskStatus(String taskStatus) {
this.taskStatus = taskStatus;
}
}

153
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerUpdateAction.java Normal file
View file

@ -0,0 +1,153 @@
package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
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.schedule.PlannerUpdateRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalTimeDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalTimeSerializer;
import ru.spcex.platform.classes.base.interfaces.WithId;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.text.TextUtil;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class PlannerUpdateAction implements IAction<PlannerUpdateRequest>, WithId {
@ApiModelProperty(hidden = true)
@JsonProperty
public Long id;
@ApiModelProperty(value = "Идентификатор задачи", example = "ABCD")
@JsonProperty
private String task;
@ApiModelProperty(value = "Время", example = "16:30:00")
@JsonSerialize(using = LocalTimeSerializer.class)
@JsonDeserialize(using = LocalTimeDeserializer.class)
@JsonProperty
public LocalTime taskTime;
@ApiModelProperty(value = "Дата", example = "2022-12-25")
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate clearingDate;
@ApiModelProperty(value = "Секция", example = "ABCD")
@JsonProperty
public String market;
@ApiModelProperty(value = "Статус", example = "ABCD")
@JsonProperty
public String taskStatus;
@ApiModelProperty(value = "Инструмент", example = "1000")
@JsonProperty
public Long securityId;
@Override
public PlannerUpdateRequest toRequest() {
PlannerUpdateRequest plannerUpdateRequest = new PlannerUpdateRequest();
plannerUpdateRequest.setId(id);
plannerUpdateRequest.setTask(task);
plannerUpdateRequest.setTaskTime(taskTime);
plannerUpdateRequest.setClearingDate(clearingDate);
plannerUpdateRequest.setMarket(market);
plannerUpdateRequest.setTaskStatus(taskStatus);
plannerUpdateRequest.setSecurityId(securityId);
return plannerUpdateRequest;
}
@Override
public ActionType getActionType() {
return ActionType.UPDATE;
}
@Override
public Collection<EnumMessage> validate() {
List<EnumMessage> errors = new ArrayList<>();
if (id == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"id"));
}
if (TextUtil.isEmpty(task)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"task"));
}
if (taskTime == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskTime"));
}
if (clearingDate == null) {
errors.add(new EnumMessage(BackEndError.ValidationError,"clearingDate"));
}
if (TextUtil.isEmpty(taskStatus)) {
errors.add(new EnumMessage(BackEndError.ValidationError,"taskStatus"));
}
return errors;
}
@Override
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTask() {
return task;
}
public void setTask(String task) {
this.task = task;
}
public LocalTime getTaskTime() {
return taskTime;
}
public void setTaskTime(LocalTime taskTime) {
this.taskTime = taskTime;
}
public LocalDate getClearingDate() {
return clearingDate;
}
public void setClearingDate(LocalDate clearingDate) {
this.clearingDate = clearingDate;
}
public String getMarket() {
return market;
}
public void setMarket(String market) {
this.market = market;
}
public String getTaskStatus() {
return taskStatus;
}
public void setTaskStatus(String taskStatus) {
this.taskStatus = taskStatus;
}
public Long getSecurityId() {
return securityId;
}
public void setSecurityId(Long securityId) {
this.securityId = securityId;
}
}

83
clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/SchedulerNewAction.java
View file

@ -1,83 +0,0 @@
package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
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.schedule.SchedulerNewRequest;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalTimeDeserializer;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.text.TextUtil;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class SchedulerNewAction implements IAction<SchedulerNewRequest> {
@ApiModelProperty(value = "Идентификатор задачи", example = "ABCD")
@JsonProperty
private String task;
@ApiModelProperty(value = "Время", example = "01:30:00")
@JsonDeserialize(using = LocalTimeDeserializer.class)
@JsonProperty
public LocalTime taskTime;
@ApiModelProperty(value = "Дата", example = "2022-01-20")
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonProperty
public LocalDate clearingDate;
@ApiModelProperty(value = "Секция", example = "ABCD")
@JsonProperty
private String market;
@ApiModelProperty(value = "Статус", example = "ABCD")
@JsonProperty
private String taskStatus;
@ApiModelProperty(value = "Инструмент", example = "1000")
@JsonProperty
private Long securityId;
@Override
public SchedulerNewRequest toRequest() {
SchedulerNewRequest schedulerNewRequest = new SchedulerNewRequest();
schedulerNewRequest.setTask(task);
schedulerNewRequest.setTaskTime(taskTime);
schedulerNewRequest.setClearingDate(clearingDate);
schedulerNewRequest.setMarket(market);
schedulerNewRequest.setTaskStatus(taskStatus);
schedulerNewRequest.setSecurityId(securityId);
return schedulerNewRequest;
}
@Override
public ActionType getActionType() {
return ActionType.NEW;
}
@Override
public Collection<EnumMessage> validate() {
List<EnumMessage> validationErrors = new ArrayList<>();
if (TextUtil.isEmpty(task)) {
validationErrors.add(new EnumMessage(BackEndError.ValidationError, "task"));
}
if (taskTime == null) {
validationErrors.add(new EnumMessage(BackEndError.ValidationError, "taskTime"));
}
if (clearingDate == null) {
validationErrors.add(new EnumMessage(BackEndError.ValidationError, "clearingDate"));
}
if (TextUtil.isEmpty(taskStatus)) {
validationErrors.add(new EnumMessage(BackEndError.ValidationError, "taskStatus"));
}
return validationErrors;
}
}