https://jira.fingo.info/browse/IJ-326 urlop wypocz. przysług. field is calculated wrongly (#210)

DaDudek · Dawid Dudek · web-flow · commit 72d45ba1de7d · 2023-02-23T13:11:31.000+01:00
* https://jira.fingo.info/browse/IJ-326 urlop wypocz. przysług. field is calculated wrongly * https://jira.fingo.info/browse/IJ-326 urlop wypocz. przysług. field is calculated wrongly * https://jira.fingo.info/browse/IJ-326 urlop wypocz. przysług. field is calculated wrongly * https://jira.fingo.info/browse/IJ-326 urlop wypocz. przysług. field is calculated wrongly --------- Co-authored-by: Dawid Dudek <dawid.dudek@fingo.pl>
diff --git a/src/main/java/info/fingo/urlopia/history/HistoryLogFilterCreator.java b/src/main/java/info/fingo/urlopia/history/HistoryLogFilterCreator.java
@@ -12,17 +12,53 @@ public class HistoryLogFilterCreator {
     private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern(UrlopiaApplication.DATE_TIME_FORMAT);
     private static final String CREATED_FIELD_FILTER = "created";
     private static final String USER_ID_FIELD_FILTER = "user.id";
-    private static final String EVENT_FILTER = "userDetailsChangeEvent";
+    private static final String EVENT_FIELD_FILTER = "userDetailsChangeEvent";
+    private static final String COUNT_NEXT_YEAR_FIELD_FILTER = "countForNextYear";
 
 
+    public static Filter filterBy(LocalDate date,
+                                  Long userId){
+        var formattedStartOfDay = getFormattedDayStart(date);
+        var formattedEndOfDay = getFormattedDayEnd(date);
+        return Filter.newBuilder()
+                .and(USER_ID_FIELD_FILTER, Operator.EQUAL, String.valueOf(userId))
+                .and(CREATED_FIELD_FILTER, Operator.GREATER_OR_EQUAL, formattedStartOfDay)
+                .and(CREATED_FIELD_FILTER, Operator.LESS_OR_EQUAL, formattedEndOfDay)
+                .build();
+    }
+
+    public static Filter filterBy(LocalDate startDate,
+                                  LocalDate endDate,
+                                  Long userId){
+        var formattedStartOfDay = getFormattedDayStart(startDate);
+        var formattedEndOfDay = getFormattedDayEnd(endDate);
+        return Filter.newBuilder()
+                .and(USER_ID_FIELD_FILTER, Operator.EQUAL, String.valueOf(userId))
+                .and(CREATED_FIELD_FILTER, Operator.GREATER_OR_EQUAL, formattedStartOfDay)
+                .and(CREATED_FIELD_FILTER, Operator.LESS_OR_EQUAL, formattedEndOfDay)
+                .build();
+    }
+
+    private static String getFormattedDayStart(LocalDate date){
+        var startOfDay = LocalDateTime.of(date, LocalTime.MIN);
+        var formatter = DateTimeFormatter.ofPattern(UrlopiaApplication.DATE_TIME_FORMAT);
+        return formatter.format(startOfDay);
+    }
+
+    private static String getFormattedDayEnd(LocalDate date){
+        var endOfDay = LocalDateTime.of(date, LocalTime.MAX);
+        var formatter = DateTimeFormatter.ofPattern(UrlopiaApplication.DATE_TIME_FORMAT);
+        return formatter.format(endOfDay);
+    }
+
     public static Filter filterBy(UserDetailsChangeEvent changeEvent,
                                   YearMonth minYearMonth){
         var firstDayOfMonth = minYearMonth.atDay(1);
         var startOfFirstDay = LocalDateTime.of(firstDayOfMonth, LocalTime.MIN);
 
         return Filter.newBuilder()
                 .and(CREATED_FIELD_FILTER, Operator.GREATER_OR_EQUAL, DATE_FORMATTER.format(startOfFirstDay))
-                .and(EVENT_FILTER, Operator.EQUAL, changeEvent.name())
+                .and(EVENT_FIELD_FILTER, Operator.EQUAL, changeEvent.name())
                 .build();
     }
 
@@ -39,7 +75,7 @@ public static Filter filterBy(UserDetailsChangeEvent changeEvent,
                 .and(USER_ID_FIELD_FILTER, Operator.EQUAL, String.valueOf(userId))
                 .and(CREATED_FIELD_FILTER, Operator.GREATER_OR_EQUAL, DATE_FORMATTER.format(startOfFirstDay))
                 .and(CREATED_FIELD_FILTER, Operator.LESS_OR_EQUAL, DATE_FORMATTER.format(endOfLastDay))
-                .and(EVENT_FILTER, Operator.EQUAL, changeEvent.name())
+                .and(EVENT_FIELD_FILTER, Operator.EQUAL, changeEvent.name())
                 .build();
     }
 
@@ -56,7 +92,24 @@ public static Filter filterBy(UserDetailsChangeEvent changeEvent,
                 .and(USER_ID_FIELD_FILTER, Operator.EQUAL, String.valueOf(userId))
                 .and(CREATED_FIELD_FILTER, Operator.GREATER_OR_EQUAL, DATE_FORMATTER.format(startOfFirstDay))
                 .and(CREATED_FIELD_FILTER, Operator.LESS_OR_EQUAL, DATE_FORMATTER.format(endOfLastDay))
-                .and(EVENT_FILTER, Operator.EQUAL, changeEvent.name())
+                .and(EVENT_FIELD_FILTER, Operator.EQUAL, changeEvent.name())
+                .build();
+    }
+
+    public static Filter filterBy(Integer year,
+                                  Long userId,
+                                  Boolean countForNextYear){
+        var firstDayOfYear = LocalDate.of(year, 1, 1);
+        var formattedFirstDayOfYear = getFormattedDayStart(firstDayOfYear);
+
+        var lastDayOfMonth = LocalDate.of(year,12,31);
+        var formattedLastDaysOfMonth = getFormattedDayEnd(lastDayOfMonth);
+
+        return Filter.newBuilder()
+                .and(USER_ID_FIELD_FILTER, Operator.EQUAL, String.valueOf(userId))
+                .and(CREATED_FIELD_FILTER, Operator.GREATER_OR_EQUAL, formattedFirstDayOfYear)
+                .and(CREATED_FIELD_FILTER, Operator.LESS_OR_EQUAL, formattedLastDaysOfMonth)
+                .and(COUNT_NEXT_YEAR_FIELD_FILTER, Operator.EQUAL, String.valueOf(countForNextYear))
                 .build();
     }
 }
diff --git a/src/main/java/info/fingo/urlopia/history/HistoryLogService.java b/src/main/java/info/fingo/urlopia/history/HistoryLogService.java
@@ -19,9 +19,9 @@
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
-import java.time.LocalTime;
 import java.time.YearMonth;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
@@ -51,19 +51,17 @@ public Page<HistoryLogExcerptProjection> get(Filter filter,
 
     public List<HistoryLogExcerptProjection> get(LocalDate date,
                                                  Long userId) {
-        var startOfDay = LocalDateTime.of(date, LocalTime.MIN);
-        var endOfDay = LocalDateTime.of(date, LocalTime.MAX);
-        var formatter = DateTimeFormatter.ofPattern(UrlopiaApplication.DATE_TIME_FORMAT);
-        var formattedStartOfDay = formatter.format(startOfDay);
-        var formattedEndOfDay = formatter.format(endOfDay);
-        var filter = Filter.newBuilder()
-                .and("user.id", Operator.EQUAL, String.valueOf(userId))
-                .and(CREATED_FILTER, Operator.GREATER_OR_EQUAL, formattedStartOfDay)
-                .and(CREATED_FILTER, Operator.LESS_OR_EQUAL, formattedEndOfDay)
-                .build();
+        var filter = HistoryLogFilterCreator.filterBy(date, userId);
         return historyLogRepository.findAll(filter, HistoryLogExcerptProjection.class);
     }
 
+    public List<HistoryLog> get(LocalDate startDate,
+                                LocalDate endDate,
+                                Long userId) {
+        var filter = HistoryLogFilterCreator.filterBy(startDate, endDate, userId);
+        return historyLogRepository.findAll(filter);
+    }
+
     public List<HistoryLogExcerptProjection> get(Long userId,
                                                  Integer year,
                                                  Filter filter) {
@@ -104,6 +102,13 @@ public Page<HistoryLogExcerptProjection> get(Long userId,
         return get(filterWithRestrictions, pageable);
     }
 
+    private List<HistoryLog> getCountForNextYearLogs(Integer year,
+                                                     Long userId,
+                                                     Boolean countForNextYear){
+        var filter = HistoryLogFilterCreator.filterBy(year, userId, countForNextYear);
+        return historyLogRepository.findAll(filter);
+    }
+
 
     public List<HistoryLog> getBy(YearMonth yearMonth,
                                 UserDetailsChangeEvent userDetailsChangeEvent){
@@ -227,6 +232,72 @@ public Float countRemainingHours(Long userId) {
         return historyLogRepository.sumHours(userId);
     }
 
+    public float countRemainingForCurrentYear(Long userId,
+                                              Integer year){
+        var currentYearLogs = getCountForNextYearLogs(year, userId, false);
+        var fromLastYear = getCountForNextYearLogs(year-1, userId, true);
+        var resultLogs = new ArrayList<HistoryLog>();
+        resultLogs.addAll(currentYearLogs);
+        resultLogs.addAll(fromLastYear);
+        var hours = 0f;
+        for (var log: resultLogs){
+            var request = log.getRequest();
+            if (request == null){
+                hours += log.getHours();
+            }
+        }
+        return hours + countRemainingFromPreviousYear(userId, year);
+    }
+
+    private float countRemainingFromPreviousYear(Long userId,
+                                                Integer year){
+        var hours = 0f;
+        var lastDayOfPrevYear = LocalDate.of(year-1, 12, 31);
+        var firstDay = LocalDate.of(0, 1,1);
+        var logs = get(firstDay, lastDayOfPrevYear, userId);
+        for (var log: logs){
+            var request = log.getRequest();
+            if (request == null){
+                hours += countForPrevYearFromLogWithoutRequest(log, year);
+            }
+            else if (request.isNormal()){
+                hours += countForPrevYearFromRequest(log, request, year-1);
+            }
+        }
+        return hours;
+    }
+
+    private float countForPrevYearFromRequest(HistoryLog historyLog,
+                                              Request request,
+                                              Integer year){
+        var lastDayOfYear = LocalDate.of(year, 12, 31);
+        if (request.getEndDate().isBefore(lastDayOfYear)){
+            return -1 * request.getWorkingHours();
+        }//we need to handle "next year requests"
+        else {
+            var firstMonthOfRequest = request.getStartDate().getMonthValue();
+            var hours = 0;
+            for (int month=firstMonthOfRequest; month<=12; month++){
+                hours += usedHoursFromMonthCalculator.countUsedHours(year, month, historyLog);
+            }
+            return -1 * hours;
+        }
+    }
+
+    private float countForPrevYearFromLogWithoutRequest(HistoryLog historyLog,
+                                                        Integer year){
+        var logYear = historyLog.getCreated().getYear();
+        var logIsFromPastYear = logYear < year;
+        var logIsFromNextYear = logYear > year;
+        if (logIsFromNextYear){
+            return 0;
+        }
+        if (!historyLog.getCountForNextYear() || logIsFromPastYear){
+            return historyLog.getHours();
+        }
+        return 0;
+    }
+
     public float countRemainingHoursForYear(Long userId,
                                             Integer year) {
         var hours = 0f;
diff --git a/src/main/java/info/fingo/urlopia/reports/evidence/params/resolver/EvidenceReportVacationLeaveParamsResolver.java b/src/main/java/info/fingo/urlopia/reports/evidence/params/resolver/EvidenceReportVacationLeaveParamsResolver.java
@@ -40,27 +40,8 @@ private String resolveLabel(){
     }
 
     private String resolveRemainingHoursAtYearStart() {
-        var fromPreviousYear = countRemainingFromPreviousYear(year, user.getId());
-        var fromCurrentYear  = countFromCurrentYear(year, user.getId());
-        var remainingHoursAtYearStart = fromPreviousYear + fromCurrentYear;
-        return formatResolvedHours(remainingHoursAtYearStart);
-    }
-
-    private float countFromCurrentYear(int year,
-                                       long userId){
-        return historyLogService
-                .getFromYear(userId, year).stream()
-                .filter(historyLog -> historyLog.getRequest() == null)
-                .filter(historyLog -> !historyLog.getCountForNextYear())
-                .map(HistoryLog::getHours)
-                .filter(hours -> hours > 0)
-                .reduce(Float::sum)
-                .orElse(0f);
-    }
-
-    private float countRemainingFromPreviousYear(int year,
-                                                 long userId){
-     return historyLogService.countRemainingHoursForYear(userId, year - 1);
+        var remainingHoursForYear = historyLogService.countRemainingForCurrentYear(user.getId(),year);
+        return formatResolvedHours(remainingHoursForYear);
     }
 
     private Map<String,String> resolveVacationLeaveUsedHours(){
diff --git a/src/test/groovy/info/fingo/urlopia/history/HistoryLogServiceSpec.groovy b/src/test/groovy/info/fingo/urlopia/history/HistoryLogServiceSpec.groovy
@@ -263,6 +263,96 @@ class HistoryLogServiceSpec extends Specification {
         1 * nextLog.setPrevHistoryLog(prevLog)
     }
 
+    def "countRemainingForCurrentYear WHEN only log without request should sum it"(){
+        given:
+        def log = Mock(HistoryLog){
+            getHours() >> 100
+        }
+        def log2 = Mock(HistoryLog) {
+            getHours() >> -20
+        }
+        historyLogRepository.findAll(_ as Filter) >>> [[log, log2], [], []]
+        usedHoursFromMonthCalculator.countUsedHours(_ as Integer, _ as Integer, _ as HistoryLog) >> -20
+
+        when:
+        def result = historyLogService.countRemainingForCurrentYear(1,1)
+
+        then:
+        result == 80
+    }
+
+    def "countRemainingForCurrentYear WHEN log with request SHOULD not be added"(){
+        given:
+        def log = Mock(HistoryLog){
+            getHours() >> 100
+        }
+        def log2 = Mock(HistoryLog) {
+            getHours() >> -20
+            getRequest() >> Mock(Request)
+        }
+        historyLogRepository.findAll(_ as Filter) >>> [[log, log2], [], []]
+
+        when:
+        def result = historyLogService.countRemainingForCurrentYear(1,1)
+
+        then:
+        result == 100
+    }
+
+    def "countRemainingForCurrentYear WHEN log without request from prev year but countedOnNext SHOULD be added"(){
+        given:
+        def log = Mock(HistoryLog){
+            getHours() >> 100
+        }
+        def log2 = Mock(HistoryLog) {
+            getHours() >> -20
+        }
+        historyLogRepository.findAll(_ as Filter) >>> [[log], [log2], []]
+
+        when:
+        def result = historyLogService.countRemainingForCurrentYear(1,1)
+
+        then:
+        result == 80
+    }
+
+
+    def "countRemainingForCurrentYear WHEN remaining from prev year SHOULD be added"(){
+        given:
+        def log = Mock(HistoryLog){
+            getHours() >> 100
+        }
+        def log2 = Mock(HistoryLog) {
+            getHours() >> -20
+            getRequest() >> Mock(Request) {
+                isNormal() >> true
+                getEndDate() >> LocalDate.MAX
+                getStartDate() >> LocalDate.of(2022,12,1)
+            }
+        }
+        historyLogRepository.findAll(_ as Filter) >>> [[log], [], [log2]]
+        usedHoursFromMonthCalculator.countUsedHours(_ as Integer, _ as Integer, _ as HistoryLog) >> 20
+
+        when:
+        def result = historyLogService.countRemainingForCurrentYear(1,1)
+
+        then:
+        result == 80
+    }
+
+
+
+    def "countRemainingForCurrentYear WHEN no logs SHOULD return 0"(){
+        given:
+        historyLogRepository.findAll(_ as Filter) >> []
+
+        when:
+        def result = historyLogService.countRemainingForCurrentYear(1,1)
+
+        then:
+        result == 0
+    }
+
     def "delete WHEN event is missing SHOULD throw exception"(){
         given:
         def nextLog = Mock(HistoryLog)
diff --git a/src/test/groovy/info/fingo/urlopia/reports/evidence/params/resolver/EvidenceReportVacationLeaveParamsResolverSpec.groovy b/src/test/groovy/info/fingo/urlopia/reports/evidence/params/resolver/EvidenceReportVacationLeaveParamsResolverSpec.groovy
