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

add entry listener to map
static Util -> bean PlannerAllTodayMaker
fix condition removeIf
add enum Parent(tmpl, plnr, clnd)
add enum DayStatus(bday, doff)

clearing-parent/imdg/pom.xml

@@ -71,6 +71,10 @@
             <groupId>ru.spcex.platform</groupId>
             <artifactId>platform-imdg-api-hazelcast-impl</artifactId>
         </dependency>
+        <dependency>
+            <groupId>ru.spcex.platform</groupId>
+            <artifactId>platform-enum</artifactId>
+        </dependency>
 
         <!-- TEST -->
         <dependency>

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

@@ -19,17 +19,17 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.*;
 
-import static ru.spcex.clearing.imdg.util.Util.makeSchedulerAllTodayMap;
-
 //todo почистить класс
 public abstract class AbstractHazelcastLifecycleSupport implements InitializingBean, DisposableBean {
     private final Logger log = LoggerFactory.getLogger(this.getClass());
     private final HazelcastInstance hazelcastServerInstance;
     private final JdbcTemplate jdbcTemplate;
+    private final PlannerAllTodayMaker plannerAllTodayMaker;
 
-    public AbstractHazelcastLifecycleSupport(HazelcastInstance hazelcastServerInstance, JdbcTemplate jdbcTemplate) {
+    public AbstractHazelcastLifecycleSupport(HazelcastInstance hazelcastServerInstance, JdbcTemplate jdbcTemplate, PlannerAllTodayMaker plannerAllTodayMaker) {
         this.hazelcastServerInstance = hazelcastServerInstance;
         this.jdbcTemplate = jdbcTemplate;
+        this.plannerAllTodayMaker = plannerAllTodayMaker;
     }
 
     /**
@@ -103,7 +103,7 @@ public abstract class AbstractHazelcastLifecycleSupport implements InitializingB
             boolean generatorResult = generator.init(maxKey);
             if (generatorResult) {
                 log.info("IDGenerator {} success init by {}", IMDGDistributedNames.MAP_SEQUENCE_NAME, maxKey);
-                makeSchedulerAllTodayMap(hazelcastServerInstance);
+                plannerAllTodayMaker.makeSchedulerAllTodayMap();
             } else {
                 log.info("IDGenerator {} already initialized in other node", IMDGDistributedNames.MAP_SEQUENCE_NAME);
             }

clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/services/HazelcastLifecycleSupport.java

@@ -19,8 +19,8 @@ public class HazelcastLifecycleSupport extends AbstractHazelcastLifecycleSupport
     private final Logger log = LoggerFactory.getLogger(this.getClass());
 
     @Autowired
-    public HazelcastLifecycleSupport(HazelcastInstance hazelcastServerInstance, JdbcTemplate jdbcTemplate) {
+    public HazelcastLifecycleSupport(HazelcastInstance hazelcastServerInstance, JdbcTemplate jdbcTemplate, PlannerAllTodayMaker plannerAllTodayMaker) {
-        super(hazelcastServerInstance, jdbcTemplate);
+        super(hazelcastServerInstance, jdbcTemplate, plannerAllTodayMaker);
     }
 
     @Override

clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/services/PlannerAllTodayMaker.java

@@ -0,0 +1,115 @@
+package ru.spcex.clearing.imdg.services;
+
+import com.hazelcast.core.HazelcastInstance;
+import com.hazelcast.core.IMap;
+import org.springframework.beans.factory.annotation.Autowired;
+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.platform.enumeration.DayStatus;
+import ru.spcex.platform.enumeration.Parent;
+import ru.spcex.platform.enumeration.Status;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static ru.spcex.clearing.imdg.IMDGDistributedNames.*;
+
+@Service
+public class PlannerAllTodayMaker {
+    private final HazelcastInstance hazelcastInstance;
+    private final IMap<Long, Planner> plannerMap;
+    private final IMap<Long, ClearingCalendar> clearingCalendarMap;
+    private final IMap<Long, PlannerTemplate> plannerTemplateMap;
+    private final IMap<Long, PlannerAllToday> plannerAllTodayMap;
+
+    @Autowired
+    public PlannerAllTodayMaker(HazelcastInstance hazelcastInstance) {
+        this.hazelcastInstance = hazelcastInstance;
+        plannerMap = hazelcastInstance.getMap(Map_Planner);
+        clearingCalendarMap = hazelcastInstance.getMap(Map_ClearingCalendar);
+        plannerTemplateMap = hazelcastInstance.getMap(Map_PlannerTemplate);
+        plannerAllTodayMap = hazelcastInstance.getMap(Map_PlannerAllToday);
+    }
+    
+    public void makeSchedulerAllTodayMap() {
+        LocalDate currentDate = LocalDate.now();
+        List<PlannerAllToday> listOfPlannerAllToday = new ArrayList<>();
+
+        if (!plannerMap.isEmpty()) listOfPlannerAllToday.addAll(getPlannersAllTodayToDate(currentDate));
+
+        plannerMap.values().stream().filter((x) -> x.getClearingDate().isEqual(currentDate)).forEach((x) -> {
+            if (x.getTaskStatus().equalsIgnoreCase(Status.Active.getKey())) {
+                listOfPlannerAllToday.add(createPlannerAllTodayFromPlanner(x));
+            }
+
+            if (x.getTaskStatus().equalsIgnoreCase(Status.Cancel.getKey()) || x.getTaskStatus().equalsIgnoreCase(Status.Blocked.getKey())) {
+                listOfPlannerAllToday.removeIf((allToday) -> x.getTaskTime().equals(allToday.getTaskTime()) &&
+                        x.getTask().equalsIgnoreCase(allToday.getTask()));
+            }
+        });
+        for (PlannerAllToday plannerAllToday : listOfPlannerAllToday) {
+            plannerAllToday.setId(hazelcastInstance.getIdGenerator(MAP_SEQUENCE_NAME).newId());
+            plannerAllTodayMap.put(plannerAllToday.getId(), plannerAllToday);
+        }
+    }
+
+    private List<PlannerAllToday> getPlannersAllTodayToDate(LocalDate currentDate) {
+        boolean weekend = Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(currentDate.getDayOfWeek());
+        List<PlannerAllToday> res = new ArrayList<>();
+        if (clearingCalendarMap == null || clearingCalendarMap.isEmpty()) {
+            if (!weekend) {
+                for (PlannerTemplate plannerTemplate : plannerTemplateMap.values()) {
+                    res.add(createPlannerAllTodayFromPlannerTemplate(plannerTemplate));
+                }
+            }
+        } else {
+            Optional<ClearingCalendar> clearingCalendarOptional = clearingCalendarMap.values().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) {
+                        for (PlannerTemplate plannerTemplate : plannerTemplateMap.values()) {
+                            res.add(createPlannerAllTodayFromPlannerTemplate(plannerTemplate));
+                        }
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+
+    private PlannerAllToday createPlannerAllTodayFromPlanner(Planner planner) {
+        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(Parent.Planner.getKey());
+        res.setParentId(planner.getId());
+        return res;
+    }
+
+    private PlannerAllToday createPlannerAllTodayFromPlannerTemplate(PlannerTemplate plannerTemplate) {
+        PlannerAllToday res = new PlannerAllToday();
+        res.setTask(plannerTemplate.getTask());
+        res.setTaskTime(plannerTemplate.getTaskTime());
+        res.setTaskStatus(plannerTemplate.getTaskStatus());
+        res.setParent(Parent.Template.getKey());
+        res.setParentId(plannerTemplate.getId());
+        return res;
+    }
+
+}

clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/util/Util.java

@@ -1,113 +0,0 @@
-package ru.spcex.clearing.imdg.util;
-
-import com.hazelcast.core.HazelcastInstance;
-import com.hazelcast.core.IMap;
-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 java.time.LocalDate;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-import static ru.spcex.clearing.imdg.IMDGDistributedNames.*;
-
-public class Util {
-
-    public static void makeSchedulerAllTodayMap(HazelcastInstance hazelcastInstance) {
-        IMap<Long, Planner> plannerMap = hazelcastInstance.getMap(Map_Planner);
-        IMap<Long, ClearingCalendar> clearingCalendarMap = hazelcastInstance.getMap(Map_ClearingCalendar);
-        IMap<Long, PlannerTemplate> plannerTemplateMap = hazelcastInstance.getMap(Map_PlannerTemplate);
-        IMap<Long, PlannerAllToday> plannerAllTodayMap = hazelcastInstance.getMap(Map_PlannerAllToday);
-        LocalDate currentDate = LocalDate.now();
-        List<PlannerAllToday> listOfPlannerAllToday = new ArrayList<>();
-
-
-        if (!plannerMap.isEmpty()) {
-            switch (currentDate.getDayOfWeek()) {
-                case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> listOfPlannerAllToday.addAll(getPlannersOnMonday2Friday(currentDate, clearingCalendarMap, plannerTemplateMap));
-                case SUNDAY, SATURDAY -> listOfPlannerAllToday.addAll(getPlannersOnSunday2Saturday(currentDate, clearingCalendarMap, plannerTemplateMap));
-            }
-        }
-
-        plannerMap.values().stream().filter((x) -> x.getClearingDate().isEqual(currentDate)).forEach((x) -> {
-            if (x.getTaskStatus().equalsIgnoreCase("ACTV")) {
-                listOfPlannerAllToday.add(createPlannerAllTodayFromPlanner(x));
-            }
-
-            if (x.getTaskStatus().equalsIgnoreCase("CNCL") || x.getTaskStatus().equalsIgnoreCase("BLKD")) {
-                listOfPlannerAllToday.removeIf((allToday) -> !x.getTaskTime().equals(allToday.getTaskTime()) ||
-                        !x.getTask().equalsIgnoreCase(allToday.getTask()));
-            }
-        });
-        for (PlannerAllToday plannerAllToday : listOfPlannerAllToday) {
-            plannerAllToday.setId(hazelcastInstance.getIdGenerator(MAP_SEQUENCE_NAME).newId());
-            plannerAllTodayMap.put(plannerAllToday.getId(), plannerAllToday);
-        }
-    }
-
-    private static List<PlannerAllToday> getPlannersOnMonday2Friday(LocalDate currentDate, IMap<Long, ClearingCalendar> clearingCalendarMap, IMap<Long, PlannerTemplate> plannerTemplateMap) {
-        List<PlannerAllToday> res = new ArrayList<>();
-        if (clearingCalendarMap == null || clearingCalendarMap.isEmpty()) {
-            for (PlannerTemplate plannerTemplate : plannerTemplateMap.values()) {
-                res.add(createPlannerAllTodayFromPlannerTemplate(plannerTemplate));
-            }
-        } else {
-            Optional<ClearingCalendar> clearingCalendarOptional = clearingCalendarMap.values().stream().filter((calendar) -> calendar.getClearingDate().isEqual(currentDate)).findFirst();
-            if (clearingCalendarOptional.isPresent()) {
-                ClearingCalendar calendar = clearingCalendarOptional.get();
-                if (calendar.getDayStatus().equalsIgnoreCase("BDAY")) {
-                    if (calendar.getCompanyId() != null && calendar.getCompanyId() != 0) {
-                        for (PlannerTemplate plannerTemplate :
-                                plannerTemplateMap.values()) {
-                            res.add(createPlannerAllTodayFromPlannerTemplate(plannerTemplate));
-                        }
-                    }
-                }
-            }
-        }
-
-        return res;
-    }
-
-    private static List<PlannerAllToday> getPlannersOnSunday2Saturday(LocalDate currentDate, IMap<Long, ClearingCalendar> clearingCalendarMap, IMap<Long, PlannerTemplate> plannerTemplateMap) {
-        List<PlannerAllToday> res = new ArrayList<>();
-        Optional<ClearingCalendar> clearingCalendarOptional = clearingCalendarMap.values().stream().filter((calendar) -> calendar.getClearingDate().isEqual(currentDate)).findFirst();
-        if (clearingCalendarOptional.isPresent()) {
-            ClearingCalendar clearingCalendar = clearingCalendarOptional.get();
-            if (clearingCalendar.getDayStatus().equalsIgnoreCase("BDAY")) {
-                for (PlannerTemplate plannerTemplate : plannerTemplateMap.values()) {
-                    res.add(createPlannerAllTodayFromPlannerTemplate(plannerTemplate));
-                }
-            }
-        }
-        return res;
-    }
-
-    private static PlannerAllToday createPlannerAllTodayFromPlanner(Planner planner) {
-        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(planner.getId());
-        return res;
-    }
-
-    private static PlannerAllToday createPlannerAllTodayFromPlannerTemplate(PlannerTemplate plannerTemplate) {
-        PlannerAllToday res = new PlannerAllToday();
-        res.setTask(plannerTemplate.getTask());
-        res.setTaskTime(plannerTemplate.getTaskTime());
-        res.setTaskStatus(plannerTemplate.getTaskStatus());
-        res.setParent("TMPL");
-        res.setParentId(plannerTemplate.getId());
-        return res;
-    }
-
-}

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/TaskManager.java

@@ -18,6 +18,7 @@ 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 ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;
 
 import java.time.*;
 import java.util.ArrayList;
@@ -72,6 +73,9 @@ public class TaskManager implements EntryAddedListener<Long, PlannerAllToday>,
     public void afterPropertiesSet() {
         this.launcherMap = imdgProvider.getImdg(Map_Launcher, Launcher.class);
         this.plannerAllTodayMap = imdgProvider.getImdg(Map_PlannerAllToday, PlannerAllToday.class);
+        if (plannerAllTodayMap instanceof ImdgHazelcast<PlannerAllToday> plannerAllTodayImdgHazelcast) {
+           plannerAllTodayImdgHazelcast.getMap().addEntryListener(this, true);
+        }
         scheduledJobs = new ConcurrentHashMap<>();
         updateScheduler();
     }

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/DayStatus.java

@@ -0,0 +1,18 @@
+package ru.spcex.platform.enumeration;
+
+import ru.spcex.platform.utils.enumeration.IEnumKey;
+
+public enum DayStatus implements IEnumKey {
+    Workday("BDAY"), DayOff("DOFF");
+
+    private final String key;
+
+    DayStatus(String key) {
+        this.key = key;
+    }
+
+    @Override
+    public String getKey() {
+        return key;
+    }
+}

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/Parent.java

@@ -0,0 +1,18 @@
+package ru.spcex.platform.enumeration;
+
+import ru.spcex.platform.utils.enumeration.IEnumKey;
+
+public enum Parent implements IEnumKey {
+    Template("TMPL"), Planner("PLNR"), Calendar("CLND");
+
+    private final String key;
+
+    Parent(String key) {
+        this.key = key;
+    }
+
+    @Override
+    public String getKey() {
+        return key;
+    }
+}