ItEr11S13ProbasModuloRecursos: Introducing tests that reproduce the detected bugs and fixes to resolve them. Now the

implementation is much more simpler.CriterionSatisfaction can now be used more easily in forms.

navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Criterion.java

@@ -55,11 +55,12 @@ public class Criterion implements ICriterion {
 
     @Override
     public boolean isSatisfiedBy(Resource resource) {
-        return !resource.getActiveSatisfactionsFor(this).isEmpty();
+        return !resource.getCurrentSatisfactionsFor(this).isEmpty();
     }
 
     public boolean isSatisfiedBy(Resource resource, Date start, Date end) {
-        return !resource.getActiveSatisfactionsForIn(this, start, end)
+        return !resource.query().from(this)
+        .enforcedInAll(Interval.range(start, end)).result()
                 .isEmpty();
     }
 

navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/CriterionSatisfaction.java

@@ -1,11 +1,9 @@
 package org.navalplanner.business.resources.entities;
 
+import java.util.Comparator;
 import java.util.Date;
 
 import org.apache.commons.lang.Validate;
-import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
-import org.navalplanner.business.resources.daos.ICriterionSatisfactionDAO;
-import org.springframework.beans.factory.annotation.Autowired;
 
 /**
  * Declares a interval of time in which the criterion is satisfied <br />
@@ -13,18 +11,24 @@ import org.springframework.beans.factory.annotation.Autowired;
  */
 public class CriterionSatisfaction {
 
+    public static final Comparator<CriterionSatisfaction> BY_START_COMPARATOR;
+
+    static {
+        BY_START_COMPARATOR = new Comparator<CriterionSatisfaction>() {
+
+            @Override
+            public int compare(CriterionSatisfaction o1,
+                    CriterionSatisfaction o2) {
+                return o1.getStartDate().compareTo(o2.getStartDate());
+            }
+        };
+    }
+
     private Long id;
 
     @SuppressWarnings("unused")
     private long version;
 
-    @Autowired
-    private ICriterionSatisfactionDAO criterionSatisfactionDAO;
-
-
-    /**
-     * Required by hibernate. Do not use directly
-     */
     public CriterionSatisfaction() {
 
     }
@@ -39,6 +43,14 @@ public class CriterionSatisfaction {
         this.resource = resource;
     }
 
+    public CriterionSatisfaction(Criterion criterion, Resource resource,
+            Interval interval) {
+        this(interval.getStart(), criterion, resource);
+        if (interval.getEnd() != null) {
+            this.finish(interval.getEnd());
+        }
+    }
+
     public Long getId() {
         return id;
     }
@@ -52,44 +64,54 @@ public class CriterionSatisfaction {
     private Resource resource;
 
     public Date getStartDate() {
-        return startDate==null ? null: new Date(startDate.getTime());
+        return startDate != null ? new Date(startDate.getTime()) : null;
     }
 
     public Date getEndDate() {
-        if (isFinished() ) {
+        if (isFinished()) {
             return new Date(finishDate.getTime());
         } else {
             return null;
         }
     }
 
+    public Interval getInterval() {
+        return Interval.range(startDate, finishDate);
+    }
+
     public Criterion getCriterion() {
         return criterion;
     }
 
+    public void setCriterion(Criterion criterion) {
+        this.criterion = criterion;
+    }
+
     public Resource getResource() {
         return resource;
     }
 
-    public boolean isActiveNow() {
+    public void setResource(Resource resource) {
+        this.resource = resource;
+    }
+
+    public boolean isCurrent() {
         Date now = new Date();
-        return isActiveAt(now);
+        return isEnforcedAt(now);
     }
 
-    public boolean isActiveAt(Date date) {
+    public boolean isEnforcedAt(Date date) {
-        return (startDate.before(date) || startDate.equals(date))
+        return getInterval().contains(date);
-                && (finishDate == null || date.before(finishDate));
     }
 
-    public boolean isActiveIn(Date start, Date end) {
+    public boolean isAlwaysEnforcedIn(Interval interval) {
-        return (startDate.equals(start) || startDate.before(start))
+        return getInterval().includes(interval);
-                && (finishDate == null || end.before(finishDate));
     }
 
     public void finish(Date finish) {
         Validate.notNull(finish);
         Validate.isTrue(startDate.equals(finish) || startDate.before(finish));
-        finishDate = finish;
+        this.finishDate = finish;
     }
 
     public boolean isFinished() {
@@ -97,13 +119,20 @@ public class CriterionSatisfaction {
     }
 
     public void setEndDate(Date date) {
-        if ( (startDate.equals(date) || startDate.before(date)) )
+        if (date == null) {
+            finishDate = null;
+        }
+        if ((startDate.equals(date) || startDate.before(date)))
             finishDate = date;
     }
 
     public void setStartDate(Date date) {
-        if ( (finishDate == null || finishDate.after(date)) )
+        if ((finishDate == null || finishDate.after(date)))
             startDate = date;
     }
 
+    public boolean overlapsWith(Interval interval) {
+        return getInterval().overlapsWith(interval);
+    }
+
 }

navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/CriterionTypeBase.java

@@ -10,7 +10,7 @@ public abstract class CriterionTypeBase implements ICriterionType<Criterion> {
 
     private final boolean allowHierarchy;
 
-    private final boolean allowMultipleCriterionsPerResource;
+    private final boolean allowSimultaneousCriterionsPerResource;
 
     private final String name;
 
@@ -19,11 +19,11 @@ public abstract class CriterionTypeBase implements ICriterionType<Criterion> {
     private final boolean allowEditing;
 
     protected CriterionTypeBase(String name, boolean allowHierarchy,
-            boolean allowMultipleCriterionsPerResource, boolean allowAdding,
+            boolean allowSimultaneousCriterionsPerResource,
-            boolean allowEditing) {
+            boolean allowAdding, boolean allowEditing) {
         Validate.notNull(name, "name is not null");
         this.allowHierarchy = allowHierarchy;
-        this.allowMultipleCriterionsPerResource = allowMultipleCriterionsPerResource;
+        this.allowSimultaneousCriterionsPerResource = allowSimultaneousCriterionsPerResource;
         this.name = name;
         this.allowAdding = allowAdding;
         this.allowEditing = allowEditing;
@@ -35,8 +35,8 @@ public abstract class CriterionTypeBase implements ICriterionType<Criterion> {
     }
 
     @Override
-    public boolean allowMultipleActiveCriterionsPerResource() {
+    public boolean allowSimultaneousCriterionsPerResource() {
-        return allowMultipleCriterionsPerResource;
+        return allowSimultaneousCriterionsPerResource;
     }
 
     public String getName() {

navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/ICriterionType.java

@@ -8,7 +8,7 @@ public interface ICriterionType<C extends ICriterion> {
 
     public String getName();
 
-    public boolean allowMultipleActiveCriterionsPerResource();
+    public boolean allowSimultaneousCriterionsPerResource();
 
     public boolean allowHierarchy();
 

navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Interval.java

@@ -0,0 +1,157 @@
+package org.navalplanner.business.resources.entities;
+
+import java.util.Date;
+
+import org.apache.commons.lang.Validate;
+
+/**
+ * Represents a time interval <br />
+ * @author Óscar González Fernández <ogonzalez@igalia.com>
+ */
+public abstract class Interval {
+    protected final Date start;
+    protected final Date end;
+
+    public static Interval from(Date start) {
+        return new OpenEndedInterval(start);
+    }
+
+    public static Interval point(Date date) {
+        return new Point(date);
+    }
+
+    public static Interval range(Date start, Date end) {
+        Validate.notNull(start, "start date must be not null");
+        if (end == null)
+            return from(start);
+        if (start.equals(end))
+            return point(start);
+        return new Range(start, end);
+    }
+
+    protected Interval(Date start, Date end) {
+        Validate.notNull(start, "start date must be not null");
+        if (end != null) {
+            Validate.isTrue(start.compareTo(end) <= 0,
+                    "start date must be equal or before than end date");
+        }
+        this.start = start;
+        this.end = end;
+    }
+
+    public abstract boolean contains(Date date);
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Interval) {
+            Interval interval = (Interval) obj;
+            return dateEquals(start, interval.start)
+                    && dateEquals(end, interval.end);
+        }
+        return false;
+    }
+
+    private boolean dateEquals(Date date1, Date date2) {
+        return date1 == date2
+                || (date1 != null && date2 != null && date1.equals(date2));
+    }
+
+    public abstract boolean includes(Interval included);
+
+    public abstract boolean overlapsWith(Interval interval);
+
+    public boolean before(Date date) {
+        return start.before(date);
+    }
+
+    public Date getStart() {
+        return new Date(start.getTime());
+    }
+
+    public Date getEnd() {
+        return end != null ? new Date(end.getTime()) : null;
+    }
+
+}
+
+class Range extends Interval {
+
+    Range(Date start, Date end) {
+        super(start, end);
+        Validate.notNull(start);
+        Validate.notNull(end);
+    }
+
+    @Override
+    public boolean contains(Date date) {
+        return date.compareTo(start) >= 0 && date.compareTo(end) < 0;
+    }
+
+    @Override
+    public boolean includes(Interval included) {
+        if (included instanceof Point) {
+            Point point = (Point) included;
+            return point.overlapsWith(this);
+        }
+        return start.compareTo(included.start) <= 0 && included.end != null
+                && end.after(included.end);
+    }
+
+    @Override
+    public boolean overlapsWith(Interval interval) {
+        if (interval instanceof Point) {
+            Point point = (Point) interval;
+            return point.overlapsWith(this);
+        }
+        return contains(interval.start)
+                || (interval.end != null ? contains(interval.end)
+                        && !interval.end.equals(start) : end
+                        .compareTo(interval.start) > 0);
+    }
+
+}
+
+class OpenEndedInterval extends Interval {
+    OpenEndedInterval(Date start) {
+        super(start, null);
+    }
+
+    @Override
+    public boolean contains(Date date) {
+        return date.compareTo(start) >= 0;
+    }
+
+    @Override
+    public boolean includes(Interval included) {
+        return start.compareTo(included.start) <= 0;
+    }
+
+    @Override
+    public boolean overlapsWith(Interval interval) {
+        return start.before(interval.start) || interval.end == null
+                || start.before(interval.end);
+    }
+}
+
+class Point extends Interval {
+
+    Point(Date date) {
+        super(date, date);
+    }
+
+    @Override
+    public boolean contains(Date date) {
+        return start.equals(date);
+    }
+
+    @Override
+    public boolean includes(Interval included) {
+        return equals(included);
+    }
+
+    @Override
+    public boolean overlapsWith(Interval interval) {
+        return interval.contains(end) && !interval.start.equals(end);
+    }
+
+}

navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/PredefinedCriterionTypes.java

@@ -30,7 +30,7 @@ public enum PredefinedCriterionTypes implements ICriterionType<Criterion> {
 
     private final boolean allowHierarchy;
 
-    private final boolean allowMultipleActiveCriterionsPerResource;
+    private final boolean allowSimultaneousCriterionsPerResource;
 
     private final boolean allowAdding;
 
@@ -39,11 +39,11 @@ public enum PredefinedCriterionTypes implements ICriterionType<Criterion> {
     private List<Class<? extends Resource>> classes;
 
     private PredefinedCriterionTypes(boolean allowHierarchy,
-            boolean allowMultipleActiveCriterionsPerResource,
+            boolean allowSimultaneousCriterionsPerResource,
             boolean allowAdding, boolean allowEditing,
             Class<? extends Resource>... klasses) {
         this.allowHierarchy = allowHierarchy;
-        this.allowMultipleActiveCriterionsPerResource = allowMultipleActiveCriterionsPerResource;
+        this.allowSimultaneousCriterionsPerResource = allowSimultaneousCriterionsPerResource;
         this.allowAdding = allowAdding;
         this.allowEditing = allowEditing;
         this.classes = Arrays.asList(klasses);
@@ -64,8 +64,8 @@ public enum PredefinedCriterionTypes implements ICriterionType<Criterion> {
     }
 
     @Override
-    public boolean allowMultipleActiveCriterionsPerResource() {
+    public boolean allowSimultaneousCriterionsPerResource() {
-        return allowMultipleActiveCriterionsPerResource;
+        return allowSimultaneousCriterionsPerResource;
     }
 
     @Override

navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java

@@ -1,11 +1,11 @@
 package org.navalplanner.business.resources.entities;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -20,6 +20,7 @@ import org.navalplanner.business.resources.daos.ResourcesDaoRegistry;
 // child another simple resource, general methods like getChilds() do not make
 // sense for simple entities, etc.). In consequence, I prefer the modeling
 // option shown below.
+
 /**
  * This class acts as the base class for all resources.
  * @author Fernando Bellas Permuy <fbellas@udc.es>
@@ -27,9 +28,126 @@ import org.navalplanner.business.resources.daos.ResourcesDaoRegistry;
 public abstract class Resource {
 
     private Long id;
+
     private long version;
+
     private Set<CriterionSatisfaction> criterionSatisfactions = new HashSet<CriterionSatisfaction>();
 
+    private interface Predicate {
+        public boolean accepts(CriterionSatisfaction satisfaction);
+    }
+
+    public class Query {
+
+        private List<Predicate> predicates = new ArrayList<Predicate>();
+        private boolean sort = false;
+
+        private Query() {
+
+        }
+
+        public Query from(final ICriterionType<?> type) {
+            return withNewPredicate(new Predicate() {
+
+                @Override
+                public boolean accepts(CriterionSatisfaction satisfaction) {
+                    return type.contains(satisfaction.getCriterion());
+                }
+            });
+        }
+
+        private Query withNewPredicate(Predicate newPredicate) {
+            predicates.add(newPredicate);
+            return this;
+        }
+
+        public Query at(Date date) {
+            return enforcedInAll(Interval.point(date));
+        }
+
+        public Query between(Date start, Date end) {
+            return enforcedInAll(Interval.range(start, end));
+        }
+
+        public Query enforcedInAll(final Interval interval) {
+            return withNewPredicate(new Predicate() {
+
+                @Override
+                public boolean accepts(CriterionSatisfaction satisfaction) {
+                    return satisfaction.isAlwaysEnforcedIn(interval);
+                }
+            });
+        }
+
+        public Query overlapsWith(final Interval interval) {
+            return withNewPredicate(new Predicate() {
+
+                @Override
+                public boolean accepts(CriterionSatisfaction satisfaction) {
+                    return satisfaction.overlapsWith(interval);
+                }
+            });
+        }
+
+        public Query from(final ICriterion criterion) {
+            return withNewPredicate(new Predicate() {
+
+                @Override
+                public boolean accepts(CriterionSatisfaction satisfaction) {
+                    return satisfaction.getCriterion().isEquivalent(criterion);
+                }
+            });
+        }
+
+        public Query sortByStartDate() {
+            sort = true;
+            return this;
+        }
+
+        public List<CriterionSatisfaction> result() {
+            ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
+            for (CriterionSatisfaction criterionSatisfaction : criterionSatisfactions) {
+                if (isAcceptedByAllPredicates(criterionSatisfaction)) {
+                    result.add(criterionSatisfaction);
+                }
+            }
+            Collections.sort(result, CriterionSatisfaction.BY_START_COMPARATOR);
+            return result;
+        }
+
+        private boolean isAcceptedByAllPredicates(
+                CriterionSatisfaction criterionSatisfaction) {
+            for (Predicate predicate : predicates) {
+                if (!predicate.accepts(criterionSatisfaction))
+                    return false;
+            }
+            return true;
+        }
+
+        public Query current() {
+            return withNewPredicate(new Predicate() {
+
+                @Override
+                public boolean accepts(CriterionSatisfaction satisfaction) {
+                    return satisfaction.isCurrent();
+                }
+            });
+        }
+
+        public List<Criterion> asCriterions() {
+            LinkedHashSet<Criterion> result = new LinkedHashSet<Criterion>();
+            for (CriterionSatisfaction criterionSatisfaction : result()) {
+                result.add(criterionSatisfaction.getCriterion());
+            }
+            return new ArrayList<Criterion>(result);
+        }
+
+    }
+
+    public Query query() {
+        return new Query();
+    }
+
     public Long getId() {
         return id;
     }
@@ -63,207 +181,194 @@ public abstract class Resource {
     }
 
     public Set<CriterionSatisfaction> getAllSatisfactions() {
-        return new HashSet(criterionSatisfactions);
+        return new HashSet<CriterionSatisfaction>(criterionSatisfactions);
     }
 
     public Collection<CriterionSatisfaction> getSatisfactionsFor(
             ICriterionType<?> type) {
-        Set<CriterionSatisfaction> allSatisfactions = getAllSatisfactions();
+        return query().from(type).result();
-        ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
-        for (CriterionSatisfaction criterionSatisfaction : allSatisfactions) {
-            if (type.contains(criterionSatisfaction.getCriterion())) {
-                result.add(criterionSatisfaction);
-            }
-        }
-        return result;
     }
 
     public List<CriterionSatisfaction> getSatisfactionsFor(ICriterion criterion) {
-        ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
+        return query().from(criterion).result();
-        for (CriterionSatisfaction criterionSatisfaction : getAllSatisfactions()) {
-            if (criterionSatisfaction.getCriterion().isEquivalent(criterion)) {
-                result.add(criterionSatisfaction);
-            }
-        }
-        return result;
     }
 
-    public Set<Criterion> getActiveCriterionsFor(ICriterionType<?> type) {
+    public List<Criterion> getCurrentCriterionsFor(ICriterionType<?> type) {
-        Set<Criterion> result = new HashSet<Criterion>();
+        return query().from(type).current().asCriterions();
-        Collection<CriterionSatisfaction> active = getActiveSatisfactionsFor(type);
-        for (CriterionSatisfaction satisfaction : active) {
-            result.add(satisfaction.getCriterion());
-        }
-        return result;
     }
 
-    public Collection<CriterionSatisfaction> getActiveSatisfactionsFor(
+    public Collection<CriterionSatisfaction> getCurrentSatisfactionsFor(
             ICriterionType<?> criterionType) {
-        Collection<CriterionSatisfaction> satisfactionsFor = getSatisfactionsFor(criterionType);
+        return query().from(criterionType).current().result();
-        ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
-        for (CriterionSatisfaction criterionSatisfaction : satisfactionsFor) {
-            if (criterionSatisfaction.isActiveNow()) {
-                result.add(criterionSatisfaction);
-            }
-        }
-        return result;
     }
 
-    public Collection<CriterionSatisfaction> getActiveSatisfactionsForIn(
+    public List<CriterionSatisfaction> getCurrentSatisfactionsFor(
-            ICriterionType<?> criterionType, Date start, Date end) {
-        Validate.notNull(criterionType);
-        Validate.isTrue(end == null || start.before(end));
-        Collection<CriterionSatisfaction> satisfactionsFor = getSatisfactionsFor(criterionType);
-        ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
-        for (CriterionSatisfaction criterionSatisfaction : satisfactionsFor) {
-            if (end == null && criterionSatisfaction.isActiveAt(start) || end != null && criterionSatisfaction.isActiveIn(start, end)) {
-                result.add(criterionSatisfaction);
-            }
-        }
-        return result;
-    }
-
-    public Collection<CriterionSatisfaction> getActiveSatisfactionsAt(
-            ICriterionType<?> criterionType, Date pointInTime) {
-        return getActiveSatisfactionsForIn(criterionType, pointInTime, null);
-    }
-
-    public Collection<CriterionSatisfaction> getActiveSatisfactionsFor(
             ICriterion criterion) {
-        Set<CriterionSatisfaction> result = new HashSet<CriterionSatisfaction>();
+        return query().from(criterion).current().result();
-        for (CriterionSatisfaction criterionSatisfaction : getAllSatisfactionsFor(criterion)) {
+    }
-            if (criterionSatisfaction.isActiveNow()) {
+
-                result.add(criterionSatisfaction);
+    public CriterionSatisfaction addSatisfaction(
+            CriterionWithItsType criterionWithItsType) {
+        return addSatisfaction(criterionWithItsType, Interval.from(new Date()));
+    }
+
+    private static class EnsureSatisfactionIsCorrect {
+
+        private EnsureSatisfactionIsCorrect(Resource resource,
+                ICriterionType<?> type, CriterionSatisfaction satisfaction) {
+            Validate.notNull(resource);
+            Validate.notNull(satisfaction.getResource());
+            Validate.notNull(satisfaction);
+            if (!satisfaction.getResource().equals(resource)) {
+                throw new IllegalArgumentException(
+                        "the satisfaction is not related to this resource");
             }
+            this.type = new CriterionWithItsType(type, satisfaction
+                    .getCriterion());
+            this.interval = satisfaction.getInterval();
+            this.resource = resource;
         }
-        return result;
-    }
 
-    private Collection<CriterionSatisfaction> getAllSatisfactionsFor(
+        final Resource resource;
-            ICriterion criterion) {
+
-        Set<CriterionSatisfaction> result = new HashSet<CriterionSatisfaction>();
+        final CriterionWithItsType type;
-        for (CriterionSatisfaction satisfaction : criterionSatisfactions) {
+
-            if (satisfaction.getCriterion().isEquivalent(criterion)) {
+        final Interval interval;
-                result.add(satisfaction);
+
-            }
+        CriterionSatisfaction addSatisfaction() {
+            return resource.addSatisfaction(type, interval);
         }
-        return result;
-    }
 
-    public Collection<CriterionSatisfaction> getActiveSatisfactionsForIn(
+        boolean canAddSatisfaction() {
-            ICriterion criterion, Date start, Date end) {
+            return resource.canAddSatisfaction(type, interval);
-        Validate.isTrue(end == null || start.before(end));
-        ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
-        Collection<CriterionSatisfaction> allSatisfactionsFor = getAllSatisfactionsFor(criterion);
-        for (CriterionSatisfaction criterionSatisfaction : allSatisfactionsFor) {
-            if (criterionSatisfaction.isActiveIn(start, end)) {
-                result.add(criterionSatisfaction);
-            }
         }
-        return result;
+
     }
 
-    public void activate(CriterionWithItsType criterionWithItsType) {
+    public CriterionSatisfaction addSatisfaction(
-        activate(criterionWithItsType, new Date());
+            ICriterionType<Criterion> type, CriterionSatisfaction satisfaction) {
+        return new EnsureSatisfactionIsCorrect(this, type, satisfaction)
+                .addSatisfaction();
     }
 
-    public void activate(CriterionWithItsType criterionWithItsType, Date start) {
+    public CriterionSatisfaction addSatisfaction(
-        activate(criterionWithItsType, start, null);
+            CriterionWithItsType criterionWithItsType, Interval interval) {
-    }
-
-    public void activate(CriterionWithItsType criterionWithItsType, Date start,
-            Date finish) {
-        ICriterionType<?> type = criterionWithItsType.getType();
         Criterion criterion = criterionWithItsType.getCriterion();
-        if (canBeActivated(criterionWithItsType, start, finish)) {
+        ICriterionType<?> type = criterionWithItsType.getType();
-            CriterionSatisfaction newSatisfaction = new CriterionSatisfaction(
+        CriterionSatisfaction newSatisfaction = createNewSatisfaction(interval,
-                    start, criterion, this);
+                criterion);
-            criterionSatisfactions.add(newSatisfaction);
+        if (canAddSatisfaction(criterionWithItsType, interval)) {
+            Date finish = getFinishDate(type, newSatisfaction, interval);
             if (finish != null) {
                 newSatisfaction.finish(finish);
             }
-            if (!type.allowMultipleActiveCriterionsPerResource()) {
+            criterionSatisfactions.add(newSatisfaction);
-                for (CriterionSatisfaction criterionSatisfaction : getActiveSatisfactionsAt(
+            return newSatisfaction;
-                        type, start)) {
-                    if (newSatisfaction != criterionSatisfaction) {
-                        criterionSatisfaction.finish(start);
-                    }
-                }
-                Set<CriterionSatisfaction> posterior = getSatisfactionsPosteriorTo(
-                        type, newSatisfaction);
-                Date earliest = getEarliestStartDate(posterior);
-                if (earliest != null) {
-                    newSatisfaction.finish(earliest);
-                }
-            }
         } else {
             throw new IllegalStateException(
                     "this resource is activaved for other criterion of the same type");
         }
-
     }
 
-    private static Date getEarliestStartDate(
+    private CriterionSatisfaction createNewSatisfaction(Interval interval,
-            Set<CriterionSatisfaction> posterior) {
+            Criterion criterion) {
-        Date earliest = null;
+        CriterionSatisfaction newSatisfaction = new CriterionSatisfaction(
-        for (CriterionSatisfaction criterionSatisfaction : posterior) {
+                criterion, this, interval);
-            if (earliest == null) {
+        return newSatisfaction;
-                earliest = criterionSatisfaction.getStartDate();
+    }
+
+    private Date getFinishDate(ICriterionType<?> type,
+            CriterionSatisfaction newSatisfaction, Interval interval) {
+        if (!type.allowSimultaneousCriterionsPerResource()) {
+            CriterionSatisfaction posterior = getNext(type, newSatisfaction);
+            if (posterior != null && posterior.overlapsWith(interval)) {
+                assert !posterior.overlapsWith(Interval.range(interval
+                        .getStart(), posterior.getStartDate()));
+                return posterior.getStartDate();
             }
-            earliest = Collections.min(Arrays.asList(earliest,
-                    criterionSatisfaction.getStartDate()));
         }
-        return earliest;
+        return interval.getEnd();
     }
 
-    private Set<CriterionSatisfaction> getSatisfactionsPosteriorTo(
+    /**
-            ICriterionType<?> type, CriterionSatisfaction newSatisfaction) {
+     * @param orderedSatisfactions
-        Date start = newSatisfaction.getStartDate();
+     * @param newSatisfaction
-        Date finish = newSatisfaction.isFinished() ? newSatisfaction.getEndDate() : null;
+     * @return the position in which if newSatisfaction is inserted would comply
-        Set<CriterionSatisfaction> posterior = new HashSet<CriterionSatisfaction>();
+     *         with the following:
-        if (finish != null) {
+     *         <ul>
-            posterior.addAll(getActiveSatisfactionsAt(type, finish));
+     *         <li>newSatisfaction startDate would be equal or posterior to all
+     *         the previous satisfactions</li>
+     *         <li>newSatisfaction startDate would be previous to all the
+     *         posterior satisfactions</li>
+     *         </ul>
+     */
+    private int findPlace(List<CriterionSatisfaction> orderedSatisfactions,
+            CriterionSatisfaction newSatisfaction) {
+        int position = Collections.binarySearch(orderedSatisfactions,
+                newSatisfaction, CriterionSatisfaction.BY_START_COMPARATOR);
+        if (position >= 0) {
+            return position + 1;
         } else {
-            ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
+            return Math.abs(position) - 1;
-            for (CriterionSatisfaction satisfaction : getSatisfactionsFor(type)) {
-                if (!satisfaction.isFinished() && satisfaction.getStartDate().after(start)) {
-                    result.add(satisfaction);
-                }
-            }
-            posterior.addAll(result);
-        }
-        posterior.remove(newSatisfaction);
-        return posterior;
-    }
-
-    public void deactivate(CriterionWithItsType criterionWithItsType) {
-        for (CriterionSatisfaction criterionSatisfaction : getActiveSatisfactionsFor(criterionWithItsType.getCriterion())) {
-            criterionSatisfaction.finish(new Date());
         }
     }
 
-    private boolean noneOf(CriterionWithItsType criterionWithItsType,
+    public List<CriterionSatisfaction> finish(
-            Date start, Date end) {
+            CriterionWithItsType criterionWithItsType) {
+        return finishEnforcedAt(criterionWithItsType, new Date());
+    }
+
+    public List<CriterionSatisfaction> finishEnforcedAt(
+            CriterionWithItsType criterionWithItsType, Date date) {
+        ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
+        for (CriterionSatisfaction criterionSatisfaction : query().from(
+                criterionWithItsType.getType()).at(date).result()) {
+            criterionSatisfaction.finish(date);
+            result.add(criterionSatisfaction);
+        }
+        return result;
+    }
+
+    public boolean canAddSatisfaction(
+            CriterionWithItsType criterionWithItsType, Interval interval) {
         ICriterionType<?> type = criterionWithItsType.getType();
-        Criterion criterion = criterionWithItsType.getCriterion();
+        if (!type.criterionCanBeRelatedTo(getClass())) {
-        return getActiveSatisfactionsForIn(type, start, end).size() == getActiveSatisfactionsForIn(
+            return false;
-                criterion, start, end).size();
+        }
+        if (type.allowSimultaneousCriterionsPerResource()) {
+            return true;
+        }
+        CriterionSatisfaction newSatisfaction = createNewSatisfaction(interval,
+                criterionWithItsType.getCriterion());
+        CriterionSatisfaction previous = getPrevious(criterionWithItsType
+                .getType(), newSatisfaction);
+        return previous == null || !previous.overlapsWith(interval);
     }
 
-    public boolean canBeActivated(CriterionWithItsType criterionWithItsType) {
+    public boolean canAddSatisfaction(ICriterionType<?> type,
-        return canBeActivated(criterionWithItsType, new Date());
+            CriterionSatisfaction satisfaction) {
+        return new EnsureSatisfactionIsCorrect(this, type, satisfaction)
+                .canAddSatisfaction();
     }
 
-    public boolean canBeActivated(CriterionWithItsType criterionWithItsType,
+    private CriterionSatisfaction getNext(ICriterionType<?> type,
-            Date start) {
+            CriterionSatisfaction newSatisfaction) {
-        return canBeActivated(criterionWithItsType, start, null);
+        List<CriterionSatisfaction> ordered = query().from(type)
+                .sortByStartDate().result();
+        int position = findPlace(ordered, newSatisfaction);
+        CriterionSatisfaction next = position != ordered.size() ? ordered
+                .get(position) : null;
+        return next;
     }
 
-    public boolean canBeActivated(CriterionWithItsType criterionWithItsType,
+    private CriterionSatisfaction getPrevious(ICriterionType<?> type,
-            Date start, Date finish) {
+            CriterionSatisfaction newSatisfaction) {
-        ICriterionType<?> type = criterionWithItsType.getType();
+        List<CriterionSatisfaction> ordered = query().from(type)
-        return type.criterionCanBeRelatedTo(getClass()) && (type.allowMultipleActiveCriterionsPerResource() || noneOf(
+                .sortByStartDate().result();
-                criterionWithItsType, start, finish));
+        int position = findPlace(ordered, newSatisfaction);
+        CriterionSatisfaction previous = position > 0 ? ordered
+                .get(position - 1) : null;
+        return previous;
     }
 
     public void removeCriterionSatisfaction(CriterionSatisfaction satisfaction)
@@ -271,4 +376,8 @@ public abstract class Resource {
         criterionSatisfactions.remove(satisfaction);
     }
 
+    public boolean contains(CriterionSatisfaction satisfaction) {
+        return criterionSatisfactions.contains(satisfaction);
+    }
+
 }

navalplanner-business/src/main/java/org/navalplanner/business/resources/services/impl/CriterionServiceImpl.java

@@ -14,6 +14,7 @@ import org.navalplanner.business.resources.entities.CriterionSatisfaction;
 import org.navalplanner.business.resources.entities.ICriterion;
 import org.navalplanner.business.resources.entities.ICriterionOnData;
 import org.navalplanner.business.resources.entities.ICriterionType;
+import org.navalplanner.business.resources.entities.Interval;
 import org.navalplanner.business.resources.entities.Resource;
 import org.navalplanner.business.resources.services.CriterionService;
 import org.navalplanner.business.resources.services.ResourceService;
@@ -100,7 +101,7 @@ public class CriterionServiceImpl implements CriterionService {
             ICriterionType<?> criterionType) {
         ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
         for (Resource resource : resourceService.getResources()) {
-            result.addAll(resource.getActiveSatisfactionsFor(criterionType));
+            result.addAll(resource.getCurrentSatisfactionsFor(criterionType));
         }
         return result;
     }
@@ -110,8 +111,8 @@ public class CriterionServiceImpl implements CriterionService {
             ICriterionType<?> criterionType, Date start, Date end) {
         ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
         for (Resource resource : resourceService.getResources()) {
-            result.addAll(resource.getActiveSatisfactionsForIn(criterionType,
+            result.addAll(resource.query().from(criterionType).enforcedInAll(
-                    start, end));
+                    Interval.range(start, end)).result());
         }
         return result;
     }

navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/CriterionSatisfactionTest.java

@@ -1,17 +1,23 @@
 package org.navalplanner.business.test.resources.entities;
 
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Date;
+import java.util.List;
 
 import org.junit.Test;
 import org.navalplanner.business.resources.entities.Criterion;
 import org.navalplanner.business.resources.entities.CriterionSatisfaction;
+import org.navalplanner.business.resources.entities.Interval;
 import org.navalplanner.business.resources.entities.Worker;
 import org.navalplanner.business.test.resources.daos.CriterionDAOTest;
-import org.navalplanner.business.test.resources.daos.CriterionSatisfactionDAOTest;
 
 import static junit.framework.Assert.assertEquals;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
+import static org.navalplanner.business.test.resources.daos.CriterionSatisfactionDAOTest.year;
 
 /**
  * Tests for {@link CriterionSatisfaction} <br />
@@ -24,8 +30,8 @@ public class CriterionSatisfactionTest {
         final Criterion criterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
-                CriterionSatisfactionDAOTest.year(2000), criterion, worker);
+                year(2000), criterion, worker);
-        Date end = CriterionSatisfactionDAOTest.year(2006);
+        Date end = year(2006);
         criterionSatisfaction.finish(end);
         assertTrue(criterionSatisfaction.isFinished());
         assertEquals(end, criterionSatisfaction.getEndDate());
@@ -38,7 +44,7 @@ public class CriterionSatisfactionTest {
     public void canFinishWhenItStarted() throws Exception {
         final Criterion criterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        Date start = CriterionSatisfactionDAOTest.year(2000);
+        Date start = year(2000);
         CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
                 start, criterion, worker);
         criterionSatisfaction.finish(start);
@@ -50,29 +56,75 @@ public class CriterionSatisfactionTest {
         final Criterion criterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
-                CriterionSatisfactionDAOTest.year(2000), criterion, worker);
+                year(2000), criterion, worker);
-        criterionSatisfaction.finish(CriterionSatisfactionDAOTest.year(1999));
+        criterionSatisfaction.finish(year(1999));
     }
 
     @Test
-    public void isValidAtDate() {
+    public void testIsEnforcedAtDate() {
         final Criterion criterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
-                CriterionSatisfactionDAOTest.year(2000), criterion, worker);
+                year(2000), criterion, worker);
-        assertTrue(criterionSatisfaction
+        assertTrue(criterionSatisfaction.isEnforcedAt(year(3000)));
-                .isActiveAt(CriterionSatisfactionDAOTest.year(3000)));
+        assertTrue(criterionSatisfaction.isEnforcedAt(year(2000)));
-        assertTrue(criterionSatisfaction
+        assertFalse(criterionSatisfaction.isEnforcedAt(year(1999)));
-                .isActiveAt(CriterionSatisfactionDAOTest.year(2000)));
+        criterionSatisfaction.finish(year(2005));
-        assertFalse(criterionSatisfaction
+        assertFalse(criterionSatisfaction.isEnforcedAt(year(3000)));
-                .isActiveAt(CriterionSatisfactionDAOTest.year(1999)));
+        assertFalse(criterionSatisfaction.isAlwaysEnforcedIn(Interval.range(
-        criterionSatisfaction.finish(CriterionSatisfactionDAOTest.year(2005));
+                year(2001), year(2006))));
-        assertFalse(criterionSatisfaction
+        assertTrue(criterionSatisfaction.isEnforcedAt(year(2000)));
-                .isActiveAt(CriterionSatisfactionDAOTest.year(3000)));
+        assertTrue(criterionSatisfaction.isEnforcedAt(year(2001)));
-        assertTrue(criterionSatisfaction
+        assertFalse(criterionSatisfaction.isEnforcedAt(year(1999)));
-                .isActiveAt(CriterionSatisfactionDAOTest.year(2000)));
-        assertFalse(criterionSatisfaction
-                .isActiveAt(CriterionSatisfactionDAOTest.year(1999)));
     }
 
+    @Test
+    public void testEnforcedAtSomePointInInterval() {
+        final Criterion criterion = CriterionDAOTest.createValidCriterion();
+        Worker worker = new Worker("firstName", "surName", "2333232", 10);
+        CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
+                year(2000), criterion, worker);
+        assertTrue(criterionSatisfaction.overlapsWith(Interval.range(
+                year(2001), year(4000))));
+        assertTrue(criterionSatisfaction.overlapsWith(Interval.range(
+                year(2005), year(4000))));
+        assertTrue(criterionSatisfaction.overlapsWith(Interval.range(
+                year(1999), year(2001))));
+
+        criterionSatisfaction.finish(year(2004));
+
+        assertTrue(criterionSatisfaction.overlapsWith(Interval.range(
+                year(2002), year(4000))));
+        assertTrue(criterionSatisfaction.overlapsWith(Interval.range(
+                year(2002), null)));
+        assertFalse(criterionSatisfaction.overlapsWith(Interval.range(
+                year(2005), year(4000))));
+        assertTrue(criterionSatisfaction.overlapsWith(Interval.range(
+                year(1999), null)));
+        assertFalse(criterionSatisfaction.overlapsWith(Interval.range(
+                year(1990), year(1995))));
+    }
+
+    @Test
+    public void testCriterionSatisfactionsStartComparator() {
+        final Criterion criterion = CriterionDAOTest.createValidCriterion();
+        Worker worker = new Worker("firstName", "surName", "2333232", 10);
+        Interval[] intervals = { Interval.from(year(1000)),
+                Interval.range(year(1100), year(9000)),
+                Interval.point(year(1101)), Interval.from(year(1200)),
+                Interval.range(year(3000), year(4000)) };
+        List<CriterionSatisfaction> orderedSatisfactions = new ArrayList<CriterionSatisfaction>();
+        for (Interval interval : intervals) {
+            orderedSatisfactions.add(new CriterionSatisfaction(criterion,
+                    worker, interval));
+        }
+        List<CriterionSatisfaction> copy = new ArrayList<CriterionSatisfaction>(
+                orderedSatisfactions);
+        assertThat(copy, equalTo(orderedSatisfactions));
+        for (int i = 0; i < 20; i++) {
+            Collections.shuffle(copy);
+            Collections.sort(copy, CriterionSatisfaction.BY_START_COMPARATOR);
+            assertThat(copy, equalTo(orderedSatisfactions));
+        }
+    }
 }

navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/IntervalTest.java

@@ -0,0 +1,149 @@
+package org.navalplanner.business.test.resources.entities;
+
+import java.util.Date;
+
+import org.junit.Test;
+import org.navalplanner.business.resources.entities.Interval;
+import org.navalplanner.business.test.resources.daos.CriterionSatisfactionDAOTest;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.navalplanner.business.test.resources.daos.CriterionSatisfactionDAOTest.year;
+
+public class IntervalTest {
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testStartDateMustBeBeforeThanEndDate() throws Exception {
+        Interval.range(CriterionSatisfactionDAOTest.year(2000),
+                CriterionSatisfactionDAOTest.year(1999));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testStartDateMustBeNotNull() throws Exception {
+        Interval.range(null, CriterionSatisfactionDAOTest.year(1999));
+    }
+
+    @Test
+    public void intervalCanBeOpenEnded() throws Exception {
+        Interval.range(CriterionSatisfactionDAOTest.year(1990), null);
+    }
+
+    @Test
+    public void testContainsPointInTime() {
+        Interval openEnded = Interval.from(CriterionSatisfactionDAOTest
+                .year(1990));
+        Interval range = Interval.range(
+                CriterionSatisfactionDAOTest.year(1990),
+                CriterionSatisfactionDAOTest.year(2000));
+        Interval startPoint = Interval.point(year(1990));
+        Interval endPoint = Interval.point(year(2000));
+        assertTrue(openEnded.contains(CriterionSatisfactionDAOTest.year(5000)));
+        assertFalse(range.contains(year(5000)));
+        assertTrue(range.contains(year(1990)));
+        assertFalse(range.contains(year(2000)));
+        assertTrue(range.contains(year(1991)));
+        assertFalse(range.contains(year(1989)));
+        assertFalse(range.includes(startPoint));
+        assertFalse(range.includes(endPoint));
+    }
+
+    @Test
+    public void testPointsOnlyContainsThemselves() throws Exception {
+        Interval point = Interval
+                .point(CriterionSatisfactionDAOTest.year(1990));
+        assertTrue(point.contains(CriterionSatisfactionDAOTest.year(1990)));
+        assertFalse(point.contains(CriterionSatisfactionDAOTest.year(2010)));
+    }
+
+    @Test
+    public void testIntervalsAreStartInclusiveAndEndExclusive()
+            throws Exception {
+        Interval range = Interval.range(year(1990), year(2000));
+        assertTrue(range.contains(year(1990)));
+        assertFalse(range.contains(year(2000)));
+        assertFalse(range.contains(new Date(year(1990).getTime() - 1)));
+        assertFalse(range.contains(new Date(year(1990).getTime() - 1)));
+        assertFalse(range.contains(new Date(year(2000).getTime() + 1)));
+    }
+
+    @Test
+    public void testIncludes() throws Exception {
+        Interval bigRange = Interval.range(year(1990), year(2000));
+        Interval included = Interval.range(year(1990), year(1998));
+        Interval point = Interval.point(year(1996));
+        assertTrue(bigRange.includes(included));
+        assertTrue(bigRange.includes(point));
+        assertTrue(included.includes(point));
+    }
+
+    @Test
+    public void testStartPointDoesntOverlapsWithRange() throws Exception {
+        Interval range = Interval.range(year(1990), year(2005));
+        Interval openEndedRange = Interval.from(year(1990));
+        Interval point = Interval.point(year(1990));
+        Interval internalPoint = Interval.point(year(1991));
+
+        assertFalse(point.overlapsWith(range));
+        assertFalse(point.overlapsWith(openEndedRange));
+        assertFalse(range.overlapsWith(point));
+        assertFalse(openEndedRange.overlapsWith(point));
+
+        assertTrue(internalPoint.overlapsWith(range));
+        assertTrue(internalPoint.overlapsWith(openEndedRange));
+        assertTrue(range.overlapsWith(internalPoint));
+        assertTrue(openEndedRange.overlapsWith(internalPoint));
+    }
+
+    @Test
+    public void testOverlapsWith() {
+        Interval firstRange = Interval.range(year(1990), year(2005));
+        Interval igalia = Interval.from(year(2001));
+        Interval distantPoint = Interval.point(year(2030));
+        Interval pointInFirstRange = Interval.point(year(2000));
+        Interval outRange = Interval.range(year(2020), year(2030));
+        assertTrue(firstRange.overlapsWith(igalia));
+        assertTrue(firstRange.overlapsWith(Interval.range(year(1980),
+                year(1991))));
+        assertTrue(igalia.overlapsWith(firstRange));
+        assertTrue(outRange.overlapsWith(igalia));
+        assertFalse(outRange.overlapsWith(firstRange));
+        assertTrue(distantPoint.overlapsWith(igalia));
+        assertFalse(distantPoint.overlapsWith(firstRange));
+        assertTrue(igalia.overlapsWith(distantPoint));
+        assertTrue(distantPoint.overlapsWith(igalia));
+        assertFalse(firstRange.overlapsWith(distantPoint));
+        assertTrue(firstRange.overlapsWith(pointInFirstRange));
+    }
+
+    @Test
+    public void testIntervalFinishingAtTheStartOfOtherDontOverlap()
+            throws Exception {
+        Interval range = Interval.range(year(2000), year(2005));
+        Interval from = Interval.from(year(2000));
+        Interval before = Interval.range(year(1995), year(2000));
+        assertFalse(range.overlapsWith(before));
+        assertFalse(before.overlapsWith(range));
+
+        assertFalse(from.overlapsWith(before));
+        assertFalse(before.overlapsWith(from));
+    }
+
+    @Test
+    public void testStartPointDoesntOverlapsWithRanges() {
+        Interval range = Interval.range(year(2010), year(2030));
+        Interval point = Interval.point(year(2010));
+        Interval otherRange = Interval.from(year(2010));
+        assertFalse(point.overlapsWith(range));
+        assertFalse(range.overlapsWith(point));
+        assertFalse(point.overlapsWith(otherRange));
+        assertFalse(otherRange.overlapsWith(point));
+    }
+
+    @Test
+    public void testCreatingPointWithRange() throws Exception {
+        Interval point = Interval.point(year(1990));
+        Interval range = Interval.range(year(1990), year(1990));
+        assertEquals(point, range);
+    }
+}

navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/ResourceTest.java

@@ -1,7 +1,10 @@
 package org.navalplanner.business.test.resources.entities;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Date;
 import java.util.HashSet;
+import java.util.List;
 
 import org.junit.Test;
 import org.navalplanner.business.resources.entities.Criterion;
@@ -10,6 +13,7 @@ import org.navalplanner.business.resources.entities.CriterionTypeBase;
 import org.navalplanner.business.resources.entities.CriterionWithItsType;
 import org.navalplanner.business.resources.entities.ICriterion;
 import org.navalplanner.business.resources.entities.ICriterionType;
+import org.navalplanner.business.resources.entities.Interval;
 import org.navalplanner.business.resources.entities.Resource;
 import org.navalplanner.business.resources.entities.Worker;
 import org.navalplanner.business.test.resources.daos.CriterionDAOTest;
@@ -21,6 +25,7 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.navalplanner.business.test.resources.daos.CriterionSatisfactionDAOTest.year;
 
 /**
  * Tests for {@link Resource}. <br />
@@ -36,10 +41,10 @@ public class ResourceTest {
         CriterionTypeBase otherType = createTypeThatMatches(false, other);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         assertThat(worker.getSatisfactionsFor(criterion).size(), equalTo(0));
-        worker.activate(new CriterionWithItsType(type, criterion));
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion));
         assertTrue(criterion.isSatisfiedBy(worker));
         assertThat(worker.getSatisfactionsFor(criterion).size(), equalTo(1));
-        worker.activate(new CriterionWithItsType(otherType, other));
+        worker.addSatisfaction(new CriterionWithItsType(otherType, other));
         assertTrue(other.isSatisfiedBy(worker));
         assertThat(worker.getSatisfactionsFor(other).size(), equalTo(1));
         assertThat(worker.getSatisfactionsFor(criterion).size(), equalTo(1));
@@ -48,17 +53,16 @@ public class ResourceTest {
     @Test(expected = IllegalArgumentException.class)
     public void getSatisfactionsForWrongIntervalThrowsException() {
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        worker.getActiveSatisfactionsForIn(CriterionDAOTest
+        worker.query().from(CriterionDAOTest.createValidCriterion())
-                .createValidCriterion(), CriterionSatisfactionDAOTest
+                .enforcedInAll(Interval.range(year(2000), year(1999)))
-                .year(2000), CriterionSatisfactionDAOTest.year(1999));
+                .result();
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void getSatisfactionsForWrongIntervalForCriterionTypeThrowsException() {
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        worker.getActiveSatisfactionsForIn(createTypeThatMatches(),
+        worker.query().from(createTypeThatMatches()).enforcedInAll(
-                CriterionSatisfactionDAOTest.year(2000),
+                Interval.range(year(2000), year(1999))).current().result();
-                CriterionSatisfactionDAOTest.year(1999));
     }
 
     @Test
@@ -71,14 +75,14 @@ public class ResourceTest {
         CriterionWithItsType otherCriterionWithItsType = new CriterionWithItsType(
                 createTypeThatMatches(otherCriterion), otherCriterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval
-                .year(2000));
+                .from(CriterionSatisfactionDAOTest.year(2000)));
-        worker.activate(otherCriterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(otherCriterionWithItsType, Interval
-                .year(2000));
+                .from(CriterionSatisfactionDAOTest.year(2000)));
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval
-                .year(4000));
+                .from(CriterionSatisfactionDAOTest.year(4000)));
         assertEquals(2, worker.getSatisfactionsFor(criterionType).size());
-        assertEquals(1, worker.getActiveSatisfactionsFor(criterionType).size());
+        assertEquals(1, worker.getCurrentSatisfactionsFor(criterionType).size());
     }
 
     @Test
@@ -92,16 +96,16 @@ public class ResourceTest {
         CriterionWithItsType otherCriterionWithItsType = new CriterionWithItsType(
                 type, otherCriterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        assertThat(worker.getActiveCriterionsFor(type).size(), equalTo(0));
+        assertThat(worker.getCurrentCriterionsFor(type).size(), equalTo(0));
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval
-                .year(2000));
+                .from(CriterionSatisfactionDAOTest.year(2000)));
-        assertThat(worker.getActiveCriterionsFor(type).size(), equalTo(1));
+        assertThat(worker.getCurrentCriterionsFor(type).size(), equalTo(1));
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval
-                .year(2002));
+                .from(CriterionSatisfactionDAOTest.year(2002)));
-        assertThat(worker.getActiveCriterionsFor(type).size(), equalTo(1));
+        assertThat(worker.getCurrentCriterionsFor(type).size(), equalTo(1));
-        worker.activate(otherCriterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(otherCriterionWithItsType, Interval
-                .year(2000));
+                .from(CriterionSatisfactionDAOTest.year(2000)));
-        assertThat(worker.getActiveCriterionsFor(type).size(), equalTo(2));
+        assertThat(worker.getCurrentCriterionsFor(type).size(), equalTo(2));
     }
 
     public static CriterionTypeBase createTypeThatMatches(
@@ -152,23 +156,23 @@ public class ResourceTest {
                 createTypeThatMatches(otherCriterion), otherCriterion);
 
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval
-                .year(2000));
+                .from(CriterionSatisfactionDAOTest.year(2000)));
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval
-                .year(2003));
+                .from(CriterionSatisfactionDAOTest.year(2003)));
-        worker.activate(otherCriterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(otherCriterionWithItsType, Interval
-                .year(2000));
+                .from(CriterionSatisfactionDAOTest.year(2000)));
 
         assertEquals(2, worker.getSatisfactionsFor(criterionType).size());
-        assertEquals(1, worker.getActiveSatisfactionsForIn(criterionType,
+        assertEquals(1, worker.query().from(criterionType).enforcedInAll(
-                CriterionSatisfactionDAOTest.year(2001),
+                Interval.range(year(2001), year(2005))).current().result()
-                CriterionSatisfactionDAOTest.year(2005)).size());
+                .size());
-        assertEquals(2, worker.getActiveSatisfactionsForIn(criterionType,
+        assertEquals(2, worker.query().from(criterionType).enforcedInAll(
-                CriterionSatisfactionDAOTest.year(2004),
+                Interval.range(year(2004), year(2005))).current().result()
-                CriterionSatisfactionDAOTest.year(2005)).size());
+                .size());
-        assertEquals(0, worker.getActiveSatisfactionsForIn(criterionType,
+        assertEquals(0, worker.query().from(criterionType).enforcedInAll(
-                CriterionSatisfactionDAOTest.year(1999),
+                Interval.range(year(1999), year(2005))).current().result()
-                CriterionSatisfactionDAOTest.year(2005)).size());
+                .size());
     }
 
     @Test(expected = IllegalArgumentException.class)
@@ -180,114 +184,184 @@ public class ResourceTest {
     }
 
     @Test
-    public void testActivateAndDeactivateCriterion() {
+    public void testAddAndRemoveSatisfactions() {
         Criterion criterion = CriterionDAOTest.createValidCriterion();
         Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         ICriterionType<Criterion> criterionType = createTypeThatMatches(false,
                 criterion, otherCriterion);
-        assertThat(worker.getActiveSatisfactionsFor(criterion).size(),
+        assertThat(worker.getCurrentSatisfactionsFor(criterion).size(),
                 equalTo(0));
         assertFalse(criterion.isSatisfiedBy(worker));
-        assertTrue(worker.canBeActivated(new CriterionWithItsType(
+        Interval fromNow = Interval.from(new Date());
-                criterionType, criterion)));
+        assertTrue(worker.canAddSatisfaction(new CriterionWithItsType(
-        worker.activate(new CriterionWithItsType(criterionType, criterion));
+                criterionType, criterion), fromNow));
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
+                criterion), fromNow);
         assertTrue(criterion.isSatisfiedBy(worker));
-        assertThat(worker.getActiveSatisfactionsFor(criterion).size(),
+        assertThat(worker.getCurrentSatisfactionsFor(criterion).size(),
                 equalTo(1));
-        assertFalse(worker.canBeActivated(new CriterionWithItsType(
+        assertFalse(worker.canAddSatisfaction(new CriterionWithItsType(
-                criterionType, otherCriterion)));
+                criterionType, otherCriterion), fromNow));
         try {
-            worker.activate(new CriterionWithItsType(criterionType,
+            worker.addSatisfaction(new CriterionWithItsType(criterionType,
                     otherCriterion));
             fail("must send exception since it already is activated for a criterion of the same type and the type doesn't allow repeated criterions per resource");
         } catch (IllegalStateException e) {
             // ok
         }
-        assertTrue(worker.canBeActivated(new CriterionWithItsType(
+        assertThat(worker.query().from(criterionType).enforcedInAll(fromNow)
-                criterionType, criterion)));
+                .result().size(), equalTo(1));
-        assertThat(worker.getActiveSatisfactionsFor(criterion).size(),
+        List<CriterionSatisfaction> finished = worker.finishEnforcedAt(
-                equalTo(1));
+                new CriterionWithItsType(criterionType, criterion), fromNow
-        worker.deactivate(new CriterionWithItsType(criterionType, criterion));
+                        .getStart());
-        assertTrue("the satisfactions are deactivated", worker
+        assertThat(finished.size(), equalTo(1));
-                .getActiveSatisfactionsFor(criterion).isEmpty());
+        assertTrue("all satisfactions are finished", worker.query().from(
+                criterionType).enforcedInAll(fromNow).result().isEmpty());
+        assertTrue(worker.canAddSatisfaction(new CriterionWithItsType(
+                criterionType, criterion), fromNow));
     }
 
     @Test
-    public void testActivateInDate() throws Exception {
+    public void testAddAtDate() throws Exception {
         Criterion criterion = CriterionDAOTest.createValidCriterion();
         Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         ICriterionType<Criterion> criterionType = createTypeThatMatches(false,
                 criterion, otherCriterion);
-        worker.activate(new CriterionWithItsType(criterionType, criterion),
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
-                CriterionSatisfactionDAOTest.year(4000));
+                criterion), Interval.range(year(5000), year(6000)));
-        worker.activate(new CriterionWithItsType(criterionType, criterion),
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
-                CriterionSatisfactionDAOTest.year(5000),
+                criterion), Interval.from(year(4000)));
-                CriterionSatisfactionDAOTest.year(6000));
 
-        assertThat(worker.getActiveSatisfactionsForIn(criterion,
+        assertThat(worker.query().from(criterion).enforcedInAll(
-                CriterionSatisfactionDAOTest.year(4001),
+                Interval.range(year(4001), year(4999))).result().size(),
-                CriterionSatisfactionDAOTest.year(4999)).size(), equalTo(1));
+                equalTo(1));
-        assertThat(worker.getActiveSatisfactionsForIn(criterion,
+        assertThat(worker.query().from(criterion).enforcedInAll(
-                CriterionSatisfactionDAOTest.year(5001),
+                Interval.range(year(4001), year(5000))).result().size(),
-                CriterionSatisfactionDAOTest.year(5500)).size(), equalTo(1));
+                equalTo(0));
+        assertThat(worker.query().from(criterion).enforcedInAll(
+                Interval.range(year(5000), year(5001))).result().size(),
+                equalTo(1));
+        assertThat(worker.query().from(criterion).enforcedInAll(
+                Interval.range(year(5001), year(5500))).result().size(),
+                equalTo(1));
 
-        worker.deactivate(new CriterionWithItsType(criterionType, criterion));
+        worker.finish(new CriterionWithItsType(criterionType, criterion));
 
-        assertThat(worker.getActiveSatisfactionsForIn(criterion,
+        assertThat(worker.query().from(criterion).enforcedInAll(
-                CriterionSatisfactionDAOTest.year(4001),
+                Interval.range(year(4001), year(4999))).result().size(),
-                CriterionSatisfactionDAOTest.year(4999)).size(), equalTo(1));
+                equalTo(1));
-        assertThat(worker.getActiveSatisfactionsForIn(criterion,
+        assertThat(worker.query().from(criterion).enforcedInAll(
-                CriterionSatisfactionDAOTest.year(5001),
+                Interval.range(year(5001), year(5500))).result().size(),
-                CriterionSatisfactionDAOTest.year(5500)).size(), equalTo(1));
+                equalTo(1));
 
-        assertFalse(worker.canBeActivated(new CriterionWithItsType(
+        assertFalse(worker.canAddSatisfaction(new CriterionWithItsType(
-                criterionType, otherCriterion), CriterionSatisfactionDAOTest
+                criterionType, otherCriterion), Interval
-                .year(4001)));
+                .from(CriterionSatisfactionDAOTest.year(4001))));
     }
 
     @Test
     // when type doesnt allow multiple active criterions per resource
-    public void activateOnlyUntilNextCriterionIsActive() {
+    public void addOnlyUntilNextCriterionIsActive() {
         Criterion criterion = CriterionDAOTest.createValidCriterion();
         Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         ICriterionType<Criterion> criterionType = createTypeThatMatches(false,
                 criterion, otherCriterion);
-        worker.activate(new CriterionWithItsType(criterionType, criterion),
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
-                CriterionSatisfactionDAOTest.year(4000));
+                criterion), Interval.from(year(4000)));
-        worker.activate(
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
-                new CriterionWithItsType(criterionType, otherCriterion),
+                otherCriterion), Interval.from(year(3500)));
-                CriterionSatisfactionDAOTest.year(3500));
         assertThat(worker.getSatisfactionsFor(otherCriterion).size(),
                 equalTo(1));
         CriterionSatisfaction satisfaction = worker.getSatisfactionsFor(
                 otherCriterion).iterator().next();
-        assertThat(satisfaction.getEndDate(),
+        assertThat(satisfaction.getEndDate(), equalTo(year(4000)));
-                equalTo(CriterionSatisfactionDAOTest.year(4000)));
     }
 
     @Test(expected = IllegalStateException.class)
     // when type doesnt allow multiple active criterions per resource
-    public void deactivatePrevious() {
+    public void testCantAddOverlappingTotally() {
         Criterion criterion = CriterionDAOTest.createValidCriterion();
         Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         ICriterionType<Criterion> criterionType = createTypeThatMatches(false,
                 criterion, otherCriterion);
-        worker.activate(
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
-                new CriterionWithItsType(criterionType, otherCriterion),
+                otherCriterion), Interval.from(year(3500)));
-                CriterionSatisfactionDAOTest.year(3500));
+        assertFalse(worker.canAddSatisfaction(new CriterionWithItsType(
-        assertFalse(worker.canBeActivated(new CriterionWithItsType(
+                criterionType, criterion), Interval.range(year(4000),
-                criterionType, criterion), CriterionSatisfactionDAOTest
+                year(5000))));
-                .year(4000)));
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
-        worker.activate(new CriterionWithItsType(criterionType, criterion),
+                criterion), Interval.range(year(4000), year(5000)));
-                CriterionSatisfactionDAOTest.year(4000));
     }
 
     @Test(expected = IllegalStateException.class)
-    public void shouldntActivate() {
+    public void testCantAddIfOverlapsPartially() {
+        Criterion criterion = CriterionDAOTest.createValidCriterion();
+        Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
+        Worker worker = new Worker("firstName", "surName", "2333232", 10);
+        ICriterionType<Criterion> criterionType = createTypeThatMatches(false,
+                criterion, otherCriterion);
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
+                otherCriterion), Interval.range(year(3500), year(4500)));
+        assertFalse(worker.canAddSatisfaction(new CriterionWithItsType(
+                criterionType, criterion), Interval.range(year(3600),
+                year(3800))));
+        worker.addSatisfaction(new CriterionWithItsType(criterionType,
+                criterion), Interval.range(year(3600), year(3800)));
+    }
+
+    @Test
+    public void testCantAddWrongCriterionSatisfaction() {
+        Criterion criterion = CriterionDAOTest.createValidCriterion();
+        Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
+        Worker worker = new Worker("firstName", "surName", "2333232", 10);
+        Worker other = new Worker("other", "surName", "2333232", 10);
+        ICriterionType<Criterion> criterionType = createTypeThatMatches(false,
+                criterion);
+        List<CriterionSatisfaction> wrongSatisfactions = new ArrayList<CriterionSatisfaction>();
+        CriterionSatisfaction satisfaction = createValid(criterion, worker);
+        satisfaction.setResource(other);
+        wrongSatisfactions.add(satisfaction);
+        satisfaction = createValid(criterion, worker);
+        satisfaction.setResource(null);
+        wrongSatisfactions.add(satisfaction);
+        satisfaction = createValid(criterion, worker);
+        satisfaction.setCriterion(otherCriterion);
+        wrongSatisfactions.add(satisfaction);
+        for (CriterionSatisfaction wrong : wrongSatisfactions) {
+            try {
+                worker.addSatisfaction(criterionType, wrong);
+                fail("must send exception");
+            } catch (IllegalArgumentException e) {
+                // ok
+            }
+        }
+    }
+
+    public void testAddCriterionSatisfaction() throws Exception {
+        Criterion criterion = CriterionDAOTest.createValidCriterion();
+        Worker worker = new Worker("firstName", "surName", "2333232", 10);
+        ICriterionType<Criterion> criterionType = createTypeThatMatches(false,
+                criterion);
+        CriterionSatisfaction satisfaction = createValid(criterion, worker);
+        worker.addSatisfaction(criterionType, satisfaction);
+        assertThat(worker.getAllSatisfactions().size(), equalTo(1));
+    }
+
+    private CriterionSatisfaction createValid(Criterion criterion, Worker worker) {
+        CriterionSatisfaction satisfaction = new CriterionSatisfaction();
+        satisfaction.setResource(worker);
+        satisfaction.setStartDate(year(2000));
+        satisfaction.setCriterion(criterion);
+        satisfaction.setEndDate(year(2004));
+        return satisfaction;
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void shouldntAdd() {
         Criterion criterion = CriterionDAOTest.createValidCriterion();
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         ICriterionType<?> type = new CriterionTypeBase("prueba", false, false,
@@ -316,8 +390,9 @@ public class ResourceTest {
         };
         CriterionWithItsType criterionWithItsType = new CriterionWithItsType(
                 type, criterion);
-        assertFalse(worker.canBeActivated(criterionWithItsType));
+        assertFalse(worker.canAddSatisfaction(criterionWithItsType, Interval
-        worker.activate(criterionWithItsType);
+                .from(new Date())));
+        worker.addSatisfaction(criterionWithItsType);
     }
 
 }

navalplanner-business/src/test/java/org/navalplanner/business/test/resources/services/CriterionServiceTest.java

@@ -15,6 +15,7 @@ import org.navalplanner.business.resources.entities.CriterionWithItsType;
 import org.navalplanner.business.resources.entities.ICriterion;
 import org.navalplanner.business.resources.entities.ICriterionOnData;
 import org.navalplanner.business.resources.entities.ICriterionType;
+import org.navalplanner.business.resources.entities.Interval;
 import org.navalplanner.business.resources.entities.PredefinedCriterionTypes;
 import org.navalplanner.business.resources.entities.Resource;
 import org.navalplanner.business.resources.entities.Worker;
@@ -126,7 +127,7 @@ public class CriterionServiceTest {
         Criterion criterion = CriterionDAOTest.createValidCriterion();
         ICriterionType<?> type = createTypeThatMatches(criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        worker.activate(new CriterionWithItsType(type, criterion));
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion));
         assertTrue(criterion.isSatisfiedBy(worker));
         resourceService.saveResource(worker);
         assertTrue(criterion.isSatisfiedBy(worker));
@@ -141,7 +142,7 @@ public class CriterionServiceTest {
         criterionService.save(criterion);
         ICriterionType<?> type = createTypeThatMatches(criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        worker.activate(new CriterionWithItsType(type, criterion));
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion));
         assertTrue(criterion.isSatisfiedBy(worker));
         resourceService.saveResource(worker);
         assertTrue(criterion.isSatisfiedBy(worker));
@@ -155,7 +156,7 @@ public class CriterionServiceTest {
         ICriterionType<?> type = createTypeThatMatches(criterion);
         criterionService.save(criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
-        worker.activate(new CriterionWithItsType(type, criterion));
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion));
         resourceService.saveResource(worker);
         assertThat(criterionService.getResourcesSatisfying(criterion).size(),
                 equalTo(1));
@@ -170,7 +171,7 @@ public class CriterionServiceTest {
         ICriterionType<?> type = createTypeThatMatches(criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         resourceService.saveResource(worker);
-        worker.activate(new CriterionWithItsType(type, criterion));
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion));
         assertEquals(1, criterionService.getResourcesSatisfying(criterion)
                 .size());
     }
@@ -191,7 +192,7 @@ public class CriterionServiceTest {
         ICriterionType<Criterion> type = createTypeThatMatches(criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         resourceService.saveResource(worker);
-        worker.activate(new CriterionWithItsType(type, criterion));
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion));
 
         assertThat(criterionService.getResourcesSatisfying(Resource.class,
                 criterion).size(), is(1));
@@ -208,8 +209,7 @@ public class CriterionServiceTest {
         criterionService.save(criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         resourceService.saveResource(worker);
-        worker.activate(new CriterionWithItsType(type, criterion),
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion), Interval.from(CriterionSatisfactionDAOTest.year(2000)));
-                CriterionSatisfactionDAOTest.year(2000));
         ICriterionOnData criterionOnData = criterionService.empower(criterion);
         assertTrue(criterionOnData.isSatisfiedBy(worker));
         assertEquals(1, criterionOnData.getResourcesSatisfying().size());
@@ -232,7 +232,7 @@ public class CriterionServiceTest {
         Criterion criterion = CriterionDAOTest.createValidCriterion();
         criterionService.save(criterion);
         ICriterionType<?> type = createTypeThatMatches(criterion);
-        worker1.activate(new CriterionWithItsType(type, criterion));
+        worker1.addSatisfaction(new CriterionWithItsType(type, criterion));
         resourceService.saveResource(worker1);
         Resource workerReloaded = criterionService
                 .onTransaction(new OnTransaction<Resource>() {
@@ -266,8 +266,7 @@ public class CriterionServiceTest {
         criterionService.save(criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         resourceService.saveResource(worker);
-        worker.activate(new CriterionWithItsType(type, criterion),
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion), Interval.from(CriterionSatisfactionDAOTest.year(2000)));
-                CriterionSatisfactionDAOTest.year(2000));
         ICriterionOnData criterionOnData = criterionService.empower(criterion);
         criterionOnData.getResourcesSatisfying();
         criterionOnData.getResourcesSatisfying(CriterionSatisfactionDAOTest
@@ -292,8 +291,8 @@ public class CriterionServiceTest {
                 type, criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         resourceService.saveResource(worker);
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval.from(CriterionSatisfactionDAOTest
-                .year(2000));
+        .year(2000)));
 
         assertEquals(1, criterionService.getResourcesSatisfying(criterion,
                 CriterionSatisfactionDAOTest.year(2001),
@@ -302,8 +301,7 @@ public class CriterionServiceTest {
                 CriterionSatisfactionDAOTest.year(1999),
                 CriterionSatisfactionDAOTest.year(2005)).size());
 
-        worker.activate(new CriterionWithItsType(type, criterion),
+        worker.addSatisfaction(new CriterionWithItsType(type, criterion), Interval.from(CriterionSatisfactionDAOTest.year(1998)));
-                CriterionSatisfactionDAOTest.year(1998));
 
         assertEquals(1, criterionService.getResourcesSatisfying(criterion,
                 CriterionSatisfactionDAOTest.year(1999),
@@ -319,10 +317,10 @@ public class CriterionServiceTest {
         criterionService.save(criterion);
         Worker worker = new Worker("firstName", "surName", "2333232", 10);
         resourceService.saveResource(worker);
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval.from(CriterionSatisfactionDAOTest
-                .year(2000));
+        .year(2000)));
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval.from(CriterionSatisfactionDAOTest
-                .year(1998));
+        .year(1998)));
 
         ICriterionType<?> criterionType = ResourceTest
                 .createTypeThatMatches(criterion);
@@ -337,8 +335,8 @@ public class CriterionServiceTest {
                 CriterionSatisfactionDAOTest.year(1997),
                 CriterionSatisfactionDAOTest.year(2005)).size());
 
-        worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
+        worker.addSatisfaction(criterionWithItsType, Interval.from(CriterionSatisfactionDAOTest
-                .year(1997));
+        .year(1997)));
         assertEquals(2, criterionService.getSatisfactionsFor(criterionType,
                 CriterionSatisfactionDAOTest.year(1999),
                 CriterionSatisfactionDAOTest.year(2005)).size());
@@ -363,18 +361,18 @@ public class CriterionServiceTest {
     }
 
     public static ICriterionType<Criterion> createTypeThatMatches(
-            final boolean allowMultipleActiveCriterionsPerResource,
+            final boolean allowSimultaneousCriterionsPerResource,
             final Criterion criterion) {
         return new ICriterionType<Criterion>() {
 
             @Override
-            public boolean allowHierarchy() {
+            public boolean allowSimultaneousCriterionsPerResource() {
-                return false;
+                return allowSimultaneousCriterionsPerResource;
             }
 
             @Override
-            public boolean allowMultipleActiveCriterionsPerResource() {
+            public boolean allowHierarchy() {
-                return allowMultipleActiveCriterionsPerResource;
+                return false;
             }
 
             @Override

navalplanner-business/src/test/java/org/navalplanner/business/test/resources/services/ResourceServiceTest.java

@@ -138,7 +138,7 @@ public class ResourceServiceTest {
         criterionService.save(criterion);
         ICriterionType<Criterion> type = CriterionServiceTest
                 .createTypeThatMatches(criterion);
-        worker1.activate(new CriterionWithItsType(type, criterion));
+        worker1.addSatisfaction(new CriterionWithItsType(type, criterion));
         resourceService.saveResource(worker1);
         assertThat(worker1.getVersion(), not(equalTo(versionValueAfterSave)));
     }

navalplanner-webapp/src/main/java/org/navalplanner/web/resources/criterion/CriterionsModel.java

@@ -126,7 +126,7 @@ public class CriterionsModel implements ICriterionsModel {
     @Override
     public boolean isChangeAssignmentsDisabled() {
         return criterionType == null
-                || !criterionType.allowMultipleActiveCriterionsPerResource();
+                || !criterionType.allowSimultaneousCriterionsPerResource();
     }
 
     @Override
@@ -135,7 +135,7 @@ public class CriterionsModel implements ICriterionsModel {
         for (Resource resource : resources) {
             Resource reloaded = find(resource.getId());
             reloaded
-                    .activate(new CriterionWithItsType(criterionType, criterion));
+                    .addSatisfaction(new CriterionWithItsType(criterionType, criterion));
             resourceService.saveResource(reloaded);
         }
     }
@@ -145,7 +145,7 @@ public class CriterionsModel implements ICriterionsModel {
     public void deactivateAll(Collection<? extends Resource> resources) {
         for (Resource resource : resources) {
             Resource reloaded = find(resource.getId());
-            reloaded.deactivate(new CriterionWithItsType(criterionType,
+            reloaded.finish(new CriterionWithItsType(criterionType,
                     criterion));
             resourceService.saveResource(reloaded);
         }

navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/WorkRelationshipsController.java

@@ -1,26 +1,22 @@
 package org.navalplanner.web.resources.worker;
 
-import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.Map.Entry;
 
-import java.util.logging.Level;
-import java.util.logging.Logger;
 import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
 import org.navalplanner.business.resources.entities.Criterion;
 import org.navalplanner.business.resources.entities.CriterionSatisfaction;
 import org.navalplanner.business.resources.entities.CriterionWithItsType;
 import org.navalplanner.business.resources.entities.ICriterionType;
+import org.navalplanner.business.resources.entities.Interval;
 import org.navalplanner.business.resources.entities.Worker;
 import org.zkoss.zk.ui.Component;
 import org.zkoss.zk.ui.util.GenericForwardComposer;
-import org.zkoss.zul.Datebox;
 import org.zkoss.zul.Listbox;
 
 /**
@@ -33,7 +29,10 @@ public class WorkRelationshipsController extends GenericForwardComposer {
 
     private WorkerCRUDController workerCRUDController;
 
-/*    private CriterionSatisfaction newRelationship = new CriterionSatisfaction(); */
+    /*
+     * private CriterionSatisfaction newRelationship = new
+     * CriterionSatisfaction();
+     */
 
     private CriterionSatisfaction editRelationship = new CriterionSatisfaction();
 
@@ -41,21 +40,26 @@ public class WorkRelationshipsController extends GenericForwardComposer {
 
     private Listbox selectedWorkCriterion;
 
-/*    private Datebox newWorkRelationshipStartDate;
+    /*
-
+     * private Datebox newWorkRelationshipStartDate;
-    private Datebox newWorkRelationshipEndDate; */
+     * 
+     * private Datebox newWorkRelationshipEndDate;
+     */
 
     private HashMap<Criterion, CriterionWithItsType> fromCriterionToType;
 
+    private boolean editing;
+
     public WorkRelationshipsController(IWorkerModel workerModel,
             WorkerCRUDController workerCRUDController) {
         this.workerModel = workerModel;
         this.workerCRUDController = workerCRUDController;
         this.workCriterions = new ArrayList<Criterion>();
-        Map<ICriterionType<?>, Collection<Criterion>> map =
+        Map<ICriterionType<?>, Collection<Criterion>> map = workerModel
-                workerModel.getLaboralRelatedCriterions();
+                .getLaboralRelatedCriterions();
         this.fromCriterionToType = new HashMap<Criterion, CriterionWithItsType>();
-        for (Entry<ICriterionType<?>, Collection<Criterion>> entry : map.entrySet()) {
+        for (Entry<ICriterionType<?>, Collection<Criterion>> entry : map
+                .entrySet()) {
             this.workCriterions.addAll(entry.getValue());
             for (Criterion criterion : entry.getValue()) {
                 this.fromCriterionToType.put(criterion,
@@ -68,66 +72,53 @@ public class WorkRelationshipsController extends GenericForwardComposer {
         if (this.workerCRUDController.getWorker() == null) {
             return new HashSet<CriterionSatisfaction>();
         } else {
-            return workerModel.getLaboralRelatedCriterionSatisfactions(
+            return workerModel
-                    this.workerCRUDController.getWorker());
+                    .getLaboralRelatedCriterionSatisfactions(this.workerCRUDController
+                            .getWorker());
         }
     }
 
     public void deleteCriterionSatisfaction(CriterionSatisfaction satisfaction)
             throws InstanceNotFoundException {
-        workerCRUDController.getWorker().removeCriterionSatisfaction(satisfaction);
+        workerCRUDController.getWorker().removeCriterionSatisfaction(
+                satisfaction);
         this.workerCRUDController.goToEditForm();
     }
 
-    public void setEditCriterionSatisfaction(CriterionSatisfaction crit) {
+    public void prepareForCreate() {
-        // the component should be preselected.
+        this.editRelationship = new CriterionSatisfaction();
-        this.editRelationship = crit;
+        editing = false;
+    }
+
+    public void prepareForEdit(CriterionSatisfaction criterionSatisfaction) {
+        this.editRelationship = criterionSatisfaction;
+        editing = true;
     }
 
     public void saveCriterionSatisfaction() throws InstanceNotFoundException {
 
         // Add new criterion
-        Criterion selectedCriterion = (Criterion) selectedWorkCriterion.getSelectedItem().getValue();
+        Criterion selectedCriterion = (Criterion) selectedWorkCriterion
-        CriterionWithItsType criterionWithItsType = fromCriterionToType.get(selectedCriterion);
+                .getSelectedItem().getValue();
-        System.out.println( "SAVE!!: " + selectedCriterion.getName() );
+        CriterionWithItsType criterionWithItsType = fromCriterionToType
-
+                .get(selectedCriterion);
-        if (editRelationship.getStartDate() == null) {
+        System.out.println("SAVE!!: " + selectedCriterion.getName());
-            this.workerCRUDController.getWorker().activate(
+        if (this.workerCRUDController.getWorker().contains(editRelationship)) {
-                    criterionWithItsType,
+            this.workerCRUDController.getWorker().removeCriterionSatisfaction(
-                    editRelationship.getStartDate());
+                    editRelationship);
-        } else {
-            this.workerCRUDController.getWorker().activate(
-                    criterionWithItsType,
-                    editRelationship.getStartDate(),
-                    editRelationship.getEndDate());
         }
+        this.workerCRUDController.getWorker().addSatisfaction(
+                criterionWithItsType,
+                Interval.range(editRelationship.getStartDate(),
+                        editRelationship.getEndDate()));
 
         // Delete the former one
-        workerCRUDController.getWorker().
+        workerCRUDController.getWorker().removeCriterionSatisfaction(
-                removeCriterionSatisfaction(this.editRelationship);
+                this.editRelationship);
 
         this.workerCRUDController.goToEditForm();
     }
 
-    public void addCriterionSatisfaction() {
-        Criterion selectedCriterion = (Criterion) selectedWorkCriterion.getSelectedItem().getValue();
-        CriterionWithItsType criterionWithItsType = fromCriterionToType.get(selectedCriterion);
-        // never accessed: Unnecesary as edition does this.
-        System.out.println( "SELECTED: " + criterionWithItsType.toString() );
-
-        if (editRelationship.getStartDate() == null) {
-            this.workerCRUDController.getWorker().activate(
-                    criterionWithItsType,
-                    editRelationship.getStartDate());
-        } else {
-            this.workerCRUDController.getWorker().activate(
-                    criterionWithItsType,
-                    editRelationship.getStartDate(),
-                    editRelationship.getEndDate());
-        }
-        this.workerCRUDController.goToEditForm();
-    }
-
     @Override
     public void doAfterCompose(Component comp) throws Exception {
         super.doAfterCompose(comp);
@@ -142,4 +133,8 @@ public class WorkRelationshipsController extends GenericForwardComposer {
         return this.workCriterions;
     }
 
+    public boolean isEditing() {
+        return editing;
+    }
+
 }

navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/WorkerCRUDController.java

@@ -1,17 +1,11 @@
 package org.navalplanner.web.resources.worker;
 
-import java.util.Date;
 import java.util.List;
 
 import org.hibernate.validator.InvalidValue;
 import org.navalplanner.business.common.exceptions.ValidationException;
-import org.navalplanner.business.resources.entities.Criterion;
 import org.navalplanner.business.resources.entities.CriterionSatisfaction;
-import org.navalplanner.business.resources.entities.CriterionTypeBase;
-import org.navalplanner.business.resources.entities.CriterionWithItsType;
-import org.navalplanner.business.resources.entities.PredefinedCriterionTypes;
 import org.navalplanner.business.resources.entities.Worker;
-import org.navalplanner.business.resources.entities.WorkingRelationship;
 import org.navalplanner.business.resources.services.CriterionService;
 import org.navalplanner.web.common.IMessagesForUser;
 import org.navalplanner.web.common.Level;
@@ -53,7 +47,7 @@ public class WorkerCRUDController extends GenericForwardComposer implements
 
     private Component messagesContainer;
 
-    private WorkRelationshipsController workRelationship;
+    private WorkRelationshipsController addWorkRelationship;
 
     private LocalizationsController localizationsForEditionController;
 
@@ -61,13 +55,16 @@ public class WorkerCRUDController extends GenericForwardComposer implements
 
     private CriterionService criterionService;
 
+    private WorkRelationshipsController editWorkRelationship;
+
     public WorkerCRUDController() {
     }
 
     public WorkerCRUDController(Window createWindow, Window listWindow,
             Window editWindow, Window workRelationshipsWindow,
-            Window addWorkRelationshipWindow, Window editWorkRelationshipWindow,
+            Window addWorkRelationshipWindow,
-            IWorkerModel workerModel, IMessagesForUser messages) {
+            Window editWorkRelationshipWindow, IWorkerModel workerModel,
+            IMessagesForUser messages) {
         this.createWindow = createWindow;
         this.listWindow = listWindow;
         this.editWindow = editWindow;
@@ -131,24 +128,9 @@ public class WorkerCRUDController extends GenericForwardComposer implements
     }
 
     public void goToAddWorkRelationshipForm() {
-       Criterion selectedCriterion = criterionService.load(
+        this.addWorkRelationship.prepareForCreate();
-               WorkingRelationship.HIRED.criterion());
-       CriterionWithItsType criteriontype = new CriterionWithItsType(
-               PredefinedCriterionTypes.WORK_RELATIONSHIP, selectedCriterion);
-       this.workerModel.getWorker().activate(criteriontype,new Date());
-       /* CriterionSatisfaction newSatisfaction =
-                new CriterionSatisfaction(
-                    new Date(),
-                    selectedCriterion,
-                    this.workerModel.getWorker()); */
-       CriterionSatisfaction newSatisfaction =
-               this.workerModel.getWorker().
-                getActiveSatisfactionsFor(selectedCriterion).iterator().next();
-        this.workRelationship.setEditCriterionSatisfaction(newSatisfaction);
         getVisibility().showOnly(addWorkRelationshipWindow);
         Util.reloadBindings(addWorkRelationshipWindow);
-//        getVisibility().showOnly(editWorkRelationshipWindow);
-//        Util.reloadBindings(editWorkRelationshipWindow);
     }
 
     public void goToCreateForm() {
@@ -158,7 +140,7 @@ public class WorkerCRUDController extends GenericForwardComposer implements
     }
 
     public void goToEditWorkRelationshipForm(CriterionSatisfaction satisfaction) {
-        this.workRelationship.setEditCriterionSatisfaction(satisfaction);
+        this.editWorkRelationship.prepareForEdit(satisfaction);
         getVisibility().showOnly(editWorkRelationshipWindow);
         Util.reloadBindings(editWorkRelationshipWindow);
     }
@@ -175,15 +157,27 @@ public class WorkerCRUDController extends GenericForwardComposer implements
         if (messagesContainer == null)
             throw new RuntimeException("messagesContainer is needed");
         messages = new MessagesForUser(messagesContainer);
-        this.workRelationship =
+        this.addWorkRelationship = new WorkRelationshipsController(
-                 new WorkRelationshipsController(this.workerModel,this);
+                this.workerModel, this);
-        this.workRelationship.doAfterCompose(
+        setupWorkRelationshipController(this.addWorkRelationship,
-                comp.getFellow("addWorkRelationshipWindow"));
+                this.addWorkRelationshipWindow);
-         URLHandler<IWorkerCRUDControllerEntryPoints> handler = URLHandlerRegistry
+        setupWorkRelationshipController(
+                this.editWorkRelationship = new WorkRelationshipsController(
+                        this.workerModel, this), editWorkRelationshipWindow);
+
+        URLHandler<IWorkerCRUDControllerEntryPoints> handler = URLHandlerRegistry
                 .getRedirectorFor(IWorkerCRUDControllerEntryPoints.class);
         handler.applyIfMatches(this);
     }
 
+    private void setupWorkRelationshipController(
+            WorkRelationshipsController workRelationshipController,
+            Window workRelationshipWindow) throws Exception {
+        workRelationshipController.doAfterCompose(workRelationshipWindow);
+        workRelationshipWindow.setVariable("workRelationship",
+                workRelationshipController, true);
+    }
+
     private LocalizationsController createLocalizationsController(
             Component comp, String localizationsContainerName) throws Exception {
         LocalizationsController localizationsController = new LocalizationsController(
@@ -198,13 +192,13 @@ public class WorkerCRUDController extends GenericForwardComposer implements
         if (visibility == null) {
             visibility = new OnlyOneVisible(listWindow, editWindow,
                     createWindow, workRelationshipsWindow,
-                   addWorkRelationshipWindow, editWorkRelationshipWindow );
+                    addWorkRelationshipWindow, editWorkRelationshipWindow);
         }
         return visibility;
     }
 
     public GenericForwardComposer getWorkRelationship() {
-        return this.workRelationship;
+        return this.addWorkRelationship;
     }
 
 }

navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/WorkerModel.java

@@ -19,6 +19,7 @@ import org.navalplanner.business.resources.entities.Criterion;
 import org.navalplanner.business.resources.entities.CriterionSatisfaction;
 import org.navalplanner.business.resources.entities.CriterionWithItsType;
 import org.navalplanner.business.resources.entities.ICriterionType;
+import org.navalplanner.business.resources.entities.Interval;
 import org.navalplanner.business.resources.entities.PredefinedCriterionTypes;
 import org.navalplanner.business.resources.entities.Resource;
 import org.navalplanner.business.resources.entities.Worker;
@@ -165,7 +166,7 @@ public class WorkerModel implements IWorkerModel {
                 ICriterionType<?> type) {
             Validate
                     .isTrue(
-                            type.allowMultipleActiveCriterionsPerResource(),
+                            type.allowSimultaneousCriterionsPerResource(),
                             "must allow multiple active criterions for this type to use this assignment strategy");
             this.criterionService = criterionService;
             this.resource = resource;
@@ -197,13 +198,13 @@ public class WorkerModel implements IWorkerModel {
 
         private HashSet<CriterionSatisfaction> calculateInitialActive() {
             return new HashSet<CriterionSatisfaction>(resource
-                    .getActiveSatisfactionsFor(type));
+                    .getCurrentSatisfactionsFor(type));
         }
 
         private List<Criterion> calculateInitialCriterionsNotAssigned() {
             Map<Long, Criterion> allCriterions = byId(criterionService
                     .getCriterionsFor(type));
-            for (Long activeId : asIds(resource.getActiveCriterionsFor(type))) {
+            for (Long activeId : asIds(resource.getCurrentCriterionsFor(type))) {
                 allCriterions.remove(activeId);
             }
             return new ArrayList<Criterion>(allCriterions.values());
@@ -250,12 +251,11 @@ public class WorkerModel implements IWorkerModel {
         @Override
         public void applyChanges() {
             for (CriterionSatisfaction criterionSatisfaction : added) {
-                resource.activate(new CriterionWithItsType(type,
+                resource.addSatisfaction(new CriterionWithItsType(type,
-                        criterionSatisfaction.getCriterion()),
+                criterionSatisfaction.getCriterion()), Interval.from(criterionSatisfaction.getStartDate()));
-                        criterionSatisfaction.getStartDate());
             }
             for (Criterion criterion : unassigned.keySet()) {
-                resource.deactivate(new CriterionWithItsType(type, criterion));
+                resource.finish(new CriterionWithItsType(type, criterion));
             }
         }
     }

navalplanner-webapp/src/main/webapp/resources/worker/_editWorkRelationship.zul

@@ -1,5 +1,4 @@
-<window id="${arg.top_id}" title="${arg.title}"
+<window id="${arg.top_id}" title="${arg.title}">
-    apply="${controller.workRelationshipsController}">
     <grid id="edit">
 		<columns>
 			<column label="Date start"/>
@@ -9,11 +8,11 @@
         <rows>
 			<row>
 				<datebox id="editWorkRelationshipStartDate" width="180px"
-                    value="@{controller.workRelationship.editRelationship.startDate}" />
+                    value="@{workRelationship.editRelationship.startDate}" />
 				<datebox id="editWorkRelationshipEndDate" width="180px"
-                    value="@{controller.workRelationship.editRelationship.endDate}" />
+                    value="@{workRelationship.editRelationship.endDate}" />
                 <listbox onSelect="" mold="select" rows="1" id="selectedWorkCriterion"
-                    model="@{controller.workRelationship.workCriterions}">
+                    model="@{workRelationship.workCriterions}" disabled="@{! workRelationship.editing}">
                         <listitem self="@{each='workCriterion'}"
                             label="@{workCriterion.name}"
                             value="@{workCriterion}" />
@@ -21,7 +20,7 @@
 			</row>
 		</rows>
       </grid>
-    <button onClick="controller.workRelationship.saveCriterionSatisfaction();"
+    <button onClick="workRelationship.saveCriterionSatisfaction();"
         label="Save Work Relationship" />
     <button onClick="controller.goToEditForm()"
         label="Cancel and back to Work Relationships"/>