From f33e8f8cf83f1fd59d5f32940b18d2413241e63a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=93scar=20Gonz=C3=A1lez=20Fern=C3=A1ndez?=
 <ogonzalez@igalia.com>
Date: Mon, 3 Jan 2011 13:33:39 +0100
Subject: [PATCH] [Bug #775] Fix bug

The minusDuration contained an error that caused to reach the end of
the loop before it should.

When calculating the current duration, the workable days given were
the rounded up version which caused the problem in the third snapshot.

FEA: ItEr67S04BugFixing
---
 .../business/planner/entities/Task.java       | 57 ++++++++++++-------
 1 file changed, 37 insertions(+), 20 deletions(-)

diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/Task.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/Task.java
index 4161a81af..2ef67dfea 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/Task.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/Task.java
@@ -537,13 +537,42 @@ public class Task extends TaskElement implements ITaskPositionConstrained {
 
     private DurationBetweenDates getDurationBetweenDates() {
         if (workableDays != null) {
-            return new DurationBetweenDates(workableDays);
+            return fromFixedDuration(workableDays);
         } else {
-            Integer calculatedWorkableDays = getWorkableDaysUntil(getEndAsLocalDate());
-            return new DurationBetweenDates(calculatedWorkableDays);
+            return fromCurrentDuration();
         }
     }
 
+    private DurationBetweenDates fromFixedDuration(int fixedNumberOfWorkableDays) {
+        return new DurationBetweenDates(fixedNumberOfWorkableDays,
+                EffortDuration.zero());
+    }
+
+    private DurationBetweenDates fromCurrentDuration() {
+        IntraDayDate start = getIntraDayStartDate();
+        IntraDayDate end = getIntraDayEndDate();
+        int calculatedWorkableDays = getWorkableDaysFrom(start.roundUp(),
+                end.roundDown());
+        EffortDuration extraDuration = getExtraDurationAtStart(start).plus(
+                end.getEffortDuration());
+        return new DurationBetweenDates(calculatedWorkableDays, extraDuration);
+    }
+
+    private EffortDuration getExtraDurationAtStart(IntraDayDate start) {
+        if (start.getEffortDuration().isZero()) {
+            return EffortDuration.zero();
+        }
+        ICalendar calendar = getNullSafeCalendar();
+        EffortDuration capacity = calendar.getCapacityOn(PartialDay
+                .wholeDay(start.getDate()));
+        return capacity.minus(min(start.getEffortDuration(), capacity));
+    }
+
+    private ICalendar getNullSafeCalendar() {
+        return getCalendar() != null ? getCalendar() : SameWorkHoursEveryDay
+                .getDefaultWorkingDay();
+    }
+
     private class DurationBetweenDates {
 
         private final int numberOfWorkableDays;
@@ -552,24 +581,12 @@ public class Task extends TaskElement implements ITaskPositionConstrained {
 
         private final ICalendar calendar;
 
-        public DurationBetweenDates(int numberOfWorkableDays) {
-            this.calendar = getCalendar() != null ? getCalendar()
-                    : SameWorkHoursEveryDay.getDefaultWorkingDay();
+        private DurationBetweenDates(int numberOfWorkableDays,
+                EffortDuration remainderDuration) {
             this.numberOfWorkableDays = numberOfWorkableDays;
+            this.remainderDuration = remainderDuration;
+            this.calendar = getNullSafeCalendar();
 
-            IntraDayDate start = getIntraDayStartDate();
-            IntraDayDate end = getIntraDayEndDate();
-
-            if (start.getEffortDuration().compareTo(end.getEffortDuration()) <= 0) {
-                this.remainderDuration = end.getEffortDuration().minus(
-                        start.getEffortDuration());
-            } else {
-                EffortDuration capacity = calendar.getCapacityOn(PartialDay
-                        .wholeDay(start.getDate()));
-                this.remainderDuration = end.getEffortDuration()
-                        .plus(capacity.minus(min(start.getEffortDuration(),
-                                capacity)));
-            }
         }
 
         public IntraDayDate fromStartToEnd(IntraDayDate newStartDate) {
@@ -615,9 +632,9 @@ public class Task extends TaskElement implements ITaskPositionConstrained {
                 resultDay = resultDay.minusDays(1);
                 EffortDuration capacity = calendar.getCapacityOn(PartialDay
                         .wholeDay(resultDay));
-                decrement = decrement.minus(min(capacity, decrement));
                 result = IntraDayDate.create(resultDay,
                         capacity.minus(min(capacity, decrement)));
+                decrement = decrement.minus(min(capacity, decrement));
             }
             return result;
         }