diff --git a/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/scheduler/PlannerAllToday.java b/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/scheduler/PlannerAllToday.java index 80da5dc2e..4bbcfd930 100644 --- a/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/scheduler/PlannerAllToday.java +++ b/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/scheduler/PlannerAllToday.java @@ -24,6 +24,32 @@ public class PlannerAllToday extends SpcexObjectBase { private String parent; private Long parentId; + public static PlannerAllToday makePlannerAllTodayFromPlanner(Planner planner, Long parentId) { + PlannerAllToday res = new PlannerAllToday(); + res.setTask(planner.getTask()); + res.setTaskTime(planner.getTaskTime()); + res.setClearingDate(planner.getClearingDate()); + res.setMarket(planner.getMarket()); + res.setTaskStatus(planner.getTaskStatus()); + res.setCompanyId(planner.getCompanyId()); + res.setSecurityId(planner.getSecurityId()); + res.setParent("PLNR"); + res.setParentId(parentId); + return res; + } + + public static PlannerAllToday makePlannerAllTodayFromPlannerTemplate(PlannerTemplate plannerTemplate, Long parentId) { + PlannerAllToday res = new PlannerAllToday(); + res.setTask(plannerTemplate.getTask()); + res.setTaskTime(plannerTemplate.getTaskTime()); + res.setTaskStatus(plannerTemplate.getTaskStatus()); + res.setCompanyId(plannerTemplate.getCompanyId()); + res.setSecurityId(plannerTemplate.getSecurityId()); + res.setParent("TMPL"); + res.setParentId(parentId); + return res; + } + public String getTask() { return task; } @@ -95,4 +121,5 @@ public class PlannerAllToday extends SpcexObjectBase { public void setCompanyId(Long companyId) { this.companyId = companyId; } + } \ No newline at end of file diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/enums/TaskEnum.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/enums/TaskEnum.java new file mode 100644 index 000000000..44af2b51a --- /dev/null +++ b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/enums/TaskEnum.java @@ -0,0 +1,32 @@ +package ru.spcex.clearing.scheduler.enums; + +public enum TaskEnum { + PLANNER_NEW("PLANNER_NEW"), + PLANNER_UPDATE("PLANNER_UPDATE"), + PLANNER_DELETE("PLANNER_DELETE"), + PLANNER_TEMPLATE_NEW("PLANNER_TEMPLATE_NEW"), + PLANNER_TEMPLATE_UPDATE("PLANNER_TEMPLATE_UPDATE"), + PLANNER_TEMPLATE_DELETE("PLANNER_TEMPLATE_DELETE"), + CLEARING_CALENDAR_NEW("CLEARING_CALENDAR_NEW"), + CLEARING_CALENDAR_UPDATE("CLEARING_CALENDAR_UPDATE"), + CLEARING_CALENDAR_DELETE("CLEARING_CALENDAR_DELETE"); + private final String text; + + TaskEnum(String text) { + this.text = text; + } + + public static TaskEnum fromString(String text) { + for (TaskEnum b : TaskEnum.values()) { + if (b.text.equalsIgnoreCase(text)) { + return b; + } + } + return null; + } + + public String getText() { + return this.text; + } + +} diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/TaskManager.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/TaskManager.java index 8f97181f8..6f5b0d2ba 100644 --- a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/TaskManager.java +++ b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/TaskManager.java @@ -8,10 +8,13 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.lang.NonNull; import org.springframework.scheduling.TaskScheduler; import org.springframework.stereotype.Service; import ru.clearing.classes.statics.data.scheduler.ClearingCalendar; +import ru.clearing.classes.statics.data.scheduler.Planner; import ru.clearing.classes.statics.data.scheduler.PlannerAllToday; +import ru.clearing.classes.statics.data.scheduler.PlannerTemplate; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.BaseRequest; import ru.spcex.clearing.platform.messaging.domain.Consts; @@ -19,26 +22,23 @@ import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteReques import ru.spcex.clearing.platform.messaging.domain.cud.schedule.*; import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; +import ru.spcex.clearing.scheduler.enums.TaskEnum; import ru.spcex.platform.enumeration.DayStatus; import ru.spcex.platform.enumeration.Status; import ru.spcex.platform.enumeration.Task; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; -import java.time.LocalDate; -import java.time.LocalDateTime; -import java.time.LocalTime; -import java.time.ZoneId; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Objects; -import java.util.Optional; +import java.time.*; +import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.ScheduledFuture; import java.util.stream.Collectors; +import static ru.clearing.classes.statics.data.scheduler.PlannerAllToday.makePlannerAllTodayFromPlanner; +import static ru.clearing.classes.statics.data.scheduler.PlannerAllToday.makePlannerAllTodayFromPlannerTemplate; import static ru.spcex.clearing.platform.messaging.domain.Consts.LAUNCHER_NEW; import static ru.spcex.platform.enumeration.Status.*; import static ru.spcex.platform.utils.enumeration.IEnumKey.getEnumByKey; @@ -53,10 +53,12 @@ public class TaskManager extends QueueConsumer implements InitializingBean { private final TaskScheduler taskScheduler; private final ImdgProvider imdgProvider; + private final Producer kafkaProducer; private Imdg plannerAllTodayMap; private Imdg clearingCalendarMap; + private Imdg plannerMap; + private Imdg plannerTemplateMap; private ConcurrentHashMap scheduledJobs; - private Producer kafkaProducer; @Autowired public TaskManager(TaskScheduler taskScheduler, @@ -69,43 +71,95 @@ public class TaskManager extends QueueConsumer implements InitializingBean { this.kafkaProducer = kafkaProducer; } - @Override public void afterPropertiesSet() throws Exception { plannerAllTodayMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PlannerAllToday, PlannerAllToday.class); clearingCalendarMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingCalendar.class); + plannerMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Planner, Planner.class); + plannerTemplateMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PlannerTemplate, PlannerTemplate.class); scheduledJobs = new ConcurrentHashMap<>(); updateScheduler(); - callback(PlannerNewRequest.class) - .setFunction(this::newPlanner) + callback(TaskManagerRequest.class) + .setFunction(this::processTask) .forDestination(Consts.DESTINATION_PLANNER_NEW, callbacks::put);//fixme - callback(PlannerUpdateRequest.class) - .setFunction(this::updatePlanner) - .forDestination(Consts.DESTINATION_PLANNER_UPDATE, callbacks::put);//fixme - callback(CommonDeleteRequest.class) - .setFunction(this::deletePlanner) - .forDestination(Consts.DESTINATION_PLANNER_DELETE, callbacks::put);//fixme - callback(PlannerTemplateNewRequest.class) - .setFunction(this::newPlannerTemplate) - .forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_NEW, callbacks::put); - callback(PlannerTemplateUpdateRequest.class) - .setFunction(this::updatePlannerTemplate) - .forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_UPDATE, callbacks::put); - callback(CommonDeleteRequest.class) - .setFunction(this::deletePlannerTemplate) - .forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_DELETE, callbacks::put); - callback(ClearingCalendarNewRequest.class) - .setFunction(this::newClearingCalendar) - .forDestination(Consts.DESTINATION_CLEARING_CALENDAR_NEW, callbacks::put); - callback(ClearingCalendarUpdateRequest.class) - .setFunction(this::updateClearingCalendar) - .forDestination(Consts.DESTINATION_CLEARING_CALENDAR_UPDATE, callbacks::put); - callback(CommonDeleteRequest.class) - .setFunction(this::deleteClearingCalendar) - .forDestination(Consts.DESTINATION_CLEARING_CALENDAR_DELETE, callbacks::put); init(); } + private Object processTask(BaseRequest taskManagerRequestBaseRequest) { + LocalDate currentDate = LocalDate.now(); + TaskManagerRequest taskManagerRequest = taskManagerRequestBaseRequest.getRequestPayload(); + switch (Objects.requireNonNull(TaskEnum.fromString(taskManagerRequest.getAction()))) { + case PLANNER_NEW -> { + Planner planner = getPlannerById(taskManagerRequest.parentId); + PlannerAllToday plannerAllToday = makePlannerAllTodayFromPlanner(planner, taskManagerRequest.parentId); + createTask(plannerAllToday); + } + case PLANNER_UPDATE -> { + Planner planner = getPlannerById(taskManagerRequest.parentId); + PlannerAllToday plannerAllToday = makePlannerAllTodayFromPlanner(planner, taskManagerRequest.parentId); + updateTask(plannerAllToday); + } + case PLANNER_DELETE -> { + deleteTask(taskManagerRequest.task, taskManagerRequest.taskTime); + } + + case PLANNER_TEMPLATE_NEW -> { + PlannerTemplate template = getPlannerTemplateById(taskManagerRequest.parentId); + PlannerAllToday plannerAllToday = makePlannerAllTodayFromPlannerTemplate(template, taskManagerRequest.parentId); + boolean weekend = Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(LocalDate.now().getDayOfWeek()); + if (clearingCalendarMap == null || clearingCalendarMap.getAllValues().isEmpty()) { + if (!weekend && plannerAllToday.getTaskTime().equals(currentDate)) { + createTask(plannerAllToday); + } + } else { + Optional clearingCalendarOptional = clearingCalendarMap.getAllValues().stream() + .filter((calendar) -> calendar.getClearingDate().isEqual(currentDate)) + .findFirst(); + if (clearingCalendarOptional.isPresent()) { + ClearingCalendar calendar = clearingCalendarOptional.get(); + if (calendar.getDayStatus().equalsIgnoreCase(DayStatus.Workday.getKey())) { + if (calendar.getCompanyId() != null && calendar.getCompanyId() != 0) { + createTask(plannerAllToday); + } + } + } + } + } + case PLANNER_TEMPLATE_UPDATE -> { + PlannerTemplate template = getPlannerTemplateById(taskManagerRequest.parentId); + PlannerAllToday plannerAllToday = makePlannerAllTodayFromPlannerTemplate(template, taskManagerRequest.parentId); + updateTask(plannerAllToday); + } + case PLANNER_TEMPLATE_DELETE -> { + //todo + } + case CLEARING_CALENDAR_NEW -> { + //todo + } + case CLEARING_CALENDAR_UPDATE -> { + + } + case CLEARING_CALENDAR_DELETE -> { + + + } + } + + return new Object(); + } + + private void createTask(PlannerAllToday task) { + + } + + private void updateTask(PlannerAllToday task) { + + } + + private void deleteTask(String task, LocalTime taskTime) { + + } + // --- Планирование задач --- protected void updateScheduler() { Collection schedulerAllTodays = plannerAllTodayMap.getAllValues(); @@ -117,6 +171,20 @@ public class TaskManager extends QueueConsumer implements InitializingBean { } } + @NonNull + public Planner getPlannerById(Long id) { + return plannerMap.getSingleObjectByID(id); + } + + @NonNull + public PlannerTemplate getPlannerTemplateById(Long id) { + return plannerTemplateMap.getSingleObjectByID(id); + } + + @NonNull + public ClearingCalendar getClearingCalendarById(Long id) { + return clearingCalendarMap.getSingleObjectByID(id); + } public RequestInfoUpdate newPlanner(BaseRequest userRequest) { RequestInfoUpdate requestInfoUpdate = new RequestInfoUpdate(); @@ -200,10 +268,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean { if (calendar.getDayStatus().equalsIgnoreCase(DayStatus.Workday.getKey())) { if (calendar.getCompanyId() != null && calendar.getCompanyId() != 0) { Optional plannerAllTodayOptional = plannerAllTodayMap.getAllValues().stream().filter((x) -> { - if (x.getTaskTime().equals(request.getTaskTime()) && x.getTask().equalsIgnoreCase(request.getTask())) { - return true; - } - return false; + return x.getTaskTime().equals(request.getTaskTime()) && x.getTask().equalsIgnoreCase(request.getTask()); }).findFirst(); PlannerAllToday planner; if (plannerAllTodayOptional.isPresent()) { @@ -246,6 +311,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean { removeTask(plannerAllToday.getTask(), plannerAllToday.getTaskTime()); } + //при создании новой энтри private void newEntry(PlannerAllToday task) { Task taskType = getEnumByKey(Task.class, task.getTask()); if (taskType == null) { @@ -258,6 +324,8 @@ public class TaskManager extends QueueConsumer implements InitializingBean { plannerAllTodayMap.insert(task); } + + //при добавлении Entry private void updateEntry(PlannerAllToday plannerAllToday) { PlannerAllToday task = plannerAllToday; PlannerAllToday oldTask; @@ -265,11 +333,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean { if (!x.getTaskTime().equals(task.getTaskTime())) { return false; } - - if (!x.getTask().equalsIgnoreCase(task.getTask())) { - return false; - } - return true; + return x.getTask().equalsIgnoreCase(task.getTask()); }).findFirst(); if (!optionalOldTask.isPresent()) { @@ -303,6 +367,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean { } + //востановить таск, который был удален из запланированных private void restorePreviouslyRemovedTask(LocalTime oldTime, PlannerAllToday oldTask) { ScheduledFuture cancelledFuture = scheduledJobs.get(oldTime); if (cancelledFuture != null && cancelledFuture.isCancelled()) { @@ -315,6 +380,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean { } } + // убрать таск из очереди plannerAllToday private void removePlannerAllToday(String task, LocalTime taskTime) { for (PlannerAllToday x : plannerAllTodayMap.getAllValues()) { if (x.getTaskTime().equals(taskTime) && x.getTask().equalsIgnoreCase(task)) { @@ -324,6 +390,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean { } } + // убрать таск из запланированных и очереди plannerAllToday private boolean removeTask(String task, LocalTime taskTime) { removePlannerAllToday(task, taskTime); ScheduledFuture future = scheduledJobs.remove(taskTime); @@ -334,6 +401,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean { return future.cancel(false); } + // выполнение работы protected void doJob(PlannerAllToday task) { Task taskE = getEnumByKey(Task.class, task.getTask()); if (taskE != null) { diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/schedule/TaskManagerRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/schedule/TaskManagerRequest.java new file mode 100644 index 000000000..bdc4d824e --- /dev/null +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/schedule/TaskManagerRequest.java @@ -0,0 +1,43 @@ +package ru.spcex.clearing.platform.messaging.domain.cud.schedule; + +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.time.LocalTime; + +public class TaskManagerRequest { + @JsonProperty + public Long parentId; + @JsonProperty + public String action; //new update delete + @JsonProperty + public String parent; + + @JsonProperty + public String task; + @JsonProperty + public LocalTime taskTime; + + public Long getParentId() { + return parentId; + } + + public void setParentId(Long parentId) { + this.parentId = parentId; + } + + public String getAction() { + return action; + } + + public void setAction(String action) { + this.action = action; + } + + public String getParent() { + return parent; + } + + public void setParent(String parent) { + this.parent = parent; + } +}