diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderDAO.java index 5e3247778..4f34b16db 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderDAO.java @@ -23,11 +23,11 @@ package org.navalplanner.business.orders.daos; import java.util.Date; import java.util.List; -import org.navalplanner.business.common.daos.IGenericDAO; +import org.navalplanner.business.common.daos.IIntegrationEntityDAO; import org.navalplanner.business.orders.entities.Order; +import org.navalplanner.business.planner.entities.Task; import org.navalplanner.business.reports.dtos.OrderCostsPerResourceDTO; import org.navalplanner.business.users.entities.User; -import org.navalplanner.business.planner.entities.Task; /** * Contract for {@link OrderDAO} @@ -36,7 +36,7 @@ import org.navalplanner.business.planner.entities.Task; * @author Diego Pino Garcia * @author Jacobo Aragunde Pérez */ -public interface IOrderDAO extends IGenericDAO { +public interface IOrderDAO extends IIntegrationEntityDAO { /** * Gets all the orders. diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderElementDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderElementDAO.java index a51be6839..c3ed65e40 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderElementDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderElementDAO.java @@ -23,7 +23,7 @@ package org.navalplanner.business.orders.daos; import java.math.BigDecimal; import java.util.List; -import org.navalplanner.business.common.daos.IGenericDAO; +import org.navalplanner.business.common.daos.IIntegrationEntityDAO; import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.navalplanner.business.orders.entities.Order; import org.navalplanner.business.orders.entities.OrderElement; @@ -35,12 +35,10 @@ import org.navalplanner.business.templates.entities.OrderElementTemplate; * @author Diego Pino García * @author Susana Montes Pedreira */ -public interface IOrderElementDAO extends IGenericDAO { +public interface IOrderElementDAO extends IIntegrationEntityDAO { public List findWithoutParent(); - public List findByCode(String code); - public OrderElement findUniqueByCode(String code) throws InstanceNotFoundException; diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderDAO.java index 8ffd0388a..fcf1ee9d0 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderDAO.java @@ -25,9 +25,11 @@ import java.util.ArrayList; import java.util.Date; import java.util.List; +import org.apache.commons.lang.StringUtils; import org.hibernate.Query; +import org.hibernate.criterion.Restrictions; import org.joda.time.LocalDate; -import org.navalplanner.business.common.daos.GenericDAOHibernate; +import org.navalplanner.business.common.daos.IntegrationEntityDAO; import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.navalplanner.business.costcategories.daos.CostCategoryDAO; import org.navalplanner.business.costcategories.daos.ITypeOfWorkHoursDAO; @@ -48,7 +50,6 @@ import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; - /** * Dao for {@link Order} * @@ -58,7 +59,7 @@ import org.springframework.transaction.annotation.Transactional; */ @Repository @Scope(BeanDefinition.SCOPE_SINGLETON) -public class OrderDAO extends GenericDAOHibernate implements +public class OrderDAO extends IntegrationEntityDAO implements IOrderDAO { @Autowired @@ -230,4 +231,32 @@ public class OrderDAO extends GenericDAOHibernate implements } } + @Override + public List findAll() { + return getSession().createCriteria(getEntityClass()).addOrder( + org.hibernate.criterion.Order.asc("infoComponent.code")).list(); + } + + @SuppressWarnings("unchecked") + @Override + public Order findByCode(String code) throws InstanceNotFoundException { + + if (StringUtils.isBlank(code)) { + throw new InstanceNotFoundException(null, getEntityClass() + .getName()); + } + + Order entity = (Order) getSession().createCriteria(getEntityClass()) + .add( + Restrictions.eq("infoComponent.code", code.trim()) + .ignoreCase()).uniqueResult(); + + if (entity == null) { + throw new InstanceNotFoundException(code, getEntityClass() + .getName()); + } else { + return entity; + } + + } } \ No newline at end of file diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderElementDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderElementDAO.java index 47d6a74fe..3cff01bcd 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderElementDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderElementDAO.java @@ -25,12 +25,13 @@ import java.math.RoundingMode; import java.util.Iterator; import java.util.List; +import org.apache.commons.lang.StringUtils; import org.hibernate.Criteria; import org.hibernate.Query; import org.hibernate.criterion.Restrictions; import org.navalplanner.business.common.IAdHocTransactionService; import org.navalplanner.business.common.IOnTransaction; -import org.navalplanner.business.common.daos.GenericDAOHibernate; +import org.navalplanner.business.common.daos.IntegrationEntityDAO; import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.navalplanner.business.orders.entities.Order; import org.navalplanner.business.orders.entities.OrderElement; @@ -56,7 +57,7 @@ import org.springframework.transaction.annotation.Transactional; **/ @Repository @Scope(BeanDefinition.SCOPE_SINGLETON) -public class OrderElementDAO extends GenericDAOHibernate +public class OrderElementDAO extends IntegrationEntityDAO implements IOrderElementDAO { @Autowired @@ -191,10 +192,34 @@ public class OrderElementDAO extends GenericDAOHibernate } @Override - public List findByCode(String code) { - Criteria c = getSession().createCriteria(OrderElement.class); - c.add(Restrictions.eq("infoComponent.code", code).ignoreCase()); - return (List) c.list(); + public List findAll() { + return getSession().createCriteria(getEntityClass()).addOrder( + org.hibernate.criterion.Order.asc("infoComponent.code")).list(); + } + + @SuppressWarnings("unchecked") + @Override + public OrderElement findByCode(String code) + throws InstanceNotFoundException { + + if (StringUtils.isBlank(code)) { + throw new InstanceNotFoundException(null, getEntityClass() + .getName()); + } + + OrderElement entity = (OrderElement) getSession().createCriteria( + getEntityClass()) + .add( + Restrictions.eq("infoComponent.code", code.trim()) + .ignoreCase()).uniqueResult(); + + if (entity == null) { + throw new InstanceNotFoundException(code, getEntityClass() + .getName()); + } else { + return entity; + } + } public List findByTemplate(OrderElementTemplate template) { diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java index 6aacba626..6cf03c694 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java @@ -54,6 +54,13 @@ public class Order extends OrderLineGroup { return order; } + + public static Order createUnvalidated(String code) { + Order order = create(new Order(), code); + OrderLineGroup.setupOrderLineGroup(order); + return order; + } + /** * Constructor for hibernate. Do not use! */ @@ -67,7 +74,6 @@ public class Order extends OrderLineGroup { private Boolean dependenciesConstraintsHavePriority; - @NotNull(message = "order calendar not specified") private BaseCalendar calendar; private Boolean codeAutogenerated = false; @@ -274,6 +280,7 @@ public class Order extends OrderLineGroup { this.calendar = calendar; } + @NotNull(message = "order calendar not specified") public BaseCalendar getCalendar() { return calendar; } 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 84e171835..ed9c15fee 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 @@ -42,8 +42,9 @@ import org.navalplanner.business.advance.entities.DirectAdvanceAssignment; import org.navalplanner.business.advance.entities.IndirectAdvanceAssignment; import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException; import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException; -import org.navalplanner.business.common.BaseEntity; +import org.navalplanner.business.common.IntegrationEntity; import org.navalplanner.business.common.Registry; +import org.navalplanner.business.common.daos.IIntegrationEntityDAO; import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.navalplanner.business.common.exceptions.ValidationException; import org.navalplanner.business.labels.entities.Label; @@ -62,7 +63,7 @@ import org.navalplanner.business.requirements.entities.IndirectCriterionRequirem import org.navalplanner.business.templates.entities.OrderElementTemplate; import org.navalplanner.business.trees.ITreeNode; -public abstract class OrderElement extends BaseEntity implements +public abstract class OrderElement extends IntegrationEntity implements ICriterionRequirable, ITreeNode { private InfoComponent infoComponent = new InfoComponent(); @@ -1023,4 +1024,8 @@ public abstract class OrderElement extends BaseEntity implements return (measuredProgress.compareTo(new BigDecimal(100)) == 0); } + @Override + protected IIntegrationEntityDAO getIntegrationEntityDAO() { + return Registry.getOrderElementDAO(); + } } 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 272f8b05d..c3dbeef1e 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 @@ -51,6 +51,17 @@ public class OrderLine extends OrderElement { return result; } + public static OrderLine createUnvalidated(String code) { + OrderLine orderLine = create(new OrderLine(), code); + return orderLine; + } + + public static OrderLine createUnvalidatedWithUnfixedPercentage(String code, + int hours) { + OrderLine orderLine = createOrderLineWithUnfixedPercentage(hours); + return create(orderLine, code); + } + public static OrderLine createOrderLineWithUnfixedPercentage(int hours) { OrderLine result = create(); HoursGroup hoursGroup = HoursGroup.create(result); diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java index 727aec363..1517e3537 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java @@ -109,6 +109,12 @@ public class OrderLineGroup extends OrderElement implements return result; } + public static OrderLineGroup createUnvalidated(String code) { + OrderLineGroup orderLineGroup = create(new OrderLineGroup(), code); + setupOrderLineGroup(orderLineGroup); + return orderLineGroup; + } + protected static void setupOrderLineGroup(OrderLineGroup result) { IndirectAdvanceAssignment indirectAdvanceAssignment = IndirectAdvanceAssignment .create(true); diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderDTO.java b/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderDTO.java index d81aa6083..2a0a6e1ef 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderDTO.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderDTO.java @@ -25,7 +25,6 @@ import java.util.List; import java.util.Set; import javax.xml.bind.annotation.XmlAttribute; -import javax.xml.bind.annotation.XmlRootElement; import org.navalplanner.business.orders.entities.Order; @@ -34,9 +33,11 @@ import org.navalplanner.business.orders.entities.Order; * * @author Manuel Rego Casasnovas */ -@XmlRootElement(name = "order") + public class OrderDTO extends OrderLineGroupDTO { + public final static String ENTITY_TYPE = "order"; + @XmlAttribute(name = "dependencies-constraints-have-priority") public Boolean dependenciesConstraintsHavePriority; diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderElementDTO.java b/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderElementDTO.java index 4f399febf..aeaff7aa9 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderElementDTO.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderElementDTO.java @@ -28,7 +28,6 @@ import javax.xml.bind.annotation.XmlAttribute; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlElementWrapper; import javax.xml.bind.annotation.XmlElements; -import javax.xml.bind.annotation.XmlRootElement; import org.navalplanner.business.orders.entities.OrderElement; @@ -37,15 +36,14 @@ import org.navalplanner.business.orders.entities.OrderElement; * * @author Manuel Rego Casasnovas */ -@XmlRootElement(name = "order-element") -public class OrderElementDTO { + +public class OrderElementDTO extends IntegrationEntityDTO { + + public final static String ENTITY_TYPE = "order-element"; @XmlAttribute public String name; - @XmlAttribute - public String code; - @XmlAttribute(name = "init-date") public Date initDate; @@ -92,4 +90,9 @@ public class OrderElementDTO { this.criterionRequirements = criterionRequirements; } + @Override + public String getEntityType() { + return ENTITY_TYPE; + } + } \ No newline at end of file diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/impl/OrderElementConverter.java b/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/impl/OrderElementConverter.java index 626085114..16b6d3804 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/impl/OrderElementConverter.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/ws/common/impl/OrderElementConverter.java @@ -38,6 +38,7 @@ import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlob import org.navalplanner.business.calendars.entities.BaseCalendar; import org.navalplanner.business.common.Registry; import org.navalplanner.business.common.exceptions.InstanceNotFoundException; +import org.navalplanner.business.common.exceptions.ValidationException; import org.navalplanner.business.labels.entities.Label; import org.navalplanner.business.materials.entities.Material; import org.navalplanner.business.materials.entities.MaterialAssignment; @@ -58,7 +59,6 @@ import org.navalplanner.ws.common.api.AdvanceMeasurementDTO; import org.navalplanner.ws.common.api.CriterionRequirementDTO; import org.navalplanner.ws.common.api.DirectCriterionRequirementDTO; import org.navalplanner.ws.common.api.HoursGroupDTO; -import org.navalplanner.ws.common.api.IncompatibleTypeException; import org.navalplanner.ws.common.api.IndirectCriterionRequirementDTO; import org.navalplanner.ws.common.api.LabelReferenceDTO; import org.navalplanner.ws.common.api.MaterialAssignmentDTO; @@ -225,7 +225,7 @@ public final class OrderElementConverter { public final static OrderElement toEntity(OrderElementDTO orderElementDTO, ConfigurationOrderElementConverter configuration) - throws InstanceNotFoundException { + throws ValidationException { OrderElement orderElement = toEntityExceptCriterionRequirements( orderElementDTO, configuration); if (configuration.isCriterionRequirements()) { @@ -316,13 +316,14 @@ public final class OrderElementConverter { private final static OrderElement toEntityExceptCriterionRequirements( OrderElementDTO orderElementDTO, ConfigurationOrderElementConverter configuration) - throws InstanceNotFoundException { + throws ValidationException { OrderElement orderElement; if (orderElementDTO instanceof OrderLineDTO) { if ((configuration.isHoursGroups()) && (!((OrderLineDTO) orderElementDTO).hoursGroups.isEmpty())) { - orderElement = OrderLine.create(); + orderElement = OrderLine + .createUnvalidated(orderElementDTO.code); for (HoursGroupDTO hoursGroupDTO : ((OrderLineDTO) orderElementDTO).hoursGroups) { HoursGroup hoursGroup = toEntity(hoursGroupDTO, @@ -331,7 +332,8 @@ public final class OrderElementConverter { } } else { orderElement = OrderLine - .createOrderLineWithUnfixedPercentage(0); + .createUnvalidatedWithUnfixedPercentage( + orderElementDTO.code, 0); } } else { // orderElementDTO instanceof OrderLineGroupDTO List children = new ArrayList(); @@ -340,11 +342,9 @@ public final class OrderElementConverter { } if (orderElementDTO instanceof OrderDTO) { - orderElement = Order.create(); - + orderElement = Order.createUnvalidated(orderElementDTO.code); ((Order) orderElement) .setDependenciesConstraintsHavePriority(((OrderDTO) orderElementDTO).dependenciesConstraintsHavePriority); - List calendars = Registry.getBaseCalendarDAO() .findByName(((OrderDTO) orderElementDTO).calendarName); BaseCalendar calendar; @@ -356,7 +356,8 @@ public final class OrderElementConverter { } ((Order) orderElement).setCalendar(calendar); } else { // orderElementDTO instanceof OrderLineGroupDTO - orderElement = OrderLineGroup.create(); + orderElement = OrderLineGroup + .createUnvalidated(orderElementDTO.code); } for (OrderElement child : children) { @@ -372,7 +373,12 @@ public final class OrderElementConverter { if (configuration.isLabels()) { for (LabelReferenceDTO labelDTO : orderElementDTO.labels) { + try { orderElement.addLabel(LabelReferenceConverter.toEntity(labelDTO)); + } catch (InstanceNotFoundException e) { + throw new ValidationException("Label " + labelDTO.code + + " not found."); + } } } @@ -456,7 +462,7 @@ public final class OrderElementConverter { public final static void update(OrderElement orderElement, OrderElementDTO orderElementDTO, ConfigurationOrderElementConverter configuration) - throws IncompatibleTypeException, InstanceNotFoundException { + throws ValidationException { updateExceptCriterionRequirements(orderElement, orderElementDTO, configuration); if (configuration.isCriterionRequirements()) { @@ -467,12 +473,14 @@ public final class OrderElementConverter { private final static void updateExceptCriterionRequirements( OrderElement orderElement, OrderElementDTO orderElementDTO, ConfigurationOrderElementConverter configuration) - throws IncompatibleTypeException, InstanceNotFoundException { + throws ValidationException { if (orderElementDTO instanceof OrderLineDTO) { if (!(orderElement instanceof OrderLine)) { - throw new IncompatibleTypeException(orderElement.getCode(), - OrderLine.class, orderElement.getClass()); + throw new ValidationException(_( + "Order element {0} : OrderLineGroup is incompatible type with {1}" + + orderElement.getCode(), orderElement + .getClass().getName())); } if (configuration.isHoursGroups()) { @@ -492,8 +500,11 @@ public final class OrderElementConverter { } else { // orderElementDTO instanceof OrderLineGroupDTO if (orderElementDTO instanceof OrderDTO) { if (!(orderElement instanceof Order)) { - throw new IncompatibleTypeException(orderElement.getCode(), - Order.class, orderElement.getClass()); + throw new ValidationException(_( + "Order element {0} : Order is incompatible type with {1}" + + orderElement.getCode(), orderElement + .getClass().getName())); + } Boolean dependenciesConstraintsHavePriority = ((OrderDTO) orderElementDTO).dependenciesConstraintsHavePriority; @@ -518,8 +529,10 @@ public final class OrderElementConverter { } } else { // orderElementDTO instanceof OrderLineGroupDTO if (!(orderElement instanceof OrderLineGroup)) { - throw new IncompatibleTypeException(orderElement.getCode(), - OrderLineGroup.class, orderElement.getClass()); + throw new ValidationException(_( + "Order element {0} : OrderLineGroup is incompatible type with {1}" + + orderElement.getCode(), orderElement + .getClass().getName())); } } @@ -538,7 +551,12 @@ public final class OrderElementConverter { if (configuration.isLabels()) { for (LabelReferenceDTO labelDTO : orderElementDTO.labels) { if (!orderElement.containsLabel(labelDTO.code)) { + try { orderElement.addLabel(LabelReferenceConverter.toEntity(labelDTO)); + } catch (InstanceNotFoundException e) { + throw new ValidationException("Label " + labelDTO.code + + " not found"); + } } } } @@ -584,7 +602,7 @@ public final class OrderElementConverter { HoursGroupDTO hoursGroupDTO, ConfigurationOrderElementConverter configuration) { if (!hoursGroup.getCode().equals(hoursGroupDTO.code)) { - throw new RuntimeException( + throw new ValidationException( _("Not the same hours group, impossible to update")); } @@ -602,7 +620,8 @@ public final class OrderElementConverter { MaterialAssignmentDTO materialAssignmentDTO) { if (!materialAssignment.getMaterial().getCode().equals( materialAssignmentDTO.materialCode)) { - throw new RuntimeException(_("Not the same material, impossible to update")); + throw new ValidationException( + _("Not the same material, impossible to update")); } if (materialAssignmentDTO.units != null) { @@ -652,9 +671,13 @@ public final class OrderElementConverter { directAdvanceAssignment = orderElement .addSubcontractorAdvanceAssignment(); } catch (DuplicateValueTrueReportGlobalAdvanceException e) { - throw new RuntimeException(e); + throw new ValidationException( + _("Duplicate value true report global Advance for order element " + + orderElement.getCode())); } catch (DuplicateAdvanceAssignmentForOrderElementException e) { - throw new RuntimeException(e); + throw new ValidationException( + _("Duplicate advance assignment for order element " + + orderElement.getCode())); } } return directAdvanceAssignment; diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/IOrderElementService.java b/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/IOrderElementService.java index 52a18c7fe..23a15d729 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/IOrderElementService.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/IOrderElementService.java @@ -20,12 +20,8 @@ package org.navalplanner.ws.orders.api; -import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.navalplanner.business.orders.entities.OrderElement; -import org.navalplanner.ws.common.api.IncompatibleTypeException; import org.navalplanner.ws.common.api.InstanceConstraintViolationsListDTO; -import org.navalplanner.ws.common.api.OrderDTO; -import org.navalplanner.ws.common.api.OrderElementDTO; /** * Service for managing {@link OrderElement} entities. @@ -34,12 +30,8 @@ import org.navalplanner.ws.common.api.OrderElementDTO; */ public interface IOrderElementService { - OrderElementDTO getOrderElement(String code) - throws InstanceNotFoundException; + InstanceConstraintViolationsListDTO addOrders(OrderListDTO orderListDTO); - InstanceConstraintViolationsListDTO addOrder(OrderDTO order); - - InstanceConstraintViolationsListDTO updateOrder(OrderDTO orderDTO) - throws InstanceNotFoundException, IncompatibleTypeException; + OrderListDTO getOrders(); } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/OrderListDTO.java b/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/OrderListDTO.java new file mode 100644 index 000000000..5744513b9 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/OrderListDTO.java @@ -0,0 +1,49 @@ +/* + * This file is part of NavalPlan + * + * 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.ws.orders.api; + +import java.util.ArrayList; +import java.util.List; + +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlRootElement; + +import org.navalplanner.ws.common.api.OrderDTO; + +/** + * DTO for a list of Order entities. + * @author Susana Montes Pedreira + */ + +@XmlRootElement(name = "order-list") +public class OrderListDTO { + + @XmlElement(name = "order") + public List orderDTOs = new ArrayList(); + + public OrderListDTO() { + } + + public OrderListDTO(List orderDTOs) { + this.orderDTOs = orderDTOs; + } + +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementServiceREST.java b/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementServiceREST.java index f1523e29f..7dd6d8153 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementServiceREST.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementServiceREST.java @@ -20,32 +20,24 @@ package org.navalplanner.ws.orders.impl; -import java.util.ArrayList; -import java.util.List; - import javax.ws.rs.Consumes; import javax.ws.rs.GET; import javax.ws.rs.POST; -import javax.ws.rs.PUT; import javax.ws.rs.Path; -import javax.ws.rs.PathParam; import javax.ws.rs.Produces; -import org.navalplanner.business.common.exceptions.InstanceNotFoundException; +import org.navalplanner.business.common.daos.IIntegrationEntityDAO; import org.navalplanner.business.common.exceptions.ValidationException; -import org.navalplanner.business.orders.daos.IOrderElementDAO; +import org.navalplanner.business.orders.daos.IOrderDAO; import org.navalplanner.business.orders.entities.Order; -import org.navalplanner.business.orders.entities.OrderElement; -import org.navalplanner.ws.common.api.IncompatibleTypeException; -import org.navalplanner.ws.common.api.InstanceConstraintViolationsDTO; import org.navalplanner.ws.common.api.InstanceConstraintViolationsListDTO; import org.navalplanner.ws.common.api.OrderDTO; -import org.navalplanner.ws.common.api.OrderElementDTO; import org.navalplanner.ws.common.impl.ConfigurationOrderElementConverter; -import org.navalplanner.ws.common.impl.ConstraintViolationConverter; +import org.navalplanner.ws.common.impl.GenericRESTService; import org.navalplanner.ws.common.impl.OrderElementConverter; -import org.navalplanner.ws.common.impl.Util; +import org.navalplanner.ws.common.impl.RecoverableErrorException; import org.navalplanner.ws.orders.api.IOrderElementService; +import org.navalplanner.ws.orders.api.OrderListDTO; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @@ -58,91 +50,51 @@ import org.springframework.transaction.annotation.Transactional; @Path("/orderelements/") @Produces("application/xml") @Service("orderElementServiceREST") -public class OrderElementServiceREST implements IOrderElementService { +public class OrderElementServiceREST extends + GenericRESTService implements + IOrderElementService { @Autowired - private IOrderElementDAO orderElementDAO; + private IOrderDAO orderDAO; @Override @GET - @Path("/{code}") @Transactional(readOnly = true) - public OrderElementDTO getOrderElement(@PathParam("code") String code) - throws InstanceNotFoundException { - return OrderElementConverter.toDTO(orderElementDAO - .findUniqueByCode(code), ConfigurationOrderElementConverter - .noAdvanceMeasurements()); + public OrderListDTO getOrders() { + return new OrderListDTO(findAll()); } @Override @POST @Consumes("application/xml") - @Transactional - public InstanceConstraintViolationsListDTO addOrder(OrderDTO orderDTO) { - - List instanceConstraintViolationsList = new ArrayList(); - - InstanceConstraintViolationsDTO instanceConstraintViolationsDTO = null; - try { - OrderElement orderElement = OrderElementConverter.toEntity( - orderDTO, ConfigurationOrderElementConverter - .all()); - - orderElement.validate(); - orderElementDAO.save(orderElement); - } catch (ValidationException e) { - instanceConstraintViolationsDTO = ConstraintViolationConverter - .toDTO(Util.generateInstanceId(1, orderDTO.code), e - .getInvalidValues()); - } catch (InstanceNotFoundException e) { - instanceConstraintViolationsDTO = InstanceConstraintViolationsDTO - .create(Util.generateInstanceId(1, orderDTO.code), e - .getMessage()); - } - - if (instanceConstraintViolationsDTO != null) { - instanceConstraintViolationsList - .add(instanceConstraintViolationsDTO); - } - - return new InstanceConstraintViolationsListDTO( - instanceConstraintViolationsList); + public InstanceConstraintViolationsListDTO addOrders( + OrderListDTO orderListDTO) { + return save(orderListDTO.orderDTOs); } @Override - @PUT - @Consumes("application/xml") - @Transactional - public InstanceConstraintViolationsListDTO updateOrder(OrderDTO orderDTO) - throws InstanceNotFoundException, IncompatibleTypeException { - OrderElement orderElement = orderElementDAO - .findUniqueByCode(orderDTO.code); - if (!(orderElement instanceof Order)) { - throw new IncompatibleTypeException(orderElement.getCode(), - Order.class, orderElement.getClass()); - } + protected OrderDTO toDTO(Order entity) { + return (OrderDTO) OrderElementConverter.toDTO(entity, + ConfigurationOrderElementConverter.all()); + } - List instanceConstraintViolationsList = new ArrayList(); + @Override + protected IIntegrationEntityDAO getIntegrationEntityDAO() { + return orderDAO; + } - InstanceConstraintViolationsDTO instanceConstraintViolationsDTO = null; - try { - OrderElementConverter.update((Order) orderElement, orderDTO, + @Override + protected Order toEntity(OrderDTO entityDTO) throws ValidationException, + RecoverableErrorException { + return (Order) OrderElementConverter.toEntity(entityDTO, + ConfigurationOrderElementConverter.all()); + } + + @Override + protected void updateEntity(Order entity, OrderDTO entityDTO) + throws ValidationException, RecoverableErrorException { + OrderElementConverter.update(entity, entityDTO, ConfigurationOrderElementConverter.all()); - orderElement.validate(); - orderElementDAO.save(orderElement); - } catch (ValidationException e) { - instanceConstraintViolationsDTO = ConstraintViolationConverter - .toDTO(Util.generateInstanceId(1, orderDTO.code), e - .getInvalidValues()); - } - - if (instanceConstraintViolationsDTO != null) { - instanceConstraintViolationsList - .add(instanceConstraintViolationsDTO); - } - - return new InstanceConstraintViolationsListDTO( - instanceConstraintViolationsList); } } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/ws/subcontract/impl/SubcontractServiceREST.java b/navalplanner-webapp/src/main/java/org/navalplanner/ws/subcontract/impl/SubcontractServiceREST.java index 9eb248358..94b8a8d02 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/ws/subcontract/impl/SubcontractServiceREST.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/ws/subcontract/impl/SubcontractServiceREST.java @@ -154,10 +154,6 @@ public class SubcontractServiceREST implements ISubcontractService { instanceConstraintViolationsDTO = ConstraintViolationConverter .toDTO(Util.generateInstanceId(1, orderElementDTO.code), e .getInvalidValues()); - } catch (InstanceNotFoundException e) { - instanceConstraintViolationsDTO = InstanceConstraintViolationsDTO - .create(Util.generateInstanceId(1, orderElementDTO.code), e - .getMessage()); } if (instanceConstraintViolationsDTO != null) { diff --git a/navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/labels/api/LabelServiceTest.java b/navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/labels/api/LabelServiceTest.java index c1723d100..87d36ed69 100644 --- a/navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/labels/api/LabelServiceTest.java +++ b/navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/labels/api/LabelServiceTest.java @@ -24,6 +24,7 @@ import static org.hamcrest.CoreMatchers.anyOf; import static org.hamcrest.CoreMatchers.equalTo; 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; import static org.navalplanner.web.test.WebappGlobalNames.WEBAPP_SPRING_CONFIG_TEST_FILE; @@ -96,20 +97,27 @@ public class LabelServiceTest { @Test public void exportLabelTypes() { + int previous = labelTypeDAO.getAll().size(); LabelTypeListDTO labelTypes = labelService.getLabelTypes(); - assertTrue(labelTypes.labelTypes.isEmpty()); + assertTrue(labelTypes.labelTypes.size() == previous); } @Test public void exportLabelTypes2() { + int previous = labelTypeDAO.getAll().size(); + LabelType labelType = givenLabelTypeStored(); LabelTypeListDTO labelTypes = labelService.getLabelTypes(); - assertThat(labelTypes.labelTypes.size(), equalTo(1)); + assertThat(labelTypes.labelTypes.size(), equalTo(previous + 1)); - LabelTypeDTO labelTypeDTO = labelTypes.labelTypes.get(0); - assertThat(labelTypeDTO.code, equalTo(labelType.getCode())); - assertThat(labelTypeDTO.labels.size(), equalTo(2)); + for (LabelTypeDTO typeDTO : labelTypes.labelTypes) { + if ((typeDTO.code.equalsIgnoreCase(labelType.getCode())) + && (typeDTO.labels.size() == 2)) { + return; + } + } + fail(); } @Test @@ -138,7 +146,8 @@ public class LabelServiceTest { public void importValidLabelType() { int previous = labelTypeDAO.getAll().size(); - LabelTypeDTO labelTypeDTO = new LabelTypeDTO("label-type-name1", + LabelTypeDTO labelTypeDTO = new LabelTypeDTO("label-type-name" + + UUID.randomUUID().toString(), new ArrayList()); List instanceConstraintViolationsList = labelService @@ -147,18 +156,18 @@ public class LabelServiceTest { assertThat(labelTypeDAO.getAll().size(), equalTo(previous + 1)); - LabelType labelType = labelTypeDAO.getAll().get(0); - assertThat(labelType.getName(), equalTo(labelTypeDTO.name)); - assertThat(labelType.getLabels().size(), equalTo(0)); } @Test public void importTwoValidLabelType() { int previous = labelTypeDAO.getAll().size(); - LabelTypeDTO labelTypeDTO1 = new LabelTypeDTO("label-type-A", + String nameType1 = "label-type-" + UUID.randomUUID().toString(); + String nameType2 = "label-type-" + UUID.randomUUID().toString(); + + LabelTypeDTO labelTypeDTO1 = new LabelTypeDTO(nameType1, new ArrayList()); - LabelTypeDTO labelTypeDTO2 = new LabelTypeDTO("label-type-B", + LabelTypeDTO labelTypeDTO2 = new LabelTypeDTO(nameType2, new ArrayList()); LabelTypeListDTO labelTypeDTOs = createLabelTypeListDTO(labelTypeDTO1, @@ -171,11 +180,22 @@ public class LabelServiceTest { List labelTypes = labelTypeDAO.getAll(); assertThat(labelTypes.size(), equalTo(previous + 2)); + + int cont = 0; for (LabelType labelType : labelTypes) { - assertThat(labelType.getName(), anyOf(equalTo(labelTypeDTO1.name), - equalTo(labelTypeDTO2.name), equalTo("label-type-name1"))); - assertThat(labelType.getLabels().size(), equalTo(0)); + if (labelType.getName().equals(nameType1)) { + cont++; + } } + assertThat(cont, equalTo(1)); + + cont = 0; + for (LabelType labelType : labelTypes) { + if (labelType.getName().equals(nameType2)) { + cont++; + } + } + assertThat(cont, equalTo(1)); } @Test 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 04f026248..a674aff9f 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,7 +22,6 @@ 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.assertThat; @@ -35,6 +34,7 @@ import static org.navalplanner.web.test.WebappGlobalNames.WEBAPP_SPRING_CONFIG_T import static org.navalplanner.web.test.ws.common.Util.mustEnd; import java.math.BigDecimal; +import java.util.ArrayList; import java.util.Date; import java.util.HashSet; import java.util.List; @@ -46,7 +46,6 @@ import javax.annotation.Resource; import org.hibernate.SessionFactory; import org.joda.time.LocalDate; -import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.navalplanner.business.IDataBootstrap; @@ -60,7 +59,6 @@ import org.navalplanner.business.materials.entities.MaterialAssignment; import org.navalplanner.business.orders.daos.IOrderDAO; import org.navalplanner.business.orders.daos.IOrderElementDAO; import org.navalplanner.business.orders.entities.HoursGroup; -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.requirements.entities.CriterionRequirement; @@ -83,7 +81,9 @@ import org.navalplanner.ws.common.api.OrderLineDTO; import org.navalplanner.ws.common.api.OrderLineGroupDTO; import org.navalplanner.ws.common.api.ResourceEnumDTO; import org.navalplanner.ws.orders.api.IOrderElementService; +import org.navalplanner.ws.orders.api.OrderListDTO; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.annotation.Rollback; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.transaction.annotation.Transactional; @@ -112,7 +112,8 @@ public class OrderElementServiceTest { @Resource private IDataBootstrap criterionsBootstrap; - @Before + @Test + @Rollback(false) public void loadRequiredaData() { defaultAdvanceTypesBootstrapListener.loadRequiredData(); configurationBootstrap.loadRequiredData(); @@ -135,8 +136,12 @@ public class OrderElementServiceTest { @Autowired private SessionFactory sessionFactory; - private Label givenLabelStored() { - Label label = Label.create("label-name-" + UUID.randomUUID()); + private static String labelCode = "label-code-" + UUID.randomUUID(); + + @Test + @Rollback(false) + public void givenLabelStored() { + Label label = Label.create(labelCode, "labelName"); LabelType labelType = LabelType.create("label-type-" + UUID.randomUUID()); @@ -149,8 +154,6 @@ public class OrderElementServiceTest { labelType.dontPoseAsTransientObjectAnymore(); label.dontPoseAsTransientObjectAnymore(); - - return label; } @Test @@ -159,15 +162,20 @@ public class OrderElementServiceTest { OrderDTO orderDTO = new OrderDTO(); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; + + assertTrue(instanceConstraintViolationsList.toString(), + instanceConstraintViolationsList.size() == 1); assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList .get(0).constraintViolations; - // Mandatory fields: code, name. Check constraints: + // Mandatory fields: code, infoComponent.code, infoComponent.name. Check + // constraints: // checkConstraintOrderMustHaveStartDate - assertThat(constraintViolations.size(), equalTo(3)); + assertThat(constraintViolations.size(), equalTo(4)); assertThat(orderDAO.getOrders().size(), equalTo(previous)); } @@ -179,9 +187,12 @@ public class OrderElementServiceTest { OrderDTO orderDTO = new OrderDTO(); orderDTO.code = "order-code"; + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; - assertThat(instanceConstraintViolationsList.size(), equalTo(1)); + .addOrders(orderListDTO).instanceConstraintViolationsList; + + assertTrue(instanceConstraintViolationsList.toString(), + instanceConstraintViolationsList.size() == 1); List constraintViolations = instanceConstraintViolationsList .get(0).constraintViolations; @@ -199,15 +210,16 @@ public class OrderElementServiceTest { OrderDTO orderDTO = new OrderDTO(); orderDTO.name = "Order name"; + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList .get(0).constraintViolations; - // Mandatory fields: code. Check constraints: + // Mandatory fields: code, infoComponentCode. Check constraints: // checkConstraintOrderMustHaveStartDate - assertThat(constraintViolations.size(), equalTo(2)); + assertThat(constraintViolations.size(), equalTo(3)); assertThat(orderDAO.getOrders().size(), equalTo(previous)); } @@ -219,14 +231,15 @@ public class OrderElementServiceTest { OrderDTO orderDTO = new OrderDTO(); orderDTO.initDate = new Date(); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList .get(0).constraintViolations; - // Mandatory fields: code, name - assertThat(constraintViolations.size(), equalTo(2)); + // Mandatory fields: code,infoComponent.code, infoComponent.name + assertThat(constraintViolations.size(), equalTo(3)); for (ConstraintViolationDTO constraintViolationDTO : constraintViolations) { assertThat(constraintViolationDTO.fieldName, anyOf(mustEnd("code"), mustEnd("name"))); @@ -238,19 +251,19 @@ public class OrderElementServiceTest { @Test public void validOrder() { String code = "order-code"; - int previous = orderElementDAO.findByCode(code).size(); OrderDTO orderDTO = new OrderDTO(); orderDTO.name = "Order name"; orderDTO.code = code; orderDTO.initDate = new Date(); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; - assertThat(instanceConstraintViolationsList.size(), equalTo(0)); + .addOrders(orderListDTO).instanceConstraintViolationsList; + + assertTrue(instanceConstraintViolationsList.toString(), + instanceConstraintViolationsList.size() == 0); - assertThat(orderElementDAO.findByCode(code).size(), - equalTo(previous + 1)); } @Test @@ -265,14 +278,16 @@ public class OrderElementServiceTest { OrderLineDTO orderLineDTO = new OrderLineDTO(); orderDTO.children.add(orderLineDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList .get(0).constraintViolations; - // Mandatory fields: code, name, hours group code. - assertThat(constraintViolations.size(), equalTo(3)); + // Mandatory fields: code,infoComponent.code, infoComponent.name, hours + // group code. + assertThat(constraintViolations.size(), equalTo(4)); assertThat(orderDAO.getOrders().size(), equalTo(previous)); } @@ -294,8 +309,9 @@ public class OrderElementServiceTest { orderLineDTO.hoursGroups.add(hoursGroupDTO); orderDTO.children.add(orderLineDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList @@ -313,7 +329,6 @@ public class OrderElementServiceTest { @Test public void validOrderWithOrderLine() { String code = "order-code"; - int previous = orderElementDAO.findByCode(code).size(); OrderDTO orderDTO = new OrderDTO(); orderDTO.name = "Order name"; @@ -329,12 +344,17 @@ public class OrderElementServiceTest { orderLineDTO.hoursGroups.add(hoursGroupDTO); orderDTO.children.add(orderLineDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); - assertThat(orderElementDAO.findByCode(code).size(), - equalTo(previous + 1)); + try { + orderElementDAO.findByCode(code); + assertTrue(true); + } catch (InstanceNotFoundException e) { + fail(); + } } @Test @@ -349,15 +369,17 @@ public class OrderElementServiceTest { OrderLineGroupDTO orderLineGroupDTO = new OrderLineGroupDTO(); orderDTO.children.add(orderLineGroupDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList .get(0).constraintViolations; - // Mandatory fields: code, name. Check constraints: + // Mandatory fields: code,infoComponent.code, infoComponenet.name. Check + // constraints: // checkConstraintAtLeastOneHoursGroupForEachOrderElement - assertThat(constraintViolations.size(), equalTo(3)); + assertThat(constraintViolations.size(), equalTo(4)); assertThat(orderDAO.getOrders().size(), equalTo(previous)); } @@ -376,8 +398,9 @@ public class OrderElementServiceTest { orderLineGroupDTO.code = "order-line-group-code"; orderDTO.children.add(orderLineGroupDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList @@ -391,22 +414,22 @@ public class OrderElementServiceTest { @Test public void validOrderWithOrderLineGroup() { - String code = "order-code"; - int previous = orderElementDAO.findByCode(code).size(); + String code = UUID.randomUUID().toString(); OrderDTO orderDTO = new OrderDTO(); - orderDTO.name = "Order name"; + orderDTO.name = "Order name A"; orderDTO.code = code; orderDTO.initDate = new Date(); OrderLineGroupDTO orderLineGroupDTO = new OrderLineGroupDTO(); - orderLineGroupDTO.name = "Order line group"; - orderLineGroupDTO.code = "order-line-group-code"; + orderLineGroupDTO.name = "Order line group A"; + orderLineGroupDTO.code = "order-line-group-code-A"; OrderLineDTO orderLineDTO = new OrderLineDTO(); - orderLineDTO.name = "Order line"; - orderLineDTO.code = "order-line-code"; - HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group", + orderLineDTO.name = "Order line A"; + orderLineDTO.code = "order-line-code-A"; + HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group-" + + UUID.randomUUID().toString(), ResourceEnumDTO.WORKER, 1000, new HashSet()); orderLineDTO.hoursGroups.add(hoursGroupDTO); @@ -414,12 +437,18 @@ public class OrderElementServiceTest { orderDTO.children.add(orderLineGroupDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; - assertThat(instanceConstraintViolationsList.size(), equalTo(0)); + .addOrders(orderListDTO).instanceConstraintViolationsList; + assertTrue(instanceConstraintViolationsList.toString(), + instanceConstraintViolationsList.size() == 0); - assertThat(orderElementDAO.findByCode(code).size(), - equalTo(previous + 1)); + try { + orderElementDAO.findByCode(code); + assertTrue(true); + } catch (InstanceNotFoundException e) { + fail(); + } } @Test @@ -434,8 +463,9 @@ public class OrderElementServiceTest { MaterialAssignmentDTO materialAssignmentDTO = new MaterialAssignmentDTO(); orderDTO.materialAssignments.add(materialAssignmentDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList @@ -460,8 +490,9 @@ public class OrderElementServiceTest { materialAssignmentDTO.materialCode = "material-code"; orderDTO.materialAssignments.add(materialAssignmentDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList @@ -479,7 +510,6 @@ public class OrderElementServiceTest { @Test public void validOrderWithMaterialAssignment() { String code = "order-code"; - int previous = orderElementDAO.findByCode(code).size(); OrderDTO orderDTO = new OrderDTO(); orderDTO.name = "Order name"; @@ -492,12 +522,17 @@ public class OrderElementServiceTest { materialAssignmentDTO.units = 100.0; orderDTO.materialAssignments.add(materialAssignmentDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); - assertThat(orderElementDAO.findByCode(code).size(), - equalTo(previous + 1)); + try { + orderElementDAO.findByCode(code); + assertTrue(true); + } catch (InstanceNotFoundException e) { + fail(); + } } @Test @@ -512,8 +547,9 @@ public class OrderElementServiceTest { LabelReferenceDTO labelReferenceDTO = new LabelReferenceDTO(); orderDTO.labels.add(labelReferenceDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList @@ -526,7 +562,6 @@ public class OrderElementServiceTest { @Test public void validOrderWithLabel() { String code = "order-code"; - int previous = orderElementDAO.findByCode(code).size(); OrderDTO orderDTO = new OrderDTO(); orderDTO.name = "Order name"; @@ -534,15 +569,20 @@ public class OrderElementServiceTest { orderDTO.initDate = new Date(); LabelReferenceDTO labelReferenceDTO = new LabelReferenceDTO(); - labelReferenceDTO.code = givenLabelStored().getCode(); + labelReferenceDTO.code = labelCode; orderDTO.labels.add(labelReferenceDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); - assertThat(orderElementDAO.findByCode(code).size(), - equalTo(previous + 1)); + try { + orderElementDAO.findByCode(code); + assertTrue(true); + } catch (InstanceNotFoundException e) { + fail(); + } } @Test @@ -555,7 +595,7 @@ public class OrderElementServiceTest { orderDTO.initDate = new Date(); LabelReferenceDTO labelReferenceDTO = new LabelReferenceDTO(); - labelReferenceDTO.code = givenLabelStored().getCode(); + labelReferenceDTO.code = labelCode; orderDTO.labels.add(labelReferenceDTO); OrderLineDTO orderLineDTO = new OrderLineDTO(); @@ -568,25 +608,19 @@ public class OrderElementServiceTest { orderLineDTO.labels.add(labelReferenceDTO); orderDTO.children.add(orderLineDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; - assertThat(instanceConstraintViolationsList.size(), equalTo(0)); + .addOrders(orderListDTO).instanceConstraintViolationsList; + assertTrue(instanceConstraintViolationsList.toString(), + instanceConstraintViolationsList.size() == 1); - assertThat(orderDAO.getOrders().size(), equalTo(previous + 1)); - - Order order = orderDAO.getOrders().get(previous); - assertThat(order.getLabels().size(), equalTo(1)); - assertThat(order.getLabels().iterator().next().getCode(), - equalTo(labelReferenceDTO.code)); - - OrderElement orderElement = order.getChildren().get(0); - assertThat(orderElement.getLabels().size(), equalTo(0)); + assertThat(orderDAO.getOrders().size(), equalTo(previous)); } @Test public void updateLabels() throws InstanceNotFoundException, IncompatibleTypeException { - String code = "order-code"; + String code = "order-code-" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -599,37 +633,41 @@ public class OrderElementServiceTest { orderDTO.code = code; orderDTO.initDate = new Date(); - LabelReferenceDTO labelReferenceDTO = new LabelReferenceDTO(givenLabelStored() - .getCode()); + LabelReferenceDTO labelReferenceDTO = new LabelReferenceDTO( +labelCode); orderDTO.labels.add(labelReferenceDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); OrderElement orderElement = orderElementDAO.findUniqueByCode(code); assertNotNull(orderElement); assertThat(orderElement.getLabels().size(), equalTo(1)); - LabelReferenceDTO labelReferenceDTO2 = new LabelReferenceDTO(givenLabelStored() - .getCode()); + orderElementDAO.flush(); + sessionFactory.getCurrentSession().evict(orderElement); + + LabelReferenceDTO labelReferenceDTO2 = new LabelReferenceDTO( +labelCode); orderDTO.labels.add(labelReferenceDTO2); + + orderListDTO = createOrderListDTO(orderDTO); instanceConstraintViolationsList = orderElementService - .updateOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; + assertThat(instanceConstraintViolationsList.size(), equalTo(0)); orderElement = orderElementDAO.findUniqueByCode(code); - assertThat(orderElement.getLabels().size(), equalTo(2)); - for (Label label : orderElement.getLabels()) { - assertThat(label.getCode(), anyOf(equalTo(labelReferenceDTO.code), - equalTo(labelReferenceDTO2.code))); - } + // update the same label + assertThat(orderElement.getLabels().size(), equalTo(1)); } @Test public void updateMaterialAssignment() throws InstanceNotFoundException, IncompatibleTypeException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -646,25 +684,32 @@ public class OrderElementServiceTest { "material-code", 100.0, BigDecimal.TEN, null); orderDTO.materialAssignments.add(materialAssignmentDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); OrderElement orderElement = orderElementDAO.findUniqueByCode(code); assertNotNull(orderElement); assertThat(orderElement.getMaterialAssignments().size(), equalTo(1)); + orderElementDAO.flush(); + sessionFactory.getCurrentSession().evict(orderElement); + orderDTO.materialAssignments.iterator().next().units = 150.0; MaterialAssignmentDTO materialAssignmentDTO2 = new MaterialAssignmentDTO( "material-code2", 200.0, BigDecimal.ONE, null); + orderDTO.materialAssignments.add(materialAssignmentDTO); orderDTO.materialAssignments.add(materialAssignmentDTO2); + orderListDTO = createOrderListDTO(orderDTO); instanceConstraintViolationsList = orderElementService - .updateOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); orderElement = orderElementDAO.findUniqueByCode(code); + assertThat(orderElement.getMaterialAssignments().size(), equalTo(2)); for (MaterialAssignment materialAssignment : orderElement .getMaterialAssignments()) { @@ -673,14 +718,16 @@ public class OrderElementServiceTest { assertThat(materialAssignment.getUnits(), anyOf(equalTo(150.0), equalTo(200.0))); assertThat(materialAssignment.getUnitPrice(), anyOf( - equalTo(BigDecimal.TEN), equalTo(BigDecimal.ONE))); + equalTo(BigDecimal.TEN.setScale(2)), + equalTo(BigDecimal.ONE + .setScale(2)))); } } @Test public void updateHoursGroup() throws InstanceNotFoundException, IncompatibleTypeException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -695,48 +742,55 @@ public class OrderElementServiceTest { OrderLineDTO orderLineDTO = new OrderLineDTO(); orderLineDTO.name = "Order line"; - orderLineDTO.code = "order-line-code"; - HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group", + orderLineDTO.code = "order-line-code" + UUID.randomUUID().toString(); + HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-groupYY", ResourceEnumDTO.WORKER, 1000, new HashSet()); orderLineDTO.hoursGroups.add(hoursGroupDTO); orderDTO.children.add(orderLineDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; - assertThat(instanceConstraintViolationsList.size(), equalTo(0)); + .addOrders(orderListDTO).instanceConstraintViolationsList; + assertTrue(instanceConstraintViolationsList.toString(), + instanceConstraintViolationsList.size() == 0); OrderElement orderElement = orderElementDAO.findUniqueByCode(code); assertNotNull(orderElement); OrderLine orderLine = (OrderLine) orderElementDAO - .findUniqueByCode("order-line-code"); + .findUniqueByCode(orderLineDTO.code); assertNotNull(orderLine); assertThat(orderLine.getHoursGroups().size(), equalTo(1)); + orderElementDAO.flush(); + sessionFactory.getCurrentSession().evict(orderElement); + sessionFactory.getCurrentSession().evict(orderLine); + orderLineDTO.hoursGroups.iterator().next().workingHours = 1500; - HoursGroupDTO hoursGroupDTO2 = new HoursGroupDTO("hours-group2", + HoursGroupDTO hoursGroupDTO2 = new HoursGroupDTO("hours-groupXX", ResourceEnumDTO.WORKER, 2000, new HashSet()); orderLineDTO.hoursGroups.add(hoursGroupDTO2); + orderListDTO = createOrderListDTO(orderDTO); instanceConstraintViolationsList = orderElementService - .updateOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); orderElement = orderElementDAO.findUniqueByCode(code); assertNotNull(orderElement); orderLine = (OrderLine) orderElementDAO - .findUniqueByCode("order-line-code"); + .findUniqueByCode(orderLineDTO.code); assertNotNull(orderLine); assertThat(orderLine.getHoursGroups().size(), equalTo(2)); for (HoursGroup hoursGroup : orderLine.getHoursGroups()) { - assertThat(hoursGroup.getCode(), anyOf(equalTo("hours-group"), - equalTo("hours-group2"))); - assertThat(hoursGroup.getWorkingHours(), anyOf( - equalTo(1500), equalTo(2000))); + assertThat(hoursGroup.getCode(), anyOf(equalTo("hours-groupYY"), + equalTo("hours-groupXX"))); + assertThat(hoursGroup.getWorkingHours(), anyOf(equalTo(1500), + equalTo(2000))); assertThat(hoursGroup.getResourceType(), equalTo(ResourceEnum.WORKER)); } @@ -746,7 +800,7 @@ public class OrderElementServiceTest { // FIXME move to subcontractors service when it exists public void invalidOrderWithInvalidAdvanceMeasurements() throws InstanceNotFoundException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -762,8 +816,9 @@ public class OrderElementServiceTest { AdvanceMeasurementDTO advanceMeasurementDTO = new AdvanceMeasurementDTO(); orderDTO.advanceMeasurements.add(advanceMeasurementDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(1)); List constraintViolations = instanceConstraintViolationsList @@ -787,7 +842,7 @@ public class OrderElementServiceTest { // FIXME move to subcontractors service when it exists public void validOrderWithAdvanceMeasurements() throws InstanceNotFoundException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -804,8 +859,9 @@ public class OrderElementServiceTest { new Date(), BigDecimal.TEN); orderDTO.advanceMeasurements.add(advanceMeasurementDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); OrderElement orderElement = orderElementDAO.findUniqueByCode(code); @@ -821,7 +877,7 @@ public class OrderElementServiceTest { // FIXME move to subcontractors service when it exists public void updateAdvanceMeasurements() throws InstanceNotFoundException, IncompatibleTypeException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -839,8 +895,9 @@ public class OrderElementServiceTest { date.toDateTimeAtStartOfDay().toDate(), new BigDecimal(15)); orderDTO.advanceMeasurements.add(advanceMeasurementDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); OrderElement orderElement = orderElementDAO.findUniqueByCode(code); @@ -851,12 +908,18 @@ public class OrderElementServiceTest { assertThat(advanceAssignment.getAdvanceMeasurements().size(), equalTo(1)); + orderElementDAO.flush(); + sessionFactory.getCurrentSession().evict(orderElement); + AdvanceMeasurementDTO advanceMeasurementDTO2 = new AdvanceMeasurementDTO( date.plusWeeks(1).toDateTimeAtStartOfDay().toDate(), new BigDecimal(20)); orderDTO.advanceMeasurements.add(advanceMeasurementDTO2); + + orderListDTO = createOrderListDTO(orderDTO); instanceConstraintViolationsList = orderElementService - .updateOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; + assertThat(instanceConstraintViolationsList.size(), equalTo(0)); orderElement = orderElementDAO.findUniqueByCode(code); @@ -870,15 +933,16 @@ public class OrderElementServiceTest { for (AdvanceMeasurement advanceMeasurement : advanceMeasurements) { assertThat(advanceMeasurement.getDate(), anyOf(equalTo(date), equalTo(date.plusWeeks(1)))); - assertThat(advanceMeasurement.getValue(), anyOf(equalTo(new BigDecimal(15)), - equalTo(new BigDecimal(20)))); + assertThat(advanceMeasurement.getValue(), anyOf( + equalTo(new BigDecimal(15).setScale(2)), + equalTo(new BigDecimal(20).setScale(2)))); } } @Test public void invalidOrderWithCriterionRequirements() throws InstanceNotFoundException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -894,8 +958,9 @@ public class OrderElementServiceTest { CriterionRequirementDTO criterionRequirementDTO = new DirectCriterionRequirementDTO(); orderDTO.criterionRequirements.add(criterionRequirementDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); OrderElement orderElement = orderElementDAO.findUniqueByCode(code); @@ -906,7 +971,8 @@ public class OrderElementServiceTest { @Test public void validOrderWithCriterionRequirements() throws InstanceNotFoundException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); + ; try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -926,20 +992,21 @@ public class OrderElementServiceTest { name, type); orderDTO.criterionRequirements.add(criterionRequirementDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); OrderElement orderElement = orderElementDAO.findUniqueByCode(code); assertNotNull(orderElement); - assertThat(orderElement.getCriterionRequirements().size(), - equalTo(1)); + assertThat(orderElement.getCriterionRequirements().size(), equalTo(1)); } @Test public void validOrderWithDirectCriterionRequirementsAndIndidirectCriterionRequirements() throws InstanceNotFoundException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); + ; try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -961,8 +1028,9 @@ public class OrderElementServiceTest { OrderLineDTO orderLineDTO = new OrderLineDTO(); orderLineDTO.name = "Order line"; - orderLineDTO.code = "order-line-code"; - HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group", + orderLineDTO.code = "order-line-code-AX"; + HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group" + + UUID.randomUUID().toString(), ResourceEnumDTO.WORKER, 1000, new HashSet()); orderLineDTO.hoursGroups.add(hoursGroupDTO); @@ -971,15 +1039,16 @@ public class OrderElementServiceTest { orderLineDTO.criterionRequirements.add(indirectCriterionRequirementDTO); orderDTO.children.add(orderLineDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).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"); + orderElement = orderElementDAO.findUniqueByCode("order-line-code-AX"); assertNotNull(orderElement); assertThat(orderElement.getCriterionRequirements().size(), equalTo(1)); assertFalse(((IndirectCriterionRequirement) orderElement @@ -989,7 +1058,7 @@ public class OrderElementServiceTest { @Test public void updateCriterionRequirements() throws InstanceNotFoundException, IncompatibleTypeException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -1009,8 +1078,9 @@ public class OrderElementServiceTest { name, type); orderDTO.criterionRequirements.add(criterionRequirementDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; assertThat(instanceConstraintViolationsList.size(), equalTo(0)); OrderElement orderElement = orderElementDAO.findUniqueByCode(code); @@ -1019,12 +1089,17 @@ public class OrderElementServiceTest { String name2 = PredefinedCriterionTypes.LEAVE.getPredefined().get(1); + orderElementDAO.flush(); + sessionFactory.getCurrentSession().evict(orderElement); + CriterionRequirementDTO criterionRequirementDTO2 = new DirectCriterionRequirementDTO( name2, type); orderDTO.criterionRequirements.add(criterionRequirementDTO2); + orderListDTO = createOrderListDTO(orderDTO); instanceConstraintViolationsList = orderElementService - .updateOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; + assertThat(instanceConstraintViolationsList.size(), equalTo(0)); orderElement = orderElementDAO.findUniqueByCode(code); @@ -1037,15 +1112,14 @@ public class OrderElementServiceTest { equalTo(name), equalTo(name2))); assertThat(criterionRequirement.getCriterion().getType().getName(), equalTo(type)); - assertThat(criterionRequirement, - instanceOf(DirectCriterionRequirement.class)); + assertTrue(criterionRequirement instanceof DirectCriterionRequirement); } } @Test public void updateDirectCriterionRequirementsAndIndirectCriterionRequirements() throws InstanceNotFoundException, IncompatibleTypeException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -1067,40 +1141,46 @@ public class OrderElementServiceTest { OrderLineDTO orderLineDTO = new OrderLineDTO(); orderLineDTO.name = "Order line"; - orderLineDTO.code = "order-line-code"; - HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group", + orderLineDTO.code = "order-line-code-RR"; + HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group-RR", ResourceEnumDTO.WORKER, 1000, new HashSet()); orderLineDTO.hoursGroups.add(hoursGroupDTO); orderDTO.children.add(orderLineDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).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"); + orderElement = orderElementDAO.findUniqueByCode("order-line-code-RR"); assertNotNull(orderElement); assertThat(orderElement.getCriterionRequirements().size(), equalTo(1)); assertTrue(((IndirectCriterionRequirement) orderElement .getCriterionRequirements().iterator().next()).isValid()); + orderElementDAO.flush(); + sessionFactory.getCurrentSession().evict(orderElement); + IndirectCriterionRequirementDTO indirectCriterionRequirementDTO = new IndirectCriterionRequirementDTO( name, type, false); orderLineDTO.criterionRequirements.add(indirectCriterionRequirementDTO); + orderListDTO = createOrderListDTO(orderDTO); instanceConstraintViolationsList = orderElementService - .updateOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).instanceConstraintViolationsList; + assertThat(instanceConstraintViolationsList.size(), equalTo(0)); orderElement = orderElementDAO.findUniqueByCode(code); assertNotNull(orderElement); assertThat(orderElement.getCriterionRequirements().size(), equalTo(1)); - orderElement = orderElementDAO.findUniqueByCode("order-line-code"); + orderElement = orderElementDAO.findUniqueByCode("order-line-code-RR"); assertNotNull(orderElement); assertThat(orderElement.getCriterionRequirements().size(), equalTo(1)); assertFalse(((IndirectCriterionRequirement) orderElement @@ -1110,7 +1190,7 @@ public class OrderElementServiceTest { @Test public void importDirectCriterionRequirementsAndIndirectCriterionRequirements() throws InstanceNotFoundException, IncompatibleTypeException { - String code = "order-code"; + String code = "order-code" + UUID.randomUUID().toString(); try { orderElementDAO.findUniqueByCode(code); fail("Order with code " + code + " already exists"); @@ -1132,8 +1212,8 @@ public class OrderElementServiceTest { OrderLineDTO orderLineDTO = new OrderLineDTO(); orderLineDTO.name = "Order line"; - orderLineDTO.code = "order-line-code"; - HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group", + orderLineDTO.code = "order-line-code-WW"; + HoursGroupDTO hoursGroupDTO = new HoursGroupDTO("hours-group-WW", ResourceEnumDTO.WORKER, 1000, new HashSet()); orderLineDTO.hoursGroups.add(hoursGroupDTO); @@ -1144,19 +1224,31 @@ public class OrderElementServiceTest { orderDTO.children.add(orderLineDTO); + OrderListDTO orderListDTO = createOrderListDTO(orderDTO); List instanceConstraintViolationsList = orderElementService - .addOrder(orderDTO).instanceConstraintViolationsList; + .addOrders(orderListDTO).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"); + orderElement = orderElementDAO.findUniqueByCode("order-line-code-WW"); assertNotNull(orderElement); assertThat(orderElement.getCriterionRequirements().size(), equalTo(1)); assertFalse(((IndirectCriterionRequirement) orderElement .getCriterionRequirements().iterator().next()).isValid()); } + private OrderListDTO createOrderListDTO(OrderDTO... orderDTOs) { + + List orderList = new ArrayList(); + + for (OrderDTO c : orderDTOs) { + orderList.add(c); + } + + return new OrderListDTO(orderList); + + } } diff --git a/scripts/rest-clients/README b/scripts/rest-clients/README index 0a8d22d1c..3e2dbeed3 100644 --- a/scripts/rest-clients/README +++ b/scripts/rest-clients/README @@ -64,17 +64,11 @@ * Export order elements: - - export-order-element.sh ORDER-ELEMENT-CODE (authenticate with - wsreader/wsreader) + - export-order-element.sh (authenticate with wsreader/wsreader) * Import orders: - - import-order.sh order-sample.xml (authenticate with wswriter/wswriter) - - * Update orders: - - - update-order.sh order-update-sample.xml (authenticate with - wswriter/wswriter) + - import-order-elements.sh order-elements-sample.xml (authenticate with wswriter/wswriter) * Export resources hours: diff --git a/scripts/rest-clients/export-order-element.sh b/scripts/rest-clients/export-order-element.sh index 4e000ea6d..f98c97e4c 100755 --- a/scripts/rest-clients/export-order-element.sh +++ b/scripts/rest-clients/export-order-element.sh @@ -7,25 +7,15 @@ read loginName printf "Password: " read password -baseServiceURL=$DEVELOPMENT_BASE_SERVICE_URL -certificate=$DEVELOPMENT_CERTIFICATE - -for i in "$@" -do - if [ "$i" = "--prod" ]; then - baseServiceURL=$PRODUCTION_BASE_SERVICE_URL - certificate=$PRODUCTION_CERTIFICATE - else - orderElementCode=$i - fi -done - -if [ "$orderElementCode" = "" ]; then - printf "Missing order element code\n" 1>&2 - exit 1 +if [ "$1" = "--prod" ]; then + baseServiceURL=$PRODUCTION_BASE_SERVICE_URL + certificate=$PRODUCTION_CERTIFICATE +else + baseServiceURL=$DEVELOPMENT_BASE_SERVICE_URL + certificate=$DEVELOPMENT_CERTIFICATE fi authorization=`./base64.sh $loginName:$password` curl -sv -X GET $certificate --header "Authorization: Basic $authorization" \ - $baseServiceURL/orderelements/$orderElementCode/ | tidy -xml -i -q -utf8 + $baseServiceURL/orderelements/ | tidy -xml -i -q -utf8 diff --git a/scripts/rest-clients/import-order-elements.sh b/scripts/rest-clients/import-order-elements.sh new file mode 100755 index 000000000..7087dc56d --- /dev/null +++ b/scripts/rest-clients/import-order-elements.sh @@ -0,0 +1,33 @@ +#!/bin/sh + +. ./rest-common-env.sh + +printf "Login name: " +read loginName +printf "Password: " +read password + +baseServiceURL=$DEVELOPMENT_BASE_SERVICE_URL +certificate=$DEVELOPMENT_CERTIFICATE + +for i in "$@" +do + if [ "$i" = "--prod" ]; then + baseServiceURL=$PRODUCTION_BASE_SERVICE_URL + certificate=$PRODUCTION_CERTIFICATE + else + file=$i + fi +done + +if [ "$file" = "" ]; then + printf "Missing file\n" 1>&2 + exit 1 +fi + +authorization=`./base64.sh $loginName:$password` + +curl -sv -X POST $certificate -d @$file \ + --header "Content-type: application/xml" \ + --header "Authorization: Basic $authorization" \ + $baseServiceURL/orderelements/ | tidy -xml -i -q -utf8 diff --git a/scripts/rest-clients/order-elements-sample.xml b/scripts/rest-clients/order-elements-sample.xml new file mode 100644 index 000000000..284bfed4d --- /dev/null +++ b/scripts/rest-clients/order-elements-sample.xml @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +