TaskManage update

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

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

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.*;
-import java.time.LocalDateTime;
+import java.util.*;
-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.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<String, Object> kafkaProducer;
     private Imdg<PlannerAllToday> plannerAllTodayMap;
     private Imdg<ClearingCalendar> clearingCalendarMap;
+    private Imdg<Planner> plannerMap;
+    private Imdg<PlannerTemplate> plannerTemplateMap;
     private ConcurrentHashMap<LocalTime, ScheduledFuture> scheduledJobs;
-    private Producer<String, Object> 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)
+        callback(TaskManagerRequest.class)
-                .setFunction(this::newPlanner)
+                .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<TaskManagerRequest> 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<ClearingCalendar> 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<PlannerAllToday> 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<PlannerNewRequest> 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<PlannerAllToday> plannerAllTodayOptional = plannerAllTodayMap.getAllValues().stream().filter((x) -> {
-                        if (x.getTaskTime().equals(request.getTaskTime()) && x.getTask().equalsIgnoreCase(request.getTask())) {
+                        return x.getTaskTime().equals(request.getTaskTime()) && x.getTask().equalsIgnoreCase(request.getTask());
-                            return true;
-                        }
-                        return false;
                     }).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;
             }
-
+            return x.getTask().equalsIgnoreCase(task.getTask());
-            if (!x.getTask().equalsIgnoreCase(task.getTask())) {
-                return false;
-            }
-            return true;
         }).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) {

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