From e4bb2495500723b2b6671830441927d4578e2bb2 Mon Sep 17 00:00:00 2001 From: Manuel Rego Casasnovas Date: Thu, 31 Dec 2009 08:08:05 +0100 Subject: [PATCH] ItEr41S23CUImportarTraballoRealizadoPorSubcontrata: Import/update criterions information at order element service. --- .../business/common/Registry.java | 9 + .../entities/CriterionRequirementHandler.java | 6 +- .../business/orders/entities/HoursGroup.java | 5 +- .../orders/entities/ICriterionRequirable.java | 37 +++ .../orders/entities/OrderElement.java | 25 +- .../business/orders/entities/OrderLine.java | 4 + .../entities/CriterionRequirement.java | 2 +- .../IndirectCriterionRequirement.java | 4 +- .../business/resources/daos/CriterionDAO.java | 16 +- .../resources/daos/ICriterionDAO.java | 2 + .../ws/orders/impl/OrderElementConverter.java | 138 ++++++++- .../ws/orders/OrderElementServiceTest.java | 263 +++++++++++++++++- 12 files changed, 487 insertions(+), 24 deletions(-) create mode 100644 navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/ICriterionRequirable.java diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/common/Registry.java b/navalplanner-business/src/main/java/org/navalplanner/business/common/Registry.java index a7b610bab..2afbf8583 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/common/Registry.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/common/Registry.java @@ -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; + } + } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java index 869bdd2d4..0809f2048 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java @@ -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); } } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java index dffc021ca..b6a26759a 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java @@ -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 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( diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/ICriterionRequirable.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/ICriterionRequirable.java new file mode 100644 index 000000000..e89cd9361 --- /dev/null +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/ICriterionRequirable.java @@ -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 . + */ +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 + */ +public interface ICriterionRequirable { + + Set getCriterionRequirements(); + + void addCriterionRequirement(CriterionRequirement requirement); + +} diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java index fba89ece9..8c89a1a6b 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java @@ -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 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; diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java index e4754ef1f..7f1346ab1 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java @@ -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; diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/CriterionRequirement.java b/navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/CriterionRequirement.java index f46dc6e9e..ba721d940 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/CriterionRequirement.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/CriterionRequirement.java @@ -52,7 +52,7 @@ public class CriterionRequirement extends BaseEntity{ this.hoursGroup = hoursGroup; } - @NotNull + @NotNull(message = "criterion not specified") public Criterion getCriterion() { return criterion; } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/IndirectCriterionRequirement.java b/navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/IndirectCriterionRequirement.java index 5f09961dc..c87282548 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/IndirectCriterionRequirement.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/IndirectCriterionRequirement.java @@ -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; } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/CriterionDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/CriterionDAO.java index bcd4b09ad..1e7a73c6f 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/CriterionDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/CriterionDAO.java @@ -73,10 +73,20 @@ public class CriterionDAO extends GenericDAOHibernate if (criterion.getType() == null) { return new ArrayList(); } + return findByNameAndType(criterion.getName(), criterion.getType() + .getName()); + } + + @Override + public List findByNameAndType(String name, String type) { + if ((name == null) || (type == null)) { + return new ArrayList(); + } + 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) c.list(); } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/ICriterionDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/ICriterionDAO.java index 5db3931d0..ce2447293 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/ICriterionDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/resources/daos/ICriterionDAO.java @@ -53,4 +53,6 @@ public interface ICriterionDAO extends IGenericDAO { boolean thereIsOtherWithSameNameAndType(Criterion criterion); + List findByNameAndType(String name, String type); + } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementConverter.java b/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementConverter.java index ddf476c9f..87aaacca0 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementConverter.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementConverter.java @@ -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 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 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")); diff --git a/navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/orders/OrderElementServiceTest.java b/navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/orders/OrderElementServiceTest.java index 0584b2e0e..c954f11ca 100644 --- a/navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/orders/OrderElementServiceTest.java +++ b/navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/orders/OrderElementServiceTest.java @@ -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()); 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()); 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()); 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()); 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()); 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 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 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()); + orderLineDTO.hoursGroups.add(hoursGroupDTO); + IndirectCriterionRequirementDTO indirectCriterionRequirementDTO = new IndirectCriterionRequirementDTO( + name, type, false); + orderLineDTO.criterionRequirements.add(indirectCriterionRequirementDTO); + orderDTO.children.add(orderLineDTO); + + List 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 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 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()); + orderLineDTO.hoursGroups.add(hoursGroupDTO); + orderDTO.children.add(orderLineDTO); + + List 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()); + } + } \ No newline at end of file