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

clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/scheduler/ISchedulerChecker.java

@@ -23,7 +23,7 @@ public class ISchedulerChecker {
     /**
      * @param isWeekend тек.день=СБ-ВС<br>
      */
-    public static boolean isValidWorkday(ClearingCalendar clearingCalendar, boolean isWeekend) {
+    public static boolean isWorkDayByTradingCalendar(ClearingCalendar clearingCalendar, boolean isWeekend) {
         if (clearingCalendar.getDayStatus() != null && clearingCalendar.getDayStatus().equalsIgnoreCase(DayStatus.Workday.getKey())) {
             if (isWeekend) {
                 return clearingCalendar.getCompanyId() != null && clearingCalendar.getCompanyId() != 0;
@@ -31,4 +31,9 @@ public class ISchedulerChecker {
         }
         return false;
     }
+
+    public static boolean isWorkDayByTradingCalendar(ClearingCalendar clearingCalendar) {
+        return clearingCalendar.getDayStatus() != null &&
+                clearingCalendar.getDayStatus().equalsIgnoreCase(DayStatus.Workday.getKey());
+    }
 }

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

@@ -2,8 +2,6 @@ package ru.spcex.clearing.imdg.services;
 
 import com.hazelcast.core.HazelcastInstance;
 import com.hazelcast.core.IMap;
-import com.hazelcast.query.Predicate;
-import com.hazelcast.query.Predicates;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -13,15 +11,21 @@ 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.scheduler.ISchedulerChecker;
 import ru.spcex.clearing.scheduler.PlannerAllTodayBuilder;
 import ru.spcex.platform.enumeration.Status;
 
 import java.time.DayOfWeek;
 import java.time.LocalDate;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
 
 import static ru.spcex.clearing.imdg.IMDGDistributedNames.*;
-import static ru.spcex.clearing.scheduler.ISchedulerChecker.*;
+import static ru.spcex.clearing.scheduler.ISchedulerChecker.isValidPlanner;
+import static ru.spcex.clearing.scheduler.ISchedulerChecker.needRemoveByPlanner;
 
 @Service
 public class PlannerAllTodayMaker {
@@ -66,46 +70,25 @@ public class PlannerAllTodayMaker {
         log.info("Created {} plannerAllTodays", plannerAllTodayMap.size());
     }
 
-    private PlannerAllToday getFirstObjectByFieldValues(Map<String, ? extends Comparable<?>> conditions) {
-        Predicate<Long, ?>[] predicates = new Predicate[conditions.size()];
-        final int[] i = {0};
-        conditions.forEach((key, value) -> {
-            predicates[i[0]] = Predicates.equal(key, value);
-            i[0]++;
-        });
-        Predicate<Long, PlannerAllToday> and = Predicates.and(predicates);
-        Set<Map.Entry<Long, PlannerAllToday>> found = plannerAllTodayMap.entrySet(and);
-        Iterator<Map.Entry<Long, PlannerAllToday>> allFoundByCondition = found.iterator();
-        if (allFoundByCondition.hasNext()) {
-            return allFoundByCondition.next().getValue();
-        } else {
-            return null;
-        }
-    }
-
     private List<PlannerAllToday> getPlannersAllTodayToDate(LocalDate currentDate) {
         List<PlannerAllToday> res = new ArrayList<>();
+        Optional<ClearingCalendar> clearingCalendarOnDate = clearingCalendarMap.values().stream()
+                .filter((calendar) -> calendar.getClearingDate() != null && calendar.getClearingDate().isEqual(currentDate))
+                .findFirst();
 
-        if (needAddFromPlannerTemplate(currentDate, clearingCalendarMap.values())) {
+        if (needAddFromPlannerTemplate(currentDate, clearingCalendarOnDate)) {
-            plannerTemplateMap.values().stream().filter(plannerTemplate -> Status.Active.equalsByKey(plannerTemplate.getTaskStatus()))
+            AtomicReference<Long> companyId = new AtomicReference<>();
+            clearingCalendarOnDate.ifPresent(clearingCalendar -> companyId.set(clearingCalendar.getCompanyId()));
+            plannerTemplateMap.values().stream().filter(
+                            plannerTemplate -> Status.Active.equalsByKey(plannerTemplate.getTaskStatus()) &&
+                                    (companyId.get() == null || companyId.get().equals(plannerTemplate.getCompanyId())))
                     .forEach(plannerTemplate -> res.add(PlannerAllTodayBuilder.builder().append(plannerTemplate).build()));
         }
         return res;
     }
 
-    public boolean needAddFromPlannerTemplate(LocalDate currentDate, Collection<ClearingCalendar> clearingCalendar) {
+    public boolean needAddFromPlannerTemplate(LocalDate currentDate, Optional<ClearingCalendar> clearingCalendar) {
-        boolean isWeekend = Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(currentDate.getDayOfWeek());
+        boolean isWorkDay = !Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(currentDate.getDayOfWeek());
-
+        return clearingCalendar.map(ISchedulerChecker::isWorkDayByTradingCalendar).orElse(isWorkDay);
-        if (clearingCalendar == null || clearingCalendar.isEmpty()) {
-            return !isWeekend;
-        } else {
-            Optional<ClearingCalendar> clearingCalendarOptional = clearingCalendar.stream()
-                    .filter((calendar) -> calendar.getClearingDate() != null && calendar.getClearingDate().isEqual(currentDate))
-                    .findFirst();
-            if (clearingCalendarOptional.isPresent()) {
-                ClearingCalendar calendar = clearingCalendarOptional.get();
-                return isValidWorkday(calendar, isWeekend);
-            } else return !isWeekend;
-        }
     }
 }

clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/services/PlannerAllTodayMakerTest.java

@@ -18,7 +18,7 @@ import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.time.LocalDate;
 import java.time.LocalTime;
-import java.util.Collections;
+import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -54,31 +54,31 @@ class PlannerAllTodayMakerTest {
         assertFalse(plannerAllTodayMaker.needAddFromPlannerTemplate(weekendDate, null));
         assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(workDate, null));
         ClearingCalendar clearingCalendar = new ClearingCalendar();
-        assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(workDate, Collections.singleton(clearingCalendar)));
+        assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(workDate, Optional.of(clearingCalendar)));
         clearingCalendar.setClearingDate(workDate);
         clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
-        assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(workDate, Collections.singleton(clearingCalendar)));
+        assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(workDate, Optional.of(clearingCalendar)));
         clearingCalendar.setClearingDate(weekendDate);
         clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
-        assertFalse(plannerAllTodayMaker.needAddFromPlannerTemplate(weekendDate, Collections.singleton(clearingCalendar)));
+        assertFalse(plannerAllTodayMaker.needAddFromPlannerTemplate(weekendDate, Optional.of(clearingCalendar)));
         clearingCalendar.setCompanyId(11L);
-        assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(weekendDate, Collections.singleton(clearingCalendar)));
+        assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(weekendDate, Optional.of(clearingCalendar)));
     }
 
     @Test
     void isValidWorkdayTest() {
         ClearingCalendar clearingCalendar = new ClearingCalendar();
-        assertFalse(isValidWorkday(clearingCalendar, true));
+        assertFalse(isWorkDayByTradingCalendar(clearingCalendar, true));
         clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
-        assertFalse(isValidWorkday(clearingCalendar, true));
+        assertFalse(isWorkDayByTradingCalendar(clearingCalendar, true));
         clearingCalendar.setDayStatus(DayStatus.DayOff.getKey());
-        assertFalse(isValidWorkday(clearingCalendar, true));
+        assertFalse(isWorkDayByTradingCalendar(clearingCalendar, true));
-        assertFalse(isValidWorkday(clearingCalendar, false));
+        assertFalse(isWorkDayByTradingCalendar(clearingCalendar, false));
         clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
-        assertTrue(isValidWorkday(clearingCalendar, false));
+        assertTrue(isWorkDayByTradingCalendar(clearingCalendar, false));
-        assertFalse(isValidWorkday(clearingCalendar, true));
+        assertFalse(isWorkDayByTradingCalendar(clearingCalendar, true));
         clearingCalendar.setCompanyId(1L);
-        assertTrue(isValidWorkday(clearingCalendar, true));
+        assertTrue(isWorkDayByTradingCalendar(clearingCalendar, true));
     }
 
     @Test

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

@@ -36,7 +36,7 @@ import java.util.Collection;
 import java.util.Map;
 import java.util.function.Function;
 
-import static ru.spcex.clearing.scheduler.ISchedulerChecker.isValidWorkday;
+import static ru.spcex.clearing.scheduler.ISchedulerChecker.isWorkDayByTradingCalendar;
 import static ru.spcex.clearing.scheduler.config.PlannerQueueConfig.addToPlannerQueue;
 
 @Service
@@ -150,7 +150,7 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
         if (clearingCalendar.getClearingDate() == null || !clearingCalendar.getClearingDate().equals(currentDate))
             return;
         boolean isWeekend = Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(currentDate.getDayOfWeek());
-        if (isValidWorkday(clearingCalendar, isWeekend)) {
+        if (isWorkDayByTradingCalendar(clearingCalendar, isWeekend)) {
             for (PlannerTemplate plannerTemplate : plannerTemplateMap.getAllValues()) {
                 PlannerAllToday plannerAllToday = plannerAllTodayMap.getFirstObjectBySQL(String.format("parentId = %s", plannerTemplate.getId()));
                 if (plannerAllToday == null) {
@@ -172,7 +172,7 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
             for (ClearingCalendar calendar : clearingCalendars) {
                 //если будет хоть один валидные ClearingCalendar на сегодня на основании которого(и plannerTemplate -ов) могли быть созданы PlannerAllToday
                 //ничего проверять\удалять дальше не будем
-                if (isValidWorkday(calendar, isWeekend)) return;
+                if (isWorkDayByTradingCalendar(calendar, isWeekend)) return;
             }
         }
         //удалим все PlannerAllToday созданные на основании plannerTemplate кроме созданных на основании planner

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

@@ -35,7 +35,7 @@ import java.util.Collection;
 import java.util.Map;
 import java.util.function.Function;
 
-import static ru.spcex.clearing.scheduler.ISchedulerChecker.isValidWorkday;
+import static ru.spcex.clearing.scheduler.ISchedulerChecker.isWorkDayByTradingCalendar;
 import static ru.spcex.clearing.scheduler.config.PlannerQueueConfig.addToPlannerQueue;
 
 @Service
@@ -183,7 +183,7 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
         Collection<ClearingCalendar> clearingCalendars = clearingCalendarMap.getCollectionObjectsByFieldValues(Map.of("clearingDate", currentDate));
         if (clearingCalendars != null && !clearingCalendars.isEmpty()) {
             for (ClearingCalendar calendar : clearingCalendars) {
-                if (isValidWorkday(calendar, isWeekend)) return true;
+                if (isWorkDayByTradingCalendar(calendar, isWeekend)) return true;
             }
         } else return !isWeekend;
         return false;