diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/common/ProportionalDistributor.java b/navalplanner-business/src/main/java/org/navalplanner/business/common/ProportionalDistributor.java
index 4c0937226..4b3cd776a 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/common/ProportionalDistributor.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/common/ProportionalDistributor.java
@@ -36,7 +36,7 @@ public class ProportionalDistributor {
                 sumIntegerParts(initialShares), initialShares));
     }
 
-    private static int sumIntegerParts(int[] numbers) {
+    public static int sumIntegerParts(int[] numbers) {
         int sum = 0;
         for (Number each : numbers) {
             sum += each.intValue();
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
index f4503195b..4ec870d9d 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
@@ -1153,6 +1153,15 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
                     this.end.asExclusiveEnd());
         }
 
+        public List<DayAssignment> getNoConsolidatedAssignmentsOnInterval() {
+            return getNonConsolidatedAssignments(this.start.getDate(),
+                    this.end.asExclusiveEnd());
+        }
+
+        public List<DayAssignment> getConsolidatedAssignmentsOnInterval() {
+            return getConsolidatedAssignments(this.start.getDate(), this.end
+                    .asExclusiveEnd());
+        }
     }
 
     class AllocationIntervalInsideTask extends AllocationInterval {
@@ -1201,13 +1210,22 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
 
     private void updateAssignments(AllocationInterval interval,
             List<T> assignmentsCreated) {
+
         removingAssignments(withoutConsolidated(interval
                 .getAssignmentsOnInterval()));
         addingAssignments(assignmentsCreated);
+
+        updateConsolidatedAssignments(interval);
         updateOriginalTotalAssigment();
         updateResourcesPerDay();
     }
 
+    private void updateConsolidatedAssignments(AllocationInterval interval) {
+        for (DayAssignment day : interval.getAssignmentsOnInterval()) {
+            day.setConsolidated(false);
+        }
+    }
+
     private void resetAssigmentsFittingAllocationDatesToResultingAssignments(
             AllocationInterval interval, List<T> assignmentsCreated) {
         updateAssignments(interval, assignmentsCreated);
@@ -1938,6 +1956,18 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
                 getAssignments(), start, endExclusive));
     }
 
+    public List<DayAssignment> getNonConsolidatedAssignments(LocalDate start,
+            LocalDate endExclusive) {
+        return new ArrayList<DayAssignment>(DayAssignment.getAtInterval(
+                getNonConsolidatedAssignments(), start, endExclusive));
+    }
+
+    public List<DayAssignment> getConsolidatedAssignments(LocalDate start,
+            LocalDate endExclusive) {
+        return new ArrayList<DayAssignment>(DayAssignment.getAtInterval(
+                getConsolidatedAssignments(), start, endExclusive));
+    }
+
     public int getAssignedHours(LocalDate start, LocalDate endExclusive) {
         return getAssignedDuration(start, endExclusive).roundToHours();
     }
@@ -2094,4 +2124,12 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
                 : null;
     }
 
-}
\ No newline at end of file
+    public void setConsolidatedfromInitTo(LocalDate lastConsolidationDate) {
+        for (DayAssignment day : (List<DayAssignment>) getAssignments()) {
+            if (day.getDay().compareTo(lastConsolidationDate) <= 0) {
+                day.setConsolidated(true);
+            }
+        }
+    }
+
+}
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
index 97f8e65bb..477cc1ab2 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
@@ -313,12 +313,25 @@ public class SpecificResourceAllocation extends
             LocalDate endExclusive, int newHoursForInterval) {
         AllocationIntervalInsideTask interval = new AllocationIntervalInsideTask(
                 start, endExclusive);
+
         List<DayAssignment> assignments = interval.getAssignmentsOnInterval();
+
+        List<DayAssignment> nonConsolidatedAssignments = interval
+                .getNoConsolidatedAssignmentsOnInterval();
+        List<DayAssignment> consolidatedAssignments = interval
+                .getConsolidatedAssignmentsOnInterval();
+
+        int sumHoursConsolidated = ProportionalDistributor
+                .sumIntegerParts(asHours(consolidatedAssignments));
+        int pendingToReassign = newHoursForInterval - sumHoursConsolidated;
+
         ProportionalDistributor distributor = ProportionalDistributor
-                .create(asHours(assignments));
-        int[] newHoursPerDay = distributor.distribute(newHoursForInterval);
-        resetAssigmentsForInterval(interval,
-                assignmentsForNewHours(assignments, newHoursPerDay));
+                .create(asHours(nonConsolidatedAssignments));
+
+        int[] newHoursPerDay = distributor.distribute(pendingToReassign);
+
+        resetAssigmentsForInterval(interval, assignmentsForNewHours(
+                nonConsolidatedAssignments, newHoursPerDay));
     }
 
     private List<SpecificDayAssignment> assignmentsForNewHours(
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/AdvanceConsolidationModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/AdvanceConsolidationModel.java
index 5511d57bc..afab4916b 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/AdvanceConsolidationModel.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/AdvanceConsolidationModel.java
@@ -41,11 +41,11 @@ import org.navalplanner.business.orders.entities.OrderElement;
 import org.navalplanner.business.planner.daos.ITaskElementDAO;
 import org.navalplanner.business.planner.entities.DayAssignment;
 import org.navalplanner.business.planner.entities.ResourceAllocation;
-import org.navalplanner.business.planner.entities.ResourceAllocation.AllocationsSpecified;
-import org.navalplanner.business.planner.entities.ResourceAllocation.DetachDayAssignmentOnRemoval;
 import org.navalplanner.business.planner.entities.SpecificResourceAllocation;
 import org.navalplanner.business.planner.entities.Task;
 import org.navalplanner.business.planner.entities.TaskElement;
+import org.navalplanner.business.planner.entities.ResourceAllocation.AllocationsSpecified;
+import org.navalplanner.business.planner.entities.ResourceAllocation.DetachDayAssignmentOnRemoval;
 import org.navalplanner.business.planner.entities.consolidations.CalculatedConsolidatedValue;
 import org.navalplanner.business.planner.entities.consolidations.CalculatedConsolidation;
 import org.navalplanner.business.planner.entities.consolidations.ConsolidatedValue;
@@ -200,6 +200,9 @@ public class AdvanceConsolidationModel implements IAdvanceConsolidationModel {
 
     private void addConsolidatedValue(ConsolidatedValue value) {
         if (consolidation != null && task != null) {
+            if (consolidation.getConsolidatedValues().contains(value)) {
+                return;
+            }
             if (!consolidation.isCalculated()) {
                 ((NonCalculatedConsolidation) consolidation)
                         .addConsolidatedValue((NonCalculatedConsolidatedValue) value);
@@ -322,12 +325,6 @@ public class AdvanceConsolidationModel implements IAdvanceConsolidationModel {
 
                 LocalDate firstDayNotConsolidated = task
                         .getFirstDayNotConsolidated().getDate();
-                for (DayAssignment dayAssignment : task.getDayAssignments()) {
-                    if (dayAssignment.getDay().compareTo(
-                            firstDayNotConsolidated) >= 0) {
-                        dayAssignment.setConsolidated(false);
-                    }
-                }
 
                 Set<ResourceAllocation<?>> allResourceAllocations = task
                         .getAllResourceAllocations();
@@ -339,10 +336,14 @@ public class AdvanceConsolidationModel implements IAdvanceConsolidationModel {
                     if (!consolidation.getConsolidatedValues().isEmpty()) {
                         BigDecimal lastConslidation = task.getConsolidation()
                                 .getConsolidatedValues().last().getValue();
-                        pendingHours = BigDecimal.ONE.subtract(
-                                lastConslidation.divide(new BigDecimal(100),
-                                        RoundingMode.DOWN)).multiply(
-                                new BigDecimal(pendingHours)).intValue();
+
+                        pendingHours = BigDecimal.ONE
+                                .subtract(
+                                        lastConslidation.setScale(2).divide(
+                                                new BigDecimal(100),
+                                                RoundingMode.DOWN)).multiply(
+                                        new BigDecimal(pendingHours))
+                                .intValue();
                     }
                     if (!taskEndDate.equals(endExclusive)) {
                         if ((taskEndDate != null) && (endExclusive != null)
@@ -359,6 +360,24 @@ public class AdvanceConsolidationModel implements IAdvanceConsolidationModel {
                     reassign(resourceAllocation, firstDayNotConsolidated,
                             endExclusive, pendingHours);
                 }
+
+                // delete the assignments with posterior date than endDate
+                List<DayAssignment> toremove = new ArrayList<DayAssignment>();
+                for (DayAssignment dayAssignment : task.getDayAssignments()) {
+                    if (dayAssignment.getDay().compareTo(endExclusive) >= 0) {
+                        toremove.add(dayAssignment);
+                    }
+                }
+                task.getDayAssignments().removeAll(toremove);
+
+                // update the day assignment which not are consolidated
+                // according to the first day not consolidated in the task
+                for (DayAssignment dayAssignment : task.getDayAssignments()) {
+                    if (dayAssignment.getDay().compareTo(
+                            firstDayNotConsolidated) >= 0) {
+                        dayAssignment.setConsolidated(false);
+                    }
+                }
             }
         }
     }