RenJuan/TASKPM
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ItEr09S09AdministracionGrupos: Refactored bussiness layer so it follows ICriterionType restrictions when saving.

Browse source
This commit is contained in:
Óscar González Fernández 2009-05-21 13:59:45 +02:00 • committed by Javier Moran Rua
parent d22215fad8
commit e797f6e350
19 changed files with 616 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
navalplanner-business/src/main/java/org/navalplanner/business/resources/bootstrap/CriterionsBootstrap.java
View file

@ -6,13 +6,13 @@ import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.navalplanner.business.IDataBootstrap;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.ICriterionType;
import org.navalplanner.business.resources.services.CriterionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
/**
* Loads all {@link ICriterionTypeProvider} and if there is any criterion that
@ -21,7 +21,7 @@ import org.springframework.stereotype.Component;
*/
@Component
@Scope("singleton")
public class CriterionsBootstrap implements IDataBootstrap {
public class CriterionsBootstrap implements ICriterionsBootstrap {
@Autowired
private CriterionService criterionService;
@ -29,6 +29,9 @@ public class CriterionsBootstrap implements IDataBootstrap {
@Autowired
private List<ICriterionTypeProvider> providers;
public CriterionsBootstrap() {
}
public List<ICriterionType<?>> getTypes() {
ArrayList<ICriterionType<?>> result = new ArrayList<ICriterionType<?>>();
for (ICriterionTypeProvider provider : providers) {
@ -38,6 +41,7 @@ public class CriterionsBootstrap implements IDataBootstrap {
}
@Override
@Transactional
public void loadRequiredData() {
Map<ICriterionType<?>, List<Criterion>> typesWithCriterions = getTypesWithCriterions();
for (Entry<ICriterionType<?>, List<Criterion>> entry : typesWithCriterions
@ -48,7 +52,7 @@ public class CriterionsBootstrap implements IDataBootstrap {
}
}
public Map<ICriterionType<?>, List<Criterion>> getTypesWithCriterions() {
private Map<ICriterionType<?>, List<Criterion>> getTypesWithCriterions() {
HashMap<ICriterionType<?>, List<Criterion>> result = new HashMap<ICriterionType<?>, List<Criterion>>();
for (ICriterionTypeProvider provider : providers) {
for (Entry<ICriterionType<?>, List<Criterion>> entry : provider

18
navalplanner-business/src/main/java/org/navalplanner/business/resources/bootstrap/ICriterionsBootstrap.java Normal file
View file

@ -0,0 +1,18 @@
package org.navalplanner.business.resources.bootstrap;
import java.util.List;
import org.navalplanner.business.IDataBootstrap;
import org.navalplanner.business.resources.entities.ICriterionType;
/**
* Contract for {@link CriterionsBootstrap}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface ICriterionsBootstrap extends IDataBootstrap {
public abstract List<ICriterionType<?>> getTypes();
public abstract void loadRequiredData();
}

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

@ -30,7 +30,6 @@ public class CriterionSatisfaction {
this.startDate = startDate;
this.criterion = criterion;
this.resource = resource;
this.resource.add(this);
}
public Long getId() {
@ -62,21 +61,28 @@ public class CriterionSatisfaction {
}
public boolean isActiveNow() {
return startDate.before(new Date()) && finishDate == null;
Date now = new Date();
return isActiveAt(now);
}
public boolean isActiveAt(Date date) {
return (startDate.before(date) || startDate.equals(date))
&& (finishDate == null || date.before(finishDate));
}
public boolean isActiveIn(Date start, Date end) {
return startDate.before(start)
return (startDate.equals(start) || startDate.before(start))
&& (finishDate == null || end.before(finishDate));
}
public void finish(Date finish) {
Validate.notNull(finish);
Validate.isTrue(startDate.before(finish));
Validate.isTrue(startDate.equals(finish) || startDate.before(finish));
finishDate = finish;
}
public boolean isFinished() {
return finishDate != null;
}
}

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

@ -10,7 +10,7 @@ public abstract class CriterionTypeBase implements ICriterionType<Criterion> {
private final boolean allowHierarchy;
private final boolean allowMultipleValuesPerResource;
private final boolean allowMultipleCriterionsPerResource;
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 allowMultipleValuesPerResource, boolean allowAdding,
boolean allowMultipleCriterionsPerResource, boolean allowAdding,
boolean allowEditing) {
Validate.notNull(name, "name is not null");
this.allowHierarchy = allowHierarchy;
this.allowMultipleValuesPerResource = allowMultipleValuesPerResource;
this.allowMultipleCriterionsPerResource = allowMultipleCriterionsPerResource;
this.name = name;
this.allowAdding = allowAdding;
this.allowEditing = allowEditing;
@ -36,7 +36,7 @@ public abstract class CriterionTypeBase implements ICriterionType<Criterion> {
@Override
public boolean allowMultipleActiveCriterionsPerResource() {
return allowMultipleValuesPerResource;
return allowMultipleCriterionsPerResource;
}
public String getName() {

31
navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/CriterionWithItsType.java Normal file
View file

@ -0,0 +1,31 @@
package org.navalplanner.business.resources.entities;
import org.apache.commons.lang.Validate;
/**
* A {@link ICriterion} with his associated {@link ICriterionType} <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class CriterionWithItsType {
private final ICriterionType<?> type;
private final Criterion criterion;
public CriterionWithItsType(ICriterionType<?> type, Criterion criterion) {
Validate.notNull(type);
Validate.notNull(criterion);
Validate.isTrue(type.contains(criterion),
"the criterion must be belong to the type");
this.type = type;
this.criterion = criterion;
}
public ICriterionType<?> getType() {
return type;
}
public Criterion getCriterion() {
return criterion;
}
}

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

@ -20,4 +20,6 @@ public interface ICriterionType<C extends ICriterion> {
public boolean contains(ICriterion criterion);
public boolean criterionCanBeRelatedTo(Class<? extends Resource> klass);
}

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

@ -9,13 +9,13 @@ import java.util.List;
*/
public enum PredefinedCriterionTypes implements ICriterionType<Criterion> {
WORK_RELATIONSHIP(false, false, false, false) {
WORK_RELATIONSHIP(false, false, false, false, Worker.class) {
@Override
public List<Criterion> getPredefined() {
return WorkingRelationship.getCriterions();
}
},
LOCATION_GROUP(false, true, true, true) {
LOCATION_GROUP(false, true, true, true, Resource.class) {
@Override
public List<Criterion> getPredefined() {
@ -31,13 +31,26 @@ public enum PredefinedCriterionTypes implements ICriterionType<Criterion> {
private final boolean allowEditing;
private List<Class<? extends Resource>> classes;
private PredefinedCriterionTypes(boolean allowHierarchy,
boolean allowMultipleActiveCriterionsPerResource,
boolean allowAdding, boolean allowEditing) {
boolean allowAdding, boolean allowEditing,
Class<? extends Resource>... klasses) {
this.allowHierarchy = allowHierarchy;
this.allowMultipleActiveCriterionsPerResource = allowMultipleActiveCriterionsPerResource;
this.allowAdding = allowAdding;
this.allowEditing = allowEditing;
this.classes = Arrays.asList(klasses);
}
@Override
public boolean criterionCanBeRelatedTo(Class<? extends Resource> klass) {
for (Class<? extends Resource> c : classes) {
if (c.isAssignableFrom(klass))
return true;
}
return false;
}
@Override

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

@ -1,10 +1,12 @@
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.List;
import java.util.Set;
import org.apache.commons.lang.Validate;
@ -69,6 +71,16 @@ public abstract class Resource {
return result;
}
public List<CriterionSatisfaction> getSatisfactionsFor(ICriterion criterion) {
ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
for (CriterionSatisfaction criterionSatisfaction : getAllSatisfactions()) {
if (criterionSatisfaction.getCriterion().equals(criterion)) {
result.add(criterionSatisfaction);
}
}
return result;
}
public Collection<CriterionSatisfaction> getActiveSatisfactionsFor(
ICriterionType<?> criterionType) {
Collection<CriterionSatisfaction> satisfactionsFor = getSatisfactionsFor(criterionType);
@ -84,17 +96,24 @@ public abstract class Resource {
public Collection<CriterionSatisfaction> getActiveSatisfactionsForIn(
ICriterionType<?> criterionType, Date start, Date end) {
Validate.notNull(criterionType);
Validate.isTrue(start.before(end));
Validate.isTrue(end == null || start.before(end));
Collection<CriterionSatisfaction> satisfactionsFor = getSatisfactionsFor(criterionType);
ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
for (CriterionSatisfaction criterionSatisfaction : satisfactionsFor) {
if (criterionSatisfaction.isActiveIn(start, end)) {
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>();
@ -119,7 +138,7 @@ public abstract class Resource {
public Collection<CriterionSatisfaction> getActiveSatisfactionsForIn(
ICriterion criterion, Date start, Date end) {
Validate.isTrue(start.before(end));
Validate.isTrue(end == null || start.before(end));
ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
Collection<CriterionSatisfaction> allSatisfactionsFor = getAllSatisfactionsFor(criterion);
for (CriterionSatisfaction criterionSatisfaction : allSatisfactionsFor) {
@ -130,10 +149,109 @@ public abstract class Resource {
return result;
}
void add(CriterionSatisfaction criterionSatisfaction) {
Validate.notNull(criterionSatisfaction,
"criterionSatisfaction must be not null");
criterionSatisfactions.add(criterionSatisfaction);
public void activate(CriterionWithItsType criterionWithItsType) {
activate(criterionWithItsType, new Date());
}
public void activate(CriterionWithItsType criterionWithItsType, Date start) {
activate(criterionWithItsType, start, null);
}
public void activate(CriterionWithItsType criterionWithItsType, Date start,
Date finish) {
ICriterionType<?> type = criterionWithItsType.getType();
Criterion criterion = criterionWithItsType.getCriterion();
if (canBeActivated(criterionWithItsType, start, finish)) {
CriterionSatisfaction newSatisfaction = new CriterionSatisfaction(
start, criterion, this);
criterionSatisfactions.add(newSatisfaction);
if (finish != null)
newSatisfaction.finish(finish);
if (!type.allowMultipleActiveCriterionsPerResource()) {
for (CriterionSatisfaction criterionSatisfaction : getActiveSatisfactionsAt(
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(
Set<CriterionSatisfaction> posterior) {
Date earliest = null;
for (CriterionSatisfaction criterionSatisfaction : posterior) {
if (earliest == null)
earliest = criterionSatisfaction.getStartDate();
earliest = Collections.min(Arrays.asList(earliest,
criterionSatisfaction.getStartDate()));
}
return earliest;
}
private Set<CriterionSatisfaction> getSatisfactionsPosteriorTo(
ICriterionType<?> type, CriterionSatisfaction newSatisfaction) {
Date start = newSatisfaction.getStartDate();
Date finish = newSatisfaction.isFinished() ? newSatisfaction
.getEndDate() : null;
Set<CriterionSatisfaction> posterior = new HashSet<CriterionSatisfaction>();
if (finish != null) {
posterior.addAll(getActiveSatisfactionsAt(type, finish));
} else {
ArrayList<CriterionSatisfaction> result = new ArrayList<CriterionSatisfaction>();
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,
Date start, Date end) {
ICriterionType<?> type = criterionWithItsType.getType();
Criterion criterion = criterionWithItsType.getCriterion();
return getActiveSatisfactionsForIn(type, start, end).size() == getActiveSatisfactionsForIn(
criterion, start, end).size();
}
public boolean canBeActivated(CriterionWithItsType criterionWithItsType) {
return canBeActivated(criterionWithItsType, new Date());
}
public boolean canBeActivated(CriterionWithItsType criterionWithItsType,
Date start) {
return canBeActivated(criterionWithItsType, start, null);
}
public boolean canBeActivated(CriterionWithItsType criterionWithItsType,
Date start, Date finish) {
ICriterionType<?> type = criterionWithItsType.getType();
return type.criterionCanBeRelatedTo(getClass())
&& (type.allowMultipleActiveCriterionsPerResource() || noneOf(
criterionWithItsType, start, finish));
}
}

9
navalplanner-business/src/main/java/org/navalplanner/business/resources/services/CriterionService.java
View file

@ -13,7 +13,7 @@ import org.navalplanner.business.resources.entities.ICriterionType;
import org.navalplanner.business.resources.entities.Resource;
/**
* Services for aggregate {@link Criterion} <br />
* Services for {@link Criterion} <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface CriterionService {
@ -24,8 +24,6 @@ public interface CriterionService {
void save(Criterion entity);
void add(CriterionSatisfaction criterionSatisfaction);
Collection<Resource> getResourcesSatisfying(ICriterion criterion);
Collection<Resource> getResourcesSatisfying(ICriterion criterion,
@ -45,4 +43,9 @@ public interface CriterionService {
Collection<Criterion> getCriterionsFor(ICriterionType<?> type);
<T extends Resource> List<T> getResourcesSatisfying(Class<T> resourceType,
Criterion criterion);
Criterion load(Criterion criterion);
}

3
navalplanner-business/src/main/java/org/navalplanner/business/resources/services/ResourceService.java
View file

@ -38,5 +38,8 @@ public interface ResourceService {
public List<Resource> getResources();
public <T extends Resource> List<T> getResources(Class<T> klass);
public Set<Resource> getSetOfResourcesSatisfying(ICriterion criterion);
}

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

@ -8,7 +8,6 @@ import java.util.List;
import org.apache.commons.lang.Validate;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.resources.daos.impl.CriterionDAO;
import org.navalplanner.business.resources.daos.impl.CriterionSatisfactionDAO;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionSatisfaction;
import org.navalplanner.business.resources.entities.ICriterion;
@ -31,9 +30,6 @@ public class CriterionServiceImpl implements CriterionService {
@Autowired
private CriterionDAO criterionDAO;
@Autowired
private CriterionSatisfactionDAO criterionSatisfactionDAO;
@Autowired
private ResourceService resourceService;
@ -57,11 +53,6 @@ public class CriterionServiceImpl implements CriterionService {
criterionDAO.save(entity);
}
@Override
public void add(CriterionSatisfaction criterionSatisfaction) {
criterionSatisfactionDAO.save(criterionSatisfaction);
}
@Override
public Collection<Resource> getResourcesSatisfying(ICriterion criterion) {
List<Resource> resources = resourceService.getResources();
@ -165,4 +156,28 @@ public class CriterionServiceImpl implements CriterionService {
}
return result;
}
@Override
public <T extends Resource> List<T> getResourcesSatisfying(
Class<T> resourceType, Criterion criterion) {
Validate.notNull(resourceType, "resourceType must be not null");
Validate.notNull(criterion, "criterion must be not null");
List<T> result = new ArrayList<T>();
for (T r : resourceService.getResources(resourceType)) {
if (criterion.isSatisfiedBy(r)) {
result.add(r);
}
}
return result;
}
@Override
public Criterion load(Criterion criterion) {
try {
return criterionDAO.find(criterion);
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
}

5
navalplanner-business/src/main/java/org/navalplanner/business/resources/services/impl/ResourceServiceImpl.java
View file

@ -71,4 +71,9 @@ public class ResourceServiceImpl implements ResourceService {
public List<Resource> getResources() {
return resourceDao.list(Resource.class);
}
@Override
public <T extends Resource> List<T> getResources(Class<T> klass) {
return resourceDao.list(klass);
}
}

2
navalplanner-business/src/main/resources/org/navalplanner/business/resources/entities/Resources.hbm.xml
View file

@ -10,7 +10,7 @@
Hibernate infers type="integer".
-->
<version access="field" name="version" type="long"/>
<set access="field" inverse="true" name="criterionSatisfactions">
<set access="field" inverse="true" name="criterionSatisfactions" cascade="all-delete-orphan">
<key column="resource" not-null="true"/>
<one-to-many class="CriterionSatisfaction"/>
</set>

12
navalplanner-business/src/test/java/org/navalplanner/business/test/resources/bootstrap/CriterionsBootstrapTest.java
View file

@ -1,12 +1,8 @@
package org.navalplanner.business.test.resources.bootstrap;
import static junit.framework.Assert.assertTrue;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.resources.bootstrap.CriterionsBootstrap;
import org.navalplanner.business.resources.bootstrap.ICriterionsBootstrap;
import org.navalplanner.business.resources.entities.WorkingRelationship;
import org.navalplanner.business.resources.services.CriterionService;
import org.springframework.beans.factory.annotation.Autowired;
@ -14,6 +10,10 @@ import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import static junit.framework.Assert.assertTrue;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { BUSINESS_SPRING_CONFIG_FILE,
BUSINESS_SPRING_CONFIG_TEST_FILE })
@ -21,7 +21,7 @@ import org.springframework.transaction.annotation.Transactional;
public class CriterionsBootstrapTest {
@Autowired
private CriterionsBootstrap criterionsBootstrap;
private ICriterionsBootstrap criterionsBootstrap;
@Autowired
private CriterionService criterionService;

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

@ -10,6 +10,7 @@ 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.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
@ -33,6 +34,17 @@ public class CriterionSatisfactionTest {
criterionSatisfaction.getEndDate());
}
@Test
public void canFinishWhenItStarted() throws Exception {
final Criterion criterion = CriterionDAOTest.createValidCriterion();
Worker worker = new Worker("firstName", "surName", "2333232", 10);
Date start = CriterionSatisfactionDAOTest.year(2000);
CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
start, criterion, worker);
criterionSatisfaction.finish(start);
assertTrue(criterionSatisfaction.isFinished());
}
@Test(expected = IllegalArgumentException.class)
public void testCantFinishBeforeStart() {
final Criterion criterion = CriterionDAOTest.createValidCriterion();
@ -42,4 +54,25 @@ public class CriterionSatisfactionTest {
criterionSatisfaction.finish(CriterionSatisfactionDAOTest.year(1999));
}
@Test
public void isValidAtDate() {
final Criterion criterion = CriterionDAOTest.createValidCriterion();
Worker worker = new Worker("firstName", "surName", "2333232", 10);
CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(2000), criterion, worker);
assertTrue(criterionSatisfaction
.isActiveAt(CriterionSatisfactionDAOTest.year(3000)));
assertTrue(criterionSatisfaction
.isActiveAt(CriterionSatisfactionDAOTest.year(2000)));
assertFalse(criterionSatisfaction
.isActiveAt(CriterionSatisfactionDAOTest.year(1999)));
criterionSatisfaction.finish(CriterionSatisfactionDAOTest.year(2005));
assertFalse(criterionSatisfaction
.isActiveAt(CriterionSatisfactionDAOTest.year(3000)));
assertTrue(criterionSatisfaction
.isActiveAt(CriterionSatisfactionDAOTest.year(2000)));
assertFalse(criterionSatisfaction
.isActiveAt(CriterionSatisfactionDAOTest.year(1999)));
}
}

31
navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/CriterionTest.java
View file

@ -1,12 +1,5 @@
package org.navalplanner.business.test.resources.entities;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;
import static org.navalplanner.business.resources.entities.CriterionCompounder.atom;
import static org.navalplanner.business.resources.entities.CriterionCompounder.build;
import static org.navalplanner.business.resources.entities.CriterionCompounder.not;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
@ -19,6 +12,13 @@ import org.navalplanner.business.resources.entities.PredefinedCriterionTypes;
import org.navalplanner.business.resources.entities.Resource;
import org.navalplanner.business.resources.entities.Worker;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.navalplanner.business.resources.entities.CriterionCompounder.atom;
import static org.navalplanner.business.resources.entities.CriterionCompounder.build;
import static org.navalplanner.business.resources.entities.CriterionCompounder.not;
/**
* Tests for criterion. <br />
* Created at May 12, 2009
@ -34,7 +34,6 @@ public class CriterionTest {
.contains(firedCriterion));
}
@Test
public void testCriterionNameAndTypeIsInmutableBusinessKey()
throws Exception {
@ -59,8 +58,8 @@ public class CriterionTest {
assertTrue(criterionForWorkers1And2.isSatisfiedBy(worker1));
assertTrue(criterionForWorkers1And2.isSatisfiedBy(worker2));
ICriterion compositedCriterion = CriterionCompounder.atom(criterionForWorker1)
.and(criterionForWorkers1And2).getResult();
ICriterion compositedCriterion = CriterionCompounder.atom(
criterionForWorker1).and(criterionForWorkers1And2).getResult();
ICriterion matchesNoneComposited = CriterionCompounder.build().and(
criterionForWorker1).and(criterionForWorker2).getResult();
@ -138,6 +137,18 @@ public class CriterionTest {
assertTrue("or has less priority", or.isSatisfiedBy(worker3));
}
@Test
public void testCanBeRelatedTo() throws Exception {
assertTrue(PredefinedCriterionTypes.LOCATION_GROUP
.criterionCanBeRelatedTo(Resource.class));
assertTrue(PredefinedCriterionTypes.LOCATION_GROUP
.criterionCanBeRelatedTo(Worker.class));
assertFalse(PredefinedCriterionTypes.WORK_RELATIONSHIP
.criterionCanBeRelatedTo(Resource.class));
assertTrue(PredefinedCriterionTypes.WORK_RELATIONSHIP
.criterionCanBeRelatedTo(Worker.class));
}
public static ICriterion justThisResourcesCriterion(
final Resource... resources) {
final HashSet<Resource> set = new HashSet<Resource>(Arrays

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

@ -7,6 +7,7 @@ import org.junit.Test;
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.ICriterion;
import org.navalplanner.business.resources.entities.ICriterionType;
import org.navalplanner.business.resources.entities.Resource;
@ -14,7 +15,12 @@ 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.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
* Tests for {@link Resource}. <br />
@ -23,24 +29,20 @@ import static junit.framework.Assert.assertEquals;
public class ResourceTest {
@Test
public void testRelationResourceWithCriterionSatisfaction()
throws Exception {
public void testGetSatisfactionsForCriterion() {
Criterion criterion = CriterionDAOTest.createValidCriterion();
Criterion other = CriterionDAOTest.createValidCriterion();
CriterionTypeBase type = createTypeThatMatches(false, criterion);
CriterionTypeBase otherType = createTypeThatMatches(false, other);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
criterion, worker);
assertEquals(1, worker.getAllSatisfactions().size());
}
@Test
public void testGetActiveSatisfactionsForCriterion() throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
Worker worker = new Worker("firstName", "surName", "2333232", 10);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
criterion, worker);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(4000),
criterion, worker);
assertEquals(1, worker.getActiveSatisfactionsFor(criterion).size());
assertThat(worker.getSatisfactionsFor(criterion).size(), equalTo(0));
worker.activate(new CriterionWithItsType(type, criterion));
assertTrue(criterion.isSatisfiedBy(worker));
assertThat(worker.getSatisfactionsFor(criterion).size(), equalTo(1));
worker.activate(new CriterionWithItsType(otherType, other));
assertTrue(other.isSatisfiedBy(worker));
assertThat(worker.getSatisfactionsFor(other).size(), equalTo(1));
assertThat(worker.getSatisfactionsFor(criterion).size(), equalTo(1));
}
@Test(expected = IllegalArgumentException.class)
@ -59,40 +61,38 @@ public class ResourceTest {
CriterionSatisfactionDAOTest.year(1999));
}
@Test
public void tesGetSatisfactionsInIntervalForCriterion() throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
Worker worker = new Worker("firstName", "surName", "2333232", 10);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
criterion, worker);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(1997),
criterion, worker);
assertEquals(1, worker.getActiveSatisfactionsForIn(criterion,
CriterionSatisfactionDAOTest.year(1999),
CriterionSatisfactionDAOTest.year(2010)).size());
}
@Test
public void testRetrieveActiveCriterionsForCriterionType() throws Exception {
final Criterion criterion = CriterionDAOTest.createValidCriterion();
Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
Worker worker = new Worker("firstName", "surName", "2333232", 10);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
criterion, worker);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
otherCriterion, worker);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(4000),
criterion, worker);
ICriterionType<Criterion> criterionType = createTypeThatMatches(criterion);
CriterionWithItsType criterionWithItsType = new CriterionWithItsType(
criterionType, criterion);
CriterionWithItsType otherCriterionWithItsType = new CriterionWithItsType(
createTypeThatMatches(otherCriterion), otherCriterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
.year(2000));
worker.activate(otherCriterionWithItsType, CriterionSatisfactionDAOTest
.year(2000));
worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
.year(4000));
assertEquals(2, worker.getSatisfactionsFor(criterionType).size());
assertEquals(1, worker.getActiveSatisfactionsFor(criterionType).size());
}
public static CriterionTypeBase createTypeThatMatches(
final Criterion... criterions) {
return createTypeThatMatches(true, criterions);
}
public static CriterionTypeBase createTypeThatMatches(
boolean allowMultipleCriterionsPerResource,
final Criterion... criterions) {
final HashSet<Criterion> criterionsSet = new HashSet<Criterion>(Arrays
.asList(criterions));
return new CriterionTypeBase("base", true, true, false, false) {
return new CriterionTypeBase("base", true,
allowMultipleCriterionsPerResource, false, false) {
@Override
public boolean contains(ICriterion c) {
@ -103,6 +103,12 @@ public class ResourceTest {
public Criterion createCriterion(String name) {
return null;
}
@Override
public boolean criterionCanBeRelatedTo(
Class<? extends Resource> klass) {
return true;
}
};
}
@ -110,16 +116,20 @@ public class ResourceTest {
public void testRetrieveSatisfactionsInIntervalForCriterionType()
throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
Worker worker = new Worker("firstName", "surName", "2333232", 10);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
criterion, worker);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2003),
criterion, worker);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
otherCriterion, worker);
ICriterionType<Criterion> criterionType = createTypeThatMatches(criterion);
CriterionWithItsType criterionWithItsType = new CriterionWithItsType(
criterionType, criterion);
Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
CriterionWithItsType otherCriterionWithItsType = new CriterionWithItsType(
createTypeThatMatches(otherCriterion), otherCriterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
.year(2000));
worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
.year(2003));
worker.activate(otherCriterionWithItsType, CriterionSatisfactionDAOTest
.year(2000));
assertEquals(2, worker.getSatisfactionsFor(criterionType).size());
assertEquals(1, worker.getActiveSatisfactionsForIn(criterionType,
@ -133,4 +143,148 @@ public class ResourceTest {
CriterionSatisfactionDAOTest.year(2005)).size());
}
@Test(expected = IllegalArgumentException.class)
public void invalidadCriterionWithItsTypeNotAllowd() throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
Criterion otherCriterion = CriterionDAOTest.createValidCriterion();
ICriterionType<Criterion> criterionType = createTypeThatMatches(criterion);
new CriterionWithItsType(criterionType, otherCriterion);
}
@Test
public void testActivateAndDeactivateCriterion() {
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(),
equalTo(0));
assertFalse(criterion.isSatisfiedBy(worker));
assertTrue(worker.canBeActivated(new CriterionWithItsType(
criterionType, criterion)));
worker.activate(new CriterionWithItsType(criterionType, criterion));
assertTrue(criterion.isSatisfiedBy(worker));
assertThat(worker.getActiveSatisfactionsFor(criterion).size(),
equalTo(1));
assertFalse(worker.canBeActivated(new CriterionWithItsType(
criterionType, otherCriterion)));
try {
worker.activate(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(
criterionType, criterion)));
assertThat(worker.getActiveSatisfactionsFor(criterion).size(),
equalTo(1));
worker.deactivate(new CriterionWithItsType(criterionType, criterion));
assertTrue("the satisfactions are deactivated", worker
.getActiveSatisfactionsFor(criterion).isEmpty());
}
@Test
public void testActivateInDate() 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),
CriterionSatisfactionDAOTest.year(4000));
worker.activate(new CriterionWithItsType(criterionType, criterion),
CriterionSatisfactionDAOTest.year(5000),
CriterionSatisfactionDAOTest.year(6000));
assertThat(worker.getActiveSatisfactionsForIn(criterion,
CriterionSatisfactionDAOTest.year(4001),
CriterionSatisfactionDAOTest.year(4999)).size(), equalTo(1));
assertThat(worker.getActiveSatisfactionsForIn(criterion,
CriterionSatisfactionDAOTest.year(5001),
CriterionSatisfactionDAOTest.year(5500)).size(), equalTo(1));
worker.deactivate(new CriterionWithItsType(criterionType, criterion));
assertThat(worker.getActiveSatisfactionsForIn(criterion,
CriterionSatisfactionDAOTest.year(4001),
CriterionSatisfactionDAOTest.year(4999)).size(), equalTo(1));
assertThat(worker.getActiveSatisfactionsForIn(criterion,
CriterionSatisfactionDAOTest.year(5001),
CriterionSatisfactionDAOTest.year(5500)).size(), equalTo(1));
assertFalse(worker.canBeActivated(new CriterionWithItsType(
criterionType, otherCriterion), CriterionSatisfactionDAOTest
.year(4001)));
}
@Test
// when type doesnt allow multiple active criterions per resource
public void activateOnlyUntilNextCriterionIsActive() {
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),
CriterionSatisfactionDAOTest.year(4000));
worker.activate(
new CriterionWithItsType(criterionType, otherCriterion),
CriterionSatisfactionDAOTest.year(3500));
assertThat(worker.getSatisfactionsFor(otherCriterion).size(),
equalTo(1));
CriterionSatisfaction satisfaction = worker.getSatisfactionsFor(
otherCriterion).iterator().next();
assertThat(satisfaction.getEndDate(),
equalTo(CriterionSatisfactionDAOTest.year(4000)));
}
@Test(expected = IllegalStateException.class)
// when type doesnt allow multiple active criterions per resource
public void deactivatePrevious() {
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, otherCriterion),
CriterionSatisfactionDAOTest.year(3500));
assertFalse(worker.canBeActivated(new CriterionWithItsType(
criterionType, criterion), CriterionSatisfactionDAOTest
.year(4000)));
worker.activate(new CriterionWithItsType(criterionType, criterion),
CriterionSatisfactionDAOTest.year(4000));
}
@Test(expected = IllegalStateException.class)
public void shouldntActivate() {
Criterion criterion = CriterionDAOTest.createValidCriterion();
Worker worker = new Worker("firstName", "surName", "2333232", 10);
ICriterionType<?> type = new CriterionTypeBase("prueba", false, false,
false, false) {
@Override
public boolean contains(ICriterion c) {
return true;
}
@Override
public Criterion createCriterion(String name) {
return null;
}
@Override
public boolean criterionCanBeRelatedTo(
Class<? extends Resource> klass) {
return false;
}
};
CriterionWithItsType criterionWithItsType = new CriterionWithItsType(
type, criterion);
assertFalse(worker.canBeActivated(criterionWithItsType));
worker.activate(criterionWithItsType);
}
}

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

@ -7,12 +7,14 @@ import org.hibernate.SessionFactory;
import org.hibernate.validator.InvalidStateException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.resources.bootstrap.ICriterionsBootstrap;
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.ICriterion;
import org.navalplanner.business.resources.entities.ICriterionOnData;
import org.navalplanner.business.resources.entities.ICriterionType;
import org.navalplanner.business.resources.entities.PredefinedCriterionTypes;
import org.navalplanner.business.resources.entities.Resource;
import org.navalplanner.business.resources.entities.Worker;
import org.navalplanner.business.resources.services.CriterionService;
import org.navalplanner.business.resources.services.ResourceService;
@ -26,8 +28,11 @@ import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertTrue;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
@ -50,6 +55,9 @@ public class CriterionServiceTest {
@Autowired
private SessionFactory sessionFactory;
@Autowired
private ICriterionsBootstrap criterionsBootstrap;
@Test(expected = InvalidStateException.class)
public void testCantSaveCriterionWithoutNameAndType() throws Exception {
Criterion criterion = new Criterion("", "");
@ -99,81 +107,96 @@ public class CriterionServiceTest {
assertEquals(criterion, other);
}
@Test
public void testCreateCriterionSatisfactionButNotSave() {
Criterion criterion = CriterionDAOTest.createValidCriterion();
criterionService.save(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
resourceService.saveResource(worker);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
criterion, worker);
assertEquals(1, worker.getAllSatisfactions().size());
}
/*
* It sends a dataIntegrityViolationException when adding a
* criterionSatisfaction with a criterion that doesn't exist yet
*/
@Test(expected = DataIntegrityViolationException.class)
public void testCreateCriterionSatisfactionOnTransientCriterion()
throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
ICriterionType<?> type = createTypeThatMatches(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
worker.activate(new CriterionWithItsType(type, criterion));
assertTrue(criterion.isSatisfiedBy(worker));
resourceService.saveResource(worker);
criterionService.add(new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(2000), criterion, worker));
assertTrue(criterion.isSatisfiedBy(worker));
assertThat(criterionService.getResourcesSatisfying(criterion).size(),
equalTo(1));
}
@NotTransactional
@Test
public void testInNoTransaction() throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
criterionService.save(criterion);
ICriterionType<?> type = createTypeThatMatches(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
worker.activate(new CriterionWithItsType(type, criterion));
assertTrue(criterion.isSatisfiedBy(worker));
resourceService.saveResource(worker);
assertTrue(criterion.isSatisfiedBy(worker));
assertThat(criterionService.getResourcesSatisfying(criterion).size(),
equalTo(1));
}
@Test(expected = DataIntegrityViolationException.class)
public void testCreateCriterionSatisfactionOnTransientResource()
throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
ICriterionType<?> type = createTypeThatMatches(criterion);
criterionService.save(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(2000), criterion, worker);
criterionService.add(criterionSatisfaction);
}
@Test
public void testCreatingButNotPersistingSatisfaction() throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
criterionService.save(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
new CriterionSatisfaction(CriterionSatisfactionDAOTest.year(2000),
criterion, worker);
worker.activate(new CriterionWithItsType(type, criterion));
resourceService.saveResource(worker);
assertEquals(1, criterionService.getResourcesSatisfying(criterion)
.size());
sessionFactory.getCurrentSession().evict(worker);
assertEquals(
"once the worker has been evicted the satisfaction created is not taken into account",
0, criterionService.getResourcesSatisfying(criterion).size());
assertThat(criterionService.getResourcesSatisfying(criterion).size(),
equalTo(1));
assertThat((Worker) criterionService.getResourcesSatisfying(criterion)
.iterator().next(), equalTo(worker));
}
@Test
public void testGetSetOfResourcesSatisfyingCriterion() throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
criterionService.save(criterion);
ICriterionType<?> type = createTypeThatMatches(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
resourceService.saveResource(worker);
CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(2000), criterion, worker);
criterionService.add(criterionSatisfaction);
worker.activate(new CriterionWithItsType(type, criterion));
assertEquals(1, criterionService.getResourcesSatisfying(criterion)
.size());
}
public static class Prueba extends Resource {
@Override
public int getDailyCapacity() {
return 0;
}
}
@Test
public void testGetSetOfResourcesSubclassSatisfyingCriterion() {
Criterion criterion = CriterionDAOTest.createValidCriterion();
criterionService.save(criterion);
ICriterionType<Criterion> type = createTypeThatMatches(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
resourceService.saveResource(worker);
worker.activate(new CriterionWithItsType(type, criterion));
assertThat(criterionService.getResourcesSatisfying(Resource.class,
criterion).size(), is(1));
assertThat(criterionService.getResourcesSatisfying(Worker.class,
criterion).size(), is(1));
assertThat(criterionService.getResourcesSatisfying(Prueba.class,
criterion).size(), is(0));
}
@Test
public void shouldLetCreateCriterionOnData() {
Criterion criterion = CriterionDAOTest.createValidCriterion();
ICriterionType<?> type = createTypeThatMatches(criterion);
criterionService.save(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
resourceService.saveResource(worker);
CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(2000), criterion, worker);
criterionService.add(criterionSatisfaction);
worker.activate(new CriterionWithItsType(type, criterion),
CriterionSatisfactionDAOTest.year(2000));
ICriterionOnData criterionOnData = criterionService.empower(criterion);
assertTrue(criterionOnData.isSatisfiedBy(worker));
assertEquals(1, criterionOnData.getResourcesSatisfying().size());
@ -190,12 +213,12 @@ public class CriterionServiceTest {
@NotTransactional
public void shouldntThrowExceptionDueToTransparentProxyGotcha() {
Criterion criterion = CriterionDAOTest.createValidCriterion();
ICriterionType<Criterion> type = createTypeThatMatches(criterion);
criterionService.save(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
resourceService.saveResource(worker);
CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(2000), criterion, worker);
criterionService.add(criterionSatisfaction);
worker.activate(new CriterionWithItsType(type, criterion),
CriterionSatisfactionDAOTest.year(2000));
ICriterionOnData criterionOnData = criterionService.empower(criterion);
criterionOnData.getResourcesSatisfying();
criterionOnData.getResourcesSatisfying(CriterionSatisfactionDAOTest
@ -215,12 +238,13 @@ public class CriterionServiceTest {
public void testSearchInInterval() throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
criterionService.save(criterion);
ICriterionType<Criterion> type = createTypeThatMatches(true, criterion);
CriterionWithItsType criterionWithItsType = new CriterionWithItsType(
type, criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
resourceService.saveResource(worker);
CriterionSatisfaction criterionSatisfaction = new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(2000), criterion, worker);
criterionService.add(criterionSatisfaction);
worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
.year(2000));
assertEquals(1, criterionService.getResourcesSatisfying(criterion,
CriterionSatisfactionDAOTest.year(2001),
@ -229,9 +253,8 @@ public class CriterionServiceTest {
CriterionSatisfactionDAOTest.year(1999),
CriterionSatisfactionDAOTest.year(2005)).size());
CriterionSatisfaction otherSatisfaction = new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(1998), criterion, worker);
criterionService.add(otherSatisfaction);
worker.activate(new CriterionWithItsType(type, criterion),
CriterionSatisfactionDAOTest.year(1998));
assertEquals(1, criterionService.getResourcesSatisfying(criterion,
CriterionSatisfactionDAOTest.year(1999),
@ -241,13 +264,16 @@ public class CriterionServiceTest {
@Test
public void testSearchResourcesForCriterionType() throws Exception {
Criterion criterion = CriterionDAOTest.createValidCriterion();
ICriterionType<Criterion> type = createTypeThatMatches(true, criterion);
CriterionWithItsType criterionWithItsType = new CriterionWithItsType(
type, criterion);
criterionService.save(criterion);
Worker worker = new Worker("firstName", "surName", "2333232", 10);
resourceService.saveResource(worker);
criterionService.add(new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(2000), criterion, worker));
criterionService.add(new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(1998), criterion, worker));
worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
.year(2000));
worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
.year(1998));
ICriterionType<?> criterionType = ResourceTest
.createTypeThatMatches(criterion);
@ -262,8 +288,8 @@ public class CriterionServiceTest {
CriterionSatisfactionDAOTest.year(1997),
CriterionSatisfactionDAOTest.year(2005)).size());
criterionService.add(new CriterionSatisfaction(
CriterionSatisfactionDAOTest.year(1997), criterion, worker));
worker.activate(criterionWithItsType, CriterionSatisfactionDAOTest
.year(1997));
assertEquals(2, criterionService.getSatisfactionsFor(criterionType,
CriterionSatisfactionDAOTest.year(1999),
CriterionSatisfactionDAOTest.year(2005)).size());
@ -284,6 +310,12 @@ public class CriterionServiceTest {
private ICriterionType<Criterion> createTypeThatMatches(
final Criterion criterion) {
return createTypeThatMatches(false, criterion);
}
private ICriterionType<Criterion> createTypeThatMatches(
final boolean allowMultipleActiveCriterionsPerResource,
final Criterion criterion) {
return new ICriterionType<Criterion>() {
@Override
@ -293,7 +325,7 @@ public class CriterionServiceTest {
@Override
public boolean allowMultipleActiveCriterionsPerResource() {
return false;
return allowMultipleActiveCriterionsPerResource;
}
@Override
@ -323,6 +355,12 @@ public class CriterionServiceTest {
// TODO Auto-generated method stub
return false;
}
@Override
public boolean criterionCanBeRelatedTo(
Class<? extends Resource> klass) {
return true;
}
};
}

4
navalplanner-webapp/src/main/java/org/navalplanner/web/resources/CriterionsModel.java
View file

@ -7,7 +7,7 @@ import org.apache.commons.lang.Validate;
import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.resources.bootstrap.CriterionsBootstrap;
import org.navalplanner.business.resources.bootstrap.ICriterionsBootstrap;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.ICriterionType;
import org.navalplanner.business.resources.services.CriterionService;
@ -29,7 +29,7 @@ public class CriterionsModel implements ICriterionsModel {
Criterion.class);
@Autowired
private CriterionsBootstrap criterionsBootstrap;
private ICriterionsBootstrap criterionsBootstrap;
@Autowired
private CriterionService criterionService;