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

ItEr41S23CUImportarTraballoRealizadoPorSubcontrata: Import/update criterions information at order element service.

Browse source
This commit is contained in:
Manuel Rego Casasnovas 2009-12-31 08:08:05 +01:00 • committed by Javier Moran Rua
parent 99a18db7ab
commit e4bb249550
12 changed files with 487 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
navalplanner-business/src/main/java/org/navalplanner/business/common/Registry.java
View file

@ -30,6 +30,7 @@ import org.navalplanner.business.materials.daos.IMaterialCategoryDAO;
import org.navalplanner.business.materials.daos.IMaterialDAO;
import org.navalplanner.business.orders.daos.IOrderElementDAO;
import org.navalplanner.business.qualityforms.daos.IQualityFormDAO;
import org.navalplanner.business.resources.daos.ICriterionDAO;
import org.navalplanner.business.resources.daos.ICriterionTypeDAO;
import org.navalplanner.business.resources.daos.IMachineDAO;
import org.navalplanner.business.resources.daos.IWorkerDAO;
@ -108,6 +109,9 @@ public class Registry {
@Autowired
private IWorkReportLineDAO workReportLineDAO;
@Autowired
private ICriterionDAO criterionDAO;
private Registry() {
}
@ -181,4 +185,9 @@ public class Registry {
public static IWorkReportLineDAO getWorkReportLineDAO() {
return getInstance().workReportLineDAO;
}
public static ICriterionDAO getCriterionDAO() {
return getInstance().criterionDAO;
}
}

6
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java
View file

@ -255,7 +255,7 @@ public class CriterionRequirementHandler implements
.getIndirectCriterionRequirement();
for (IndirectCriterionRequirement current : currents) {
if (!indirects.contains(current)) {
orderElement.addCriterionRequirement(current);
orderElement.basicAddCriterionRequirement(current);
}
}
}
@ -367,12 +367,12 @@ public class CriterionRequirementHandler implements
// copy the directCriterionRequirement
for (DirectCriterionRequirement newRequirement : copyDirectRequirements(orderLine
.getDirectCriterionRequirement())) {
container.addCriterionRequirement(newRequirement);
container.basicAddCriterionRequirement(newRequirement);
}
// copy the IndirectCriterionRequirement
for (IndirectCriterionRequirement newRequirement : copyIndirectRequirements(orderLine
.getIndirectCriterionRequirement())) {
container.addCriterionRequirement(newRequirement);
container.basicAddCriterionRequirement(newRequirement);
}
}

5
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java
View file

@ -36,7 +36,8 @@ import org.navalplanner.business.requirements.entities.IndirectCriterionRequirem
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.ResourceEnum;
public class HoursGroup extends BaseEntity implements Cloneable {
public class HoursGroup extends BaseEntity implements Cloneable,
ICriterionRequirable {
public static HoursGroup create(OrderLine parentOrderLine) {
HoursGroup result = new HoursGroup(parentOrderLine);
@ -154,6 +155,7 @@ public class HoursGroup extends BaseEntity implements Cloneable {
}
@Valid
@Override
public Set<CriterionRequirement> getCriterionRequirements() {
return criterionRequirements;
}
@ -171,6 +173,7 @@ public class HoursGroup extends BaseEntity implements Cloneable {
return Collections.unmodifiableSet(criterions);
}
@Override
public void addCriterionRequirement(CriterionRequirement requirement) {
if (!isValidResourceType(requirement)) {
throw new IllegalStateException(

37
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/ICriterionRequirable.java Normal file
View file

@ -0,0 +1,37 @@
/*
* This file is part of ###PROJECT_NAME###
*
* Copyright (C) 2009 Fundación para o Fomento da Calidade Industrial e
* Desenvolvemento Tecnolóxico de Galicia
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.navalplanner.business.orders.entities;
import java.util.Set;
import org.navalplanner.business.requirements.entities.CriterionRequirement;
/**
* Marks an entity that could have assigned {@link CriterionRequirement}.
*
* @author Manuel Rego Casasnovas <mrego@igalia.com>
*/
public interface ICriterionRequirable {
Set<CriterionRequirement> getCriterionRequirements();
void addCriterionRequirement(CriterionRequirement requirement);
}

25
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
View file

@ -61,7 +61,9 @@ import org.navalplanner.business.requirements.entities.CriterionRequirement;
import org.navalplanner.business.requirements.entities.DirectCriterionRequirement;
import org.navalplanner.business.requirements.entities.IndirectCriterionRequirement;
import org.navalplanner.business.resources.entities.Criterion;
public abstract class OrderElement extends BaseEntity {
public abstract class OrderElement extends BaseEntity implements
ICriterionRequirable {
@NotEmpty(message = "name not specified")
private String name;
@ -515,6 +517,7 @@ public abstract class OrderElement extends BaseEntity {
}
@Valid
@Override
public Set<CriterionRequirement> getCriterionRequirements() {
return Collections.unmodifiableSet(criterionRequirements);
}
@ -555,7 +558,7 @@ public abstract class OrderElement extends BaseEntity {
CriterionRequirement newRequirement) {
if (criterionRequirementHandler.canAddCriterionRequirement(this,
newRequirement)) {
addCriterionRequirement(newRequirement);
basicAddCriterionRequirement(newRequirement);
criterionRequirementHandler
.propagateDirectCriterionRequirementAddition(this,
newRequirement);
@ -570,15 +573,25 @@ public abstract class OrderElement extends BaseEntity {
void addIndirectCriterionRequirement(
IndirectCriterionRequirement criterionRequirement) {
addCriterionRequirement(criterionRequirement);
basicAddCriterionRequirement(criterionRequirement);
}
protected void addCriterionRequirement(
protected void basicAddCriterionRequirement(
CriterionRequirement criterionRequirement) {
criterionRequirement.setOrderElement(this);
this.criterionRequirements.add(criterionRequirement);
}
@Override
public void addCriterionRequirement(
CriterionRequirement criterionRequirement) {
if (criterionRequirement instanceof DirectCriterionRequirement) {
addDirectCriterionRequirement((DirectCriterionRequirement) criterionRequirement);
} else { // criterionRequirement instanceof IndirectCriterionRequirement
addIndirectCriterionRequirement((IndirectCriterionRequirement) criterionRequirement);
}
}
public void updateCriterionRequirements() {
updateMyCriterionRequirements();
criterionRequirementHandler.propagateUpdateCriterionRequirements(this);
@ -847,6 +860,10 @@ public abstract class OrderElement extends BaseEntity {
}
public OrderElement getOrderElement(String code) {
if (code == null) {
return null;
}
for (OrderElement child : getChildren()) {
if (child.getCode().equals(code)) {
return child;

4
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java
View file

@ -490,6 +490,10 @@ public class OrderLine extends OrderElement {
}
public HoursGroup getHoursGroup(String code) {
if (code == null) {
return null;
}
for (HoursGroup hoursGroup : getHoursGroups()) {
if (hoursGroup.getCode().equals(code)) {
return hoursGroup;

2
navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/CriterionRequirement.java
View file

@ -52,7 +52,7 @@ public class CriterionRequirement extends BaseEntity{
this.hoursGroup = hoursGroup;
}
@NotNull
@NotNull(message = "criterion not specified")
public Criterion getCriterion() {
return criterion;
}

4
navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/IndirectCriterionRequirement.java
View file

@ -20,9 +20,9 @@
package org.navalplanner.business.requirements.entities;
import org.hibernate.validator.NotNull;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.orders.entities.HoursGroup;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.resources.entities.Criterion;
/**
@ -67,7 +67,7 @@ public class IndirectCriterionRequirement extends CriterionRequirement{
super(criterion,orderElement,hoursGroup);
}
@NotNull
@NotNull(message = "parent not specified")
public DirectCriterionRequirement getParent() {
return parent;
}

16
navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/CriterionDAO.java
View file

@ -73,10 +73,20 @@ public class CriterionDAO extends GenericDAOHibernate<Criterion, Long>
if (criterion.getType() == null) {
return new ArrayList<Criterion>();
}
return findByNameAndType(criterion.getName(), criterion.getType()
.getName());
}
@Override
public List<Criterion> findByNameAndType(String name, String type) {
if ((name == null) || (type == null)) {
return new ArrayList<Criterion>();
}
Criteria c = getSession().createCriteria(Criterion.class);
c.add(Restrictions.eq("name", criterion.getName()).ignoreCase())
.createCriteria("type")
.add(Restrictions.eq("name", criterion.getType().getName()).ignoreCase());
c.add(Restrictions.eq("name", name).ignoreCase())
.createCriteria("type").add(
Restrictions.eq("name", type).ignoreCase());
return (List<Criterion>) c.list();
}

2
navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/ICriterionDAO.java
View file

@ -53,4 +53,6 @@ public interface ICriterionDAO extends IGenericDAO<Criterion, Long> {
boolean thereIsOtherWithSameNameAndType(Criterion criterion);
List<Criterion> findByNameAndType(String name, String type);
}

138
navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementConverter.java
View file

@ -46,12 +46,15 @@ import org.navalplanner.business.materials.entities.MaterialAssignment;
import org.navalplanner.business.materials.entities.MaterialCategory;
import org.navalplanner.business.materials.entities.PredefinedMaterialCategories;
import org.navalplanner.business.orders.entities.HoursGroup;
import org.navalplanner.business.orders.entities.ICriterionRequirable;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.business.orders.entities.OrderLineGroup;
import org.navalplanner.business.requirements.entities.CriterionRequirement;
import org.navalplanner.business.requirements.entities.DirectCriterionRequirement;
import org.navalplanner.business.requirements.entities.IndirectCriterionRequirement;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.ResourceEnum;
import org.navalplanner.ws.common.api.IncompatibleTypeException;
import org.navalplanner.ws.common.api.ResourceEnumDTO;
@ -229,6 +232,96 @@ public final class OrderElementConverter {
public final static OrderElement toEntity(OrderElementDTO orderElementDTO,
ConfigurationOrderElementConverter configuration) {
OrderElement orderElement = toEntityExceptCriterionRequirements(
orderElementDTO, configuration);
if (configuration.isCriterionRequirements()) {
addOrCriterionRequirements(orderElement, orderElementDTO);
}
return orderElement;
}
private static void addOrCriterionRequirements(OrderElement orderElement,
OrderElementDTO orderElementDTO) {
addOrCriterionRequirementsEntities(orderElement,
orderElementDTO.criterionRequirements);
if (orderElementDTO instanceof OrderLineDTO) {
for (HoursGroupDTO hoursGroupDTO : ((OrderLineDTO) orderElementDTO).hoursGroups) {
HoursGroup hoursGroup = ((OrderLine) orderElement)
.getHoursGroup(hoursGroupDTO.code);
if (hoursGroup != null) {
addOrCriterionRequirementsEntities(hoursGroup,
hoursGroupDTO.criterionRequirements);
}
}
} else { // orderElementDTO instanceof OrderLineGroupDTO
for (OrderElementDTO childDTO : ((OrderLineGroupDTO) orderElementDTO).children) {
OrderElement child = ((OrderLineGroup) orderElement)
.getOrderElement(childDTO.code);
addOrCriterionRequirements(child, childDTO);
}
}
}
private static void addOrCriterionRequirementsEntities(
ICriterionRequirable criterionRequirable,
Set<CriterionRequirementDTO> criterionRequirements) {
for (CriterionRequirementDTO criterionRequirementDTO : criterionRequirements) {
Criterion criterion = getCriterion(criterionRequirementDTO.name,
criterionRequirementDTO.type);
if (criterion != null) {
if (criterionRequirementDTO instanceof DirectCriterionRequirementDTO) {
DirectCriterionRequirement directCriterionRequirement = getDirectCriterionRequirementByCriterion(
criterionRequirable, criterion);
if (directCriterionRequirement == null) {
criterionRequirable
.addCriterionRequirement(DirectCriterionRequirement
.create(criterion));
}
} else { // criterionRequirementDTO instanceof
// IndirectCriterionRequirementDTO
if (criterion != null) {
IndirectCriterionRequirement indirectCriterionRequirement = getIndirectCriterionRequirementByCriterion(
criterionRequirable, criterion);
if (indirectCriterionRequirement != null) {
indirectCriterionRequirement
.setIsValid(((IndirectCriterionRequirementDTO) criterionRequirementDTO).isValid);
}
}
}
}
}
}
private static DirectCriterionRequirement getDirectCriterionRequirementByCriterion(
ICriterionRequirable criterionRequirable, Criterion criterion) {
for (CriterionRequirement criterionRequirement : criterionRequirable
.getCriterionRequirements()) {
if (criterionRequirement instanceof DirectCriterionRequirement) {
if (criterionRequirement.getCriterion().isEquivalent(criterion)) {
return (DirectCriterionRequirement) criterionRequirement;
}
}
}
return null;
}
private static IndirectCriterionRequirement getIndirectCriterionRequirementByCriterion(
ICriterionRequirable criterionRequirable, Criterion criterion) {
for (CriterionRequirement criterionRequirement : criterionRequirable
.getCriterionRequirements()) {
if (criterionRequirement instanceof IndirectCriterionRequirement) {
if (criterionRequirement.getCriterion().isEquivalent(criterion)) {
return (IndirectCriterionRequirement) criterionRequirement;
}
}
}
return null;
}
private final static OrderElement toEntityExceptCriterionRequirements(
OrderElementDTO orderElementDTO,
ConfigurationOrderElementConverter configuration) {
OrderElement orderElement;
if (orderElementDTO instanceof OrderLineDTO) {
@ -236,7 +329,8 @@ public final class OrderElementConverter {
if (configuration.isHoursGroups()) {
for (HoursGroupDTO hoursGroupDTO : ((OrderLineDTO) orderElementDTO).hoursGroups) {
HoursGroup hoursGroup = toEntity(hoursGroupDTO);
HoursGroup hoursGroup = toEntity(hoursGroupDTO,
configuration);
((OrderLine) orderElement).addHoursGroup(hoursGroup);
}
}
@ -297,6 +391,26 @@ public final class OrderElementConverter {
return orderElement;
}
private static Criterion getCriterion(String name, String type) {
List<Criterion> criterions = Registry.getCriterionDAO()
.findByNameAndType(name, type);
if (criterions.size() != 1) {
return null;
}
return criterions.get(0);
}
public static DirectCriterionRequirement toEntity(
DirectCriterionRequirementDTO criterionRequirementDTO) {
Criterion criterion = getCriterion(criterionRequirementDTO.name,
criterionRequirementDTO.type);
if (criterion == null) {
return null;
}
return DirectCriterionRequirement.create(criterion);
}
public final static MaterialAssignment toEntity(
MaterialAssignmentDTO materialAssignmentDTO) {
Material material = null;
@ -346,7 +460,8 @@ public final class OrderElementConverter {
return label;
}
public final static HoursGroup toEntity(HoursGroupDTO hoursGroupDTO) {
public final static HoursGroup toEntity(HoursGroupDTO hoursGroupDTO,
ConfigurationOrderElementConverter configuration) {
ResourceEnum resourceType = ResourceEnumConverter
.fromDTO(hoursGroupDTO.resourceType);
HoursGroup hoursGroup = HoursGroup.createUnvalidated(
@ -358,6 +473,17 @@ public final class OrderElementConverter {
OrderElementDTO orderElementDTO,
ConfigurationOrderElementConverter configuration)
throws IncompatibleTypeException {
updateExceptCriterionRequirements(orderElement, orderElementDTO,
configuration);
if (configuration.isCriterionRequirements()) {
addOrCriterionRequirements(orderElement, orderElementDTO);
}
}
private final static void updateExceptCriterionRequirements(
OrderElement orderElement, OrderElementDTO orderElementDTO,
ConfigurationOrderElementConverter configuration)
throws IncompatibleTypeException {
if (orderElementDTO instanceof OrderLineDTO) {
if (!(orderElement instanceof OrderLine)) {
@ -371,10 +497,11 @@ public final class OrderElementConverter {
.containsHoursGroup(hoursGroupDTO.code)) {
update(((OrderLine) orderElement)
.getHoursGroup(hoursGroupDTO.code),
hoursGroupDTO);
hoursGroupDTO, configuration);
} else {
((OrderLine) orderElement)
.addHoursGroup(toEntity(hoursGroupDTO));
.addHoursGroup(toEntity(
hoursGroupDTO, configuration));
}
}
}
@ -470,7 +597,8 @@ public final class OrderElementConverter {
}
public final static void update(HoursGroup hoursGroup,
HoursGroupDTO hoursGroupDTO) {
HoursGroupDTO hoursGroupDTO,
ConfigurationOrderElementConverter configuration) {
if (!hoursGroup.getCode().equals(hoursGroupDTO.code)) {
throw new RuntimeException(
_("Not the same hours group, impossible to update"));

263
navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/orders/OrderElementServiceTest.java
View file

@ -22,9 +22,12 @@ package org.navalplanner.web.test.ws.orders;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.web.WebappGlobalNames.WEBAPP_SPRING_CONFIG_FILE;
@ -33,7 +36,9 @@ import static org.navalplanner.web.test.WebappGlobalNames.WEBAPP_SPRING_CONFIG_T
import java.math.BigDecimal;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import javax.annotation.Resource;
@ -54,14 +59,21 @@ import org.navalplanner.business.orders.daos.IOrderElementDAO;
import org.navalplanner.business.orders.entities.HoursGroup;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.business.requirements.entities.CriterionRequirement;
import org.navalplanner.business.requirements.entities.DirectCriterionRequirement;
import org.navalplanner.business.requirements.entities.IndirectCriterionRequirement;
import org.navalplanner.business.resources.entities.PredefinedCriterionTypes;
import org.navalplanner.business.resources.entities.ResourceEnum;
import org.navalplanner.ws.common.api.ConstraintViolationDTO;
import org.navalplanner.ws.common.api.IncompatibleTypeException;
import org.navalplanner.ws.common.api.InstanceConstraintViolationsDTO;
import org.navalplanner.ws.common.api.ResourceEnumDTO;
import org.navalplanner.ws.orders.api.AdvanceMeasurementDTO;
import org.navalplanner.ws.orders.api.CriterionRequirementDTO;
import org.navalplanner.ws.orders.api.DirectCriterionRequirementDTO;
import org.navalplanner.ws.orders.api.HoursGroupDTO;
import org.navalplanner.ws.orders.api.IOrderElementService;
import org.navalplanner.ws.orders.api.IndirectCriterionRequirementDTO;
import org.navalplanner.ws.orders.api.LabelDTO;
import org.navalplanner.ws.orders.api.MaterialAssignmentDTO;
import org.navalplanner.ws.orders.api.OrderDTO;
@ -93,11 +105,15 @@ public class OrderElementServiceTest {
@Resource
private IDataBootstrap materialCategoryBootstrap;
@Resource
private IDataBootstrap criterionsBootstrap;
@Before
public void loadRequiredaData() {
defaultAdvanceTypesBootstrapListener.loadRequiredData();
configurationBootstrap.loadRequiredData();
materialCategoryBootstrap.loadRequiredData();
criterionsBootstrap.loadRequiredData();
}
@Autowired
@ -309,7 +325,8 @@ public class OrderElementServiceTest {
orderLineDTO.name = "Order line";
orderLineDTO.code = "order-line-code";
HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group",
ResourceEnumDTO.WORKER, 1000);
ResourceEnumDTO.WORKER, 1000,
new HashSet<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
orderDTO.children.add(orderLineDTO);
@ -391,7 +408,8 @@ public class OrderElementServiceTest {
orderLineDTO.name = "Order line";
orderLineDTO.code = "order-line-code";
HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group",
ResourceEnumDTO.WORKER, 1000);
ResourceEnumDTO.WORKER, 1000,
new HashSet<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
orderLineGroupDTO.children.add(orderLineDTO);
@ -578,7 +596,8 @@ public class OrderElementServiceTest {
orderLineDTO.name = "Order line";
orderLineDTO.code = "order-line-code";
HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group",
ResourceEnumDTO.WORKER, 1000);
ResourceEnumDTO.WORKER, 1000,
new HashSet<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
orderLineDTO.labels.add(labelDTO);
orderDTO.children.add(orderLineDTO);
@ -709,7 +728,8 @@ public class OrderElementServiceTest {
orderLineDTO.name = "Order line";
orderLineDTO.code = "order-line-code";
HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group",
ResourceEnumDTO.WORKER, 1000);
ResourceEnumDTO.WORKER, 1000,
new HashSet<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
orderDTO.children.add(orderLineDTO);
@ -727,7 +747,8 @@ public class OrderElementServiceTest {
orderLineDTO.hoursGroups.iterator().next().workingHours = 1500;
HoursGroupDTO hoursGroupDTO2 = new HoursGroupDTO("hours-group2",
ResourceEnumDTO.WORKER, 2000);
ResourceEnumDTO.WORKER, 2000,
new HashSet<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO2);
instanceConstraintViolationsList = orderElementService
@ -886,4 +907,236 @@ public class OrderElementServiceTest {
}
}
@Test
public void invalidOrderWithCriterionRequirements()
throws InstanceNotFoundException {
String code = "order-code";
try {
orderElementDAO.findUniqueByCode(code);
fail("Order with code " + code + " already exists");
} catch (InstanceNotFoundException e) {
// It should throw an exception
}
OrderDTO orderDTO = new OrderDTO();
orderDTO.name = "Order name";
orderDTO.code = code;
orderDTO.initDate = new Date();
CriterionRequirementDTO criterionRequirementDTO = new DirectCriterionRequirementDTO();
orderDTO.criterionRequirements.add(criterionRequirementDTO);
List<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(0));
OrderElement orderElement = orderElementDAO.findUniqueByCode(code);
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(), equalTo(0));
}
@Test
public void validOrderWithCriterionRequirements()
throws InstanceNotFoundException {
String code = "order-code";
try {
orderElementDAO.findUniqueByCode(code);
fail("Order with code " + code + " already exists");
} catch (InstanceNotFoundException e) {
// It should throw an exception
}
OrderDTO orderDTO = new OrderDTO();
orderDTO.name = "Order name";
orderDTO.code = code;
orderDTO.initDate = new Date();
String name = PredefinedCriterionTypes.LEAVE.getPredefined().get(0);
String type = PredefinedCriterionTypes.LEAVE.getName();
CriterionRequirementDTO criterionRequirementDTO = new DirectCriterionRequirementDTO(
name, type);
orderDTO.criterionRequirements.add(criterionRequirementDTO);
List<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(0));
OrderElement orderElement = orderElementDAO.findUniqueByCode(code);
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(),
equalTo(1));
}
@Test
public void validOrderWithDirectCriterionRequirementsAndIndidirectCriterionRequirements()
throws InstanceNotFoundException {
String code = "order-code";
try {
orderElementDAO.findUniqueByCode(code);
fail("Order with code " + code + " already exists");
} catch (InstanceNotFoundException e) {
// It should throw an exception
}
OrderDTO orderDTO = new OrderDTO();
orderDTO.name = "Order name";
orderDTO.code = code;
orderDTO.initDate = new Date();
String name = PredefinedCriterionTypes.LEAVE.getPredefined().get(0);
String type = PredefinedCriterionTypes.LEAVE.getName();
CriterionRequirementDTO criterionRequirementDTO = new DirectCriterionRequirementDTO(
name, type);
orderDTO.criterionRequirements.add(criterionRequirementDTO);
OrderLineDTO orderLineDTO = new OrderLineDTO();
orderLineDTO.name = "Order line";
orderLineDTO.code = "order-line-code";
HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group",
ResourceEnumDTO.WORKER, 1000,
new HashSet<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
IndirectCriterionRequirementDTO indirectCriterionRequirementDTO = new IndirectCriterionRequirementDTO(
name, type, false);
orderLineDTO.criterionRequirements.add(indirectCriterionRequirementDTO);
orderDTO.children.add(orderLineDTO);
List<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(0));
OrderElement orderElement = orderElementDAO.findUniqueByCode(code);
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(), equalTo(1));
orderElement = orderElementDAO.findUniqueByCode("order-line-code");
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(), equalTo(1));
assertFalse(((IndirectCriterionRequirement) orderElement
.getCriterionRequirements().iterator().next()).isIsValid());
}
@Test
public void updateCriterionRequirements() throws InstanceNotFoundException,
IncompatibleTypeException {
String code = "order-code";
try {
orderElementDAO.findUniqueByCode(code);
fail("Order with code " + code + " already exists");
} catch (InstanceNotFoundException e) {
// It should throw an exception
}
OrderDTO orderDTO = new OrderDTO();
orderDTO.name = "Order name";
orderDTO.code = code;
orderDTO.initDate = new Date();
String name = PredefinedCriterionTypes.LEAVE.getPredefined().get(0);
String type = PredefinedCriterionTypes.LEAVE.getName();
CriterionRequirementDTO criterionRequirementDTO = new DirectCriterionRequirementDTO(
name, type);
orderDTO.criterionRequirements.add(criterionRequirementDTO);
List<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(0));
OrderElement orderElement = orderElementDAO.findUniqueByCode(code);
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(), equalTo(1));
String name2 = PredefinedCriterionTypes.LEAVE.getPredefined().get(1);
CriterionRequirementDTO criterionRequirementDTO2 = new DirectCriterionRequirementDTO(
name2, type);
orderDTO.criterionRequirements.add(criterionRequirementDTO2);
instanceConstraintViolationsList = orderElementService
.updateOrder(orderDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(0));
orderElement = orderElementDAO.findUniqueByCode(code);
assertNotNull(orderElement);
Set<CriterionRequirement> criterionRequirements = orderElement
.getCriterionRequirements();
assertThat(criterionRequirements.size(), equalTo(2));
for (CriterionRequirement criterionRequirement : criterionRequirements) {
assertThat(criterionRequirement.getCriterion().getName(), anyOf(
equalTo(name), equalTo(name2)));
assertThat(criterionRequirement.getCriterion().getType().getName(),
equalTo(type));
assertThat(criterionRequirement,
instanceOf(DirectCriterionRequirement.class));
}
}
@Test
public void updateDirectCriterionRequirementsAndIndirectCriterionRequirements()
throws InstanceNotFoundException, IncompatibleTypeException {
String code = "order-code";
try {
orderElementDAO.findUniqueByCode(code);
fail("Order with code " + code + " already exists");
} catch (InstanceNotFoundException e) {
// It should throw an exception
}
OrderDTO orderDTO = new OrderDTO();
orderDTO.name = "Order name";
orderDTO.code = code;
orderDTO.initDate = new Date();
String name = PredefinedCriterionTypes.LEAVE.getPredefined().get(0);
String type = PredefinedCriterionTypes.LEAVE.getName();
CriterionRequirementDTO criterionRequirementDTO = new DirectCriterionRequirementDTO(
name, type);
orderDTO.criterionRequirements.add(criterionRequirementDTO);
OrderLineDTO orderLineDTO = new OrderLineDTO();
orderLineDTO.name = "Order line";
orderLineDTO.code = "order-line-code";
HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group",
ResourceEnumDTO.WORKER, 1000,
new HashSet<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
orderDTO.children.add(orderLineDTO);
List<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(0));
OrderElement orderElement = orderElementDAO.findUniqueByCode(code);
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(), equalTo(1));
orderElement = orderElementDAO.findUniqueByCode("order-line-code");
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(), equalTo(1));
assertTrue(((IndirectCriterionRequirement) orderElement
.getCriterionRequirements().iterator().next()).isIsValid());
IndirectCriterionRequirementDTO indirectCriterionRequirementDTO = new IndirectCriterionRequirementDTO(
name, type, false);
orderLineDTO.criterionRequirements.add(indirectCriterionRequirementDTO);
instanceConstraintViolationsList = orderElementService
.updateOrder(orderDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(0));
orderElement = orderElementDAO.findUniqueByCode(code);
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(), equalTo(1));
orderElement = orderElementDAO.findUniqueByCode("order-line-code");
assertNotNull(orderElement);
assertThat(orderElement.getCriterionRequirements().size(), equalTo(1));
assertFalse(((IndirectCriterionRequirement) orderElement
.getCriterionRequirements().iterator().next()).isIsValid());
}
}