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

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

Browse source 
Привел в соответствие с ТЗ PlannerAllTodayMaker и добавил тесты к нему.
This commit is contained in:
psemenkov 2023-04-20 11:41:48 +03:00
parent 24dccbf4b7
commit 02c5b2a176
5 changed files with 153 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
clearing-parent/imdg/pom.xml
View file

@ -75,6 +75,16 @@
<groupId>ru.spcex.platform</groupId>
<artifactId>platform-enum</artifactId>
</dependency>
<dependency>
<groupId>ru.spcex.clearing</groupId>
<artifactId>cleaning-builders</artifactId>
<version>SPCEX-1.0.0.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>ru.spcex.clearing</groupId>
<artifactId>clearing-validation</artifactId>
</dependency>
<!-- TEST -->
<dependency>

2
clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/config/HazelcastConfiguration.java
View file

@ -24,7 +24,7 @@ public class HazelcastConfiguration {
this.hzSettings = imdgSettings.getHazelcast();
}
@Bean
@Bean("hazelcastInstanceImdg")
public HazelcastInstance hazelcastServerInstance(Config config) {
return Hazelcast.newHazelcastInstance(config);
}

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

@ -8,18 +8,15 @@ 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.clearing.scheduler.PlannerAllTodayBuilder;
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 java.util.*;
import static ru.spcex.clearing.imdg.IMDGDistributedNames.*;
import static ru.spcex.clearing.scheduler.ISchedulerChecker.*;
@Service
public class PlannerAllTodayMaker {
@ -37,7 +34,7 @@ public class PlannerAllTodayMaker {
plannerTemplateMap = hazelcastInstance.getMap(Map_PlannerTemplate);
plannerAllTodayMap = hazelcastInstance.getMap(Map_PlannerAllToday);
}
public void makeSchedulerAllTodayMap() {
LocalDate currentDate = LocalDate.now();
List<PlannerAllToday> listOfPlannerAllToday = new ArrayList<>();
@ -45,17 +42,15 @@ public class PlannerAllTodayMaker {
if (!plannerMap.isEmpty()) listOfPlannerAllToday.addAll(getPlannersAllTodayToDate(currentDate));
plannerMap.values().stream()
.filter(x -> x.getTaskStatus() != null)
.filter((x) -> x.getClearingDate() == null || x.getClearingDate().isEqual(currentDate)).forEach((x) -> {
if (x.getTaskStatus().equalsIgnoreCase(Status.Active.getKey())) {
listOfPlannerAllToday.add(createPlannerAllTodayFromPlanner(x));
}
.filter(x -> isValidPlanner(x, currentDate)).forEach((planner) -> {
if (planner.getTaskStatus().equalsIgnoreCase(Status.Active.getKey())) {
listOfPlannerAllToday.add(PlannerAllTodayBuilder.builder().append(planner).build());
}
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()));
}
});
if (planner.getTaskStatus().equalsIgnoreCase(Status.Cancel.getKey()) || planner.getTaskStatus().equalsIgnoreCase(Status.Blocked.getKey())) {
listOfPlannerAllToday.removeIf((allToday) -> needRemoveByPlanner(planner, allToday));
}
});
for (PlannerAllToday plannerAllToday : listOfPlannerAllToday) {
plannerAllToday.setId(hazelcastInstance.getIdGenerator(MAP_SEQUENCE_NAME).newId());
plannerAllTodayMap.put(plannerAllToday.getId(), plannerAllToday);
@ -63,55 +58,29 @@ public class PlannerAllTodayMaker {
}
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));
}
if (needAddFromPlannerTemplate(currentDate, clearingCalendarMap.values())){
for (PlannerTemplate plannerTemplate : plannerTemplateMap.values()) {
res.add(PlannerAllTodayBuilder.builder().append(plannerTemplate).build());
}
}
return res;
}
public boolean needAddFromPlannerTemplate(LocalDate currentDate, Collection<ClearingCalendar> clearingCalendar){
boolean isWeekend = Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(currentDate.getDayOfWeek());
if (clearingCalendar == null || clearingCalendar.isEmpty()) {
return !isWeekend;
} else {
Optional<ClearingCalendar> clearingCalendarOptional = clearingCalendarMap.values().stream()
.filter((calendar) -> calendar.getClearingDate().isEqual(currentDate))
Optional<ClearingCalendar> clearingCalendarOptional = clearingCalendar.stream()
.filter((calendar) -> calendar.getClearingDate() != null && 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 isValidWorkday(calendar, isWeekend);
} else return !isWeekend;
}
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;
}
}

2
clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/config/TestConfiguration.java
View file

@ -6,6 +6,7 @@ import com.hazelcast.core.HazelcastInstance;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@ -16,6 +17,7 @@ import org.springframework.context.annotation.Import;
public class TestConfiguration {
private final Logger log = LoggerFactory.getLogger(this.getClass());
@Autowired
@Qualifier("hazelcastInstanceImdg")
private HazelcastInstance hazelcastInstance;
@Autowired

111
clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/services/PlannerAllTodayMakerTest.java Normal file
View file

@ -0,0 +1,111 @@
package ru.spcex.clearing.imdg.services;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
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.spcex.clearing.imdg.config.TestConfiguration;
import ru.spcex.platform.enumeration.DayStatus;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Collections;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static ru.spcex.clearing.scheduler.ISchedulerChecker.*;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
TestConfiguration.class
})
class PlannerAllTodayMakerTest {
@Autowired
TestConfiguration testConfig;
private final LocalDate weekendDate = LocalDate.of(2023, 4, 16);
private final LocalDate workDate = LocalDate.of(2023, 4, 14);
@BeforeAll
static void setProperty() {
Path path = Paths.get("src", "main", "resources");
String currentPath = path.toAbsolutePath().toString();
System.setProperty("spring.config.location", currentPath);
}
@Test
void needAddFromPlannerTemplate() {
PlannerAllTodayMaker plannerAllTodayMaker = new PlannerAllTodayMaker(testConfig.getHazelcastInstance());
assertFalse(plannerAllTodayMaker.needAddFromPlannerTemplate(weekendDate, null));
assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(workDate, null));
ClearingCalendar clearingCalendar = new ClearingCalendar();
assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(workDate, Collections.singleton(clearingCalendar)));
clearingCalendar.setClearingDate(workDate);
clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(workDate, Collections.singleton(clearingCalendar)));
clearingCalendar.setClearingDate(weekendDate);
clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
assertFalse(plannerAllTodayMaker.needAddFromPlannerTemplate(weekendDate, Collections.singleton(clearingCalendar)));
clearingCalendar.setCompanyId(11L);
assertTrue(plannerAllTodayMaker.needAddFromPlannerTemplate(weekendDate, Collections.singleton(clearingCalendar)));
}
@Test
void isValidWorkdayTest() {
ClearingCalendar clearingCalendar = new ClearingCalendar();
assertFalse(isValidWorkday(clearingCalendar, true));
clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
assertFalse(isValidWorkday(clearingCalendar, true));
clearingCalendar.setDayStatus(DayStatus.DayOff.getKey());
assertFalse(isValidWorkday(clearingCalendar, true));
assertFalse(isValidWorkday(clearingCalendar, false));
clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
assertTrue(isValidWorkday(clearingCalendar, false));
assertFalse(isValidWorkday(clearingCalendar, true));
clearingCalendar.setCompanyId(1L);
assertTrue(isValidWorkday(clearingCalendar, true));
}
@Test
void needRemoveByPlannerTest() {
PlannerAllToday plannerAllToday = new PlannerAllToday();
Planner planner = new Planner();
LocalTime localTime = LocalTime.now();
assertFalse(needRemoveByPlanner(planner, plannerAllToday));
planner.setTaskTime(localTime);
assertFalse(needRemoveByPlanner(planner, plannerAllToday));
plannerAllToday.setTaskTime(localTime);
assertFalse(needRemoveByPlanner(planner, plannerAllToday));
planner.setCompanyId(1L);
assertFalse(needRemoveByPlanner(planner, plannerAllToday));
plannerAllToday.setCompanyId(1L);
assertFalse(needRemoveByPlanner(planner, plannerAllToday));
planner.setSecurityId(1L);
assertFalse(needRemoveByPlanner(planner, plannerAllToday));
plannerAllToday.setSecurityId(1L);
assertFalse(needRemoveByPlanner(planner, plannerAllToday));
plannerAllToday.setTask("1L");
assertFalse(needRemoveByPlanner(planner, plannerAllToday));
planner.setTask("1L");
assertTrue(needRemoveByPlanner(planner, plannerAllToday));
}
@Test
void isValidPlannerTest() {
Planner planner = new Planner();
assertFalse(isValidPlanner(planner, weekendDate));
planner.setTaskStatus("ACTV");
assertTrue(isValidPlanner(planner, weekendDate));
planner.setClearingDate(workDate);
assertFalse(isValidPlanner(planner, weekendDate));
planner.setClearingDate(weekendDate);
assertTrue(isValidPlanner(planner, weekendDate));
}
}