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

ItEr50S13AdaptacionServiciosRESTItEr49S18 : Adapting of OrderServiceRest to GenericServiceRest.

Browse source
This commit is contained in:
Susana Montes Pedreira 2010-03-16 13:20:23 +01:00 • committed by Javier Moran Rua
parent d039edf5ed
commit daabf1ce4c
21 changed files with 613 additions and 320 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderDAO.java
View file

@ -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 <dpino@igalia.com>
* @author Jacobo Aragunde Pérez <jaragunde@igalia.com>
*/
public interface IOrderDAO extends IGenericDAO<Order, Long> {
public interface IOrderDAO extends IIntegrationEntityDAO<Order> {
/**
* Gets all the orders.

6
navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IOrderElementDAO.java
View file

@ -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 <dpino@igalia.com>
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public interface IOrderElementDAO extends IGenericDAO<OrderElement, Long> {
public interface IOrderElementDAO extends IIntegrationEntityDAO<OrderElement> {
public List<OrderElement> findWithoutParent();
public List<OrderElement> findByCode(String code);
public OrderElement findUniqueByCode(String code)
throws InstanceNotFoundException;

35
navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderDAO.java
View file

@ -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<Order, Long> implements
public class OrderDAO extends IntegrationEntityDAO<Order> implements
IOrderDAO {
@Autowired
@ -230,4 +231,32 @@ public class OrderDAO extends GenericDAOHibernate<Order, Long> implements
}
}
@Override
public List<Order> 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;
}
}
}

37
navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/OrderElementDAO.java
View file

@ -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<OrderElement, Long>
public class OrderElementDAO extends IntegrationEntityDAO<OrderElement>
implements IOrderElementDAO {
@Autowired
@ -191,10 +192,34 @@ public class OrderElementDAO extends GenericDAOHibernate<OrderElement, Long>
}
@Override
public List<OrderElement> findByCode(String code) {
Criteria c = getSession().createCriteria(OrderElement.class);
c.add(Restrictions.eq("infoComponent.code", code).ignoreCase());
return (List<OrderElement>) c.list();
public List<OrderElement> 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<OrderElement> findByTemplate(OrderElementTemplate template) {

9
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java
View file

@ -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;
}

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

@ -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<OrderElement> {
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<OrderElement> getIntegrationEntityDAO() {
return Registry.getOrderElementDAO();
}
}

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

@ -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);

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

@ -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);

5
navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderDTO.java
View file

@ -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 <mrego@igalia.com>
*/
@XmlRootElement(name = "order")
public class OrderDTO extends OrderLineGroupDTO {
public final static String ENTITY_TYPE = "order";
@XmlAttribute(name = "dependencies-constraints-have-priority")
public Boolean dependenciesConstraintsHavePriority;

15
navalplanner-webapp/src/main/java/org/navalplanner/ws/common/api/OrderElementDTO.java
View file

@ -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 <mrego@igalia.com>
*/
@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;
}
}

65
navalplanner-webapp/src/main/java/org/navalplanner/ws/common/impl/OrderElementConverter.java
View file

@ -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<OrderElement> children = new ArrayList<OrderElement>();
@ -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<BaseCalendar> 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;

12
navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/IOrderElementService.java
View file

@ -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();
}

49
navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/api/OrderListDTO.java Normal file
View file

@ -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 <http://www.gnu.org/licenses/>.
*/
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 <code>Order</code> entities.
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
@XmlRootElement(name = "order-list")
public class OrderListDTO {
@XmlElement(name = "order")
public List<OrderDTO> orderDTOs = new ArrayList<OrderDTO>();
public OrderListDTO() {
}
public OrderListDTO(List<OrderDTO> orderDTOs) {
this.orderDTOs = orderDTOs;
}
}

114
navalplanner-webapp/src/main/java/org/navalplanner/ws/orders/impl/OrderElementServiceREST.java
View file

@ -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<Order, OrderDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = new ArrayList<InstanceConstraintViolationsDTO>();
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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = new ArrayList<InstanceConstraintViolationsDTO>();
@Override
protected IIntegrationEntityDAO<Order> 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);
}
}

4
navalplanner-webapp/src/main/java/org/navalplanner/ws/subcontract/impl/SubcontractServiceREST.java
View file

@ -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) {

48
navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/labels/api/LabelServiceTest.java
View file

@ -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<LabelDTO>());
List<InstanceConstraintViolationsDTO> 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<LabelDTO>());
LabelTypeDTO labelTypeDTO2 = new LabelTypeDTO("label-type-B",
LabelTypeDTO labelTypeDTO2 = new LabelTypeDTO(nameType2,
new ArrayList<LabelDTO>());
LabelTypeListDTO labelTypeDTOs = createLabelTypeListDTO(labelTypeDTO1,
@ -171,11 +180,22 @@ public class LabelServiceTest {
List<LabelType> 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

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

@ -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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertTrue(instanceConstraintViolationsList.toString(),
instanceConstraintViolationsList.size() == 1);
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertTrue(instanceConstraintViolationsList.toString(),
instanceConstraintViolationsList.size() == 1);
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
@ -414,12 +437,18 @@ public class OrderElementServiceTest {
orderDTO.children.add(orderLineGroupDTO);
OrderListDTO orderListDTO = createOrderListDTO(orderDTO);
List<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> constraintViolations = instanceConstraintViolationsList
@ -460,8 +490,9 @@ public class OrderElementServiceTest {
materialAssignmentDTO.materialCode = "material-code";
orderDTO.materialAssignments.add(materialAssignmentDTO);
OrderListDTO orderListDTO = createOrderListDTO(orderDTO);
List<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> 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<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
orderDTO.children.add(orderLineDTO);
OrderListDTO orderListDTO = createOrderListDTO(orderDTO);
List<InstanceConstraintViolationsDTO> 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<CriterionRequirementDTO>());
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<InstanceConstraintViolationsDTO> instanceConstraintViolationsList = orderElementService
.addOrder(orderDTO).instanceConstraintViolationsList;
.addOrders(orderListDTO).instanceConstraintViolationsList;
assertThat(instanceConstraintViolationsList.size(), equalTo(1));
List<ConstraintViolationDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> 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<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
@ -971,15 +1039,16 @@ public class OrderElementServiceTest {
orderLineDTO.criterionRequirements.add(indirectCriterionRequirementDTO);
orderDTO.children.add(orderLineDTO);
OrderListDTO orderListDTO = createOrderListDTO(orderDTO);
List<InstanceConstraintViolationsDTO> 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<InstanceConstraintViolationsDTO> 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<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
orderDTO.children.add(orderLineDTO);
OrderListDTO orderListDTO = createOrderListDTO(orderDTO);
List<InstanceConstraintViolationsDTO> 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<CriterionRequirementDTO>());
orderLineDTO.hoursGroups.add(hoursGroupDTO);
@ -1144,19 +1224,31 @@ public class OrderElementServiceTest {
orderDTO.children.add(orderLineDTO);
OrderListDTO orderListDTO = createOrderListDTO(orderDTO);
List<InstanceConstraintViolationsDTO> 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<OrderDTO> orderList = new ArrayList<OrderDTO>();
for (OrderDTO c : orderDTOs) {
orderList.add(c);
}
return new OrderListDTO(orderList);
}
}

10
scripts/rest-clients/README
View file

@ -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:

24
scripts/rest-clients/export-order-element.sh
View file

@ -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

33
scripts/rest-clients/import-order-elements.sh Executable file
View file

@ -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

67
scripts/rest-clients/order-elements-sample.xml Normal file
View file

@ -0,0 +1,67 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<order-list xmlns="http://rest.ws.navalplanner.org">
<order calendar-name="Default"
dependencies-constraints-have-priority="false"
deadline="2010-03-25T00:00:00+01:00"
init-date="2010-03-15T10:22:24.251+01:00" name="Pedido A"
code="PREFIX-00019">
<labels>
<label code="458ade05-dc8c-4678-a28a-50b883415d99" />
</labels>
<material-assignments>
<material-assignment estimated-availability="2010-03-15T10:22:24.251+01:00"
unit-price="5.00" units="0.0" material-code="4141" />
</material-assignments>
<advance-measurements>
<advance-measurement value="0"
date="2010-03-15T00:00:00+01:00" />
</advance-measurements>
<criterion-requirements>
<direct-criterion-requirement type="LeaveAAKjflasfj"
name="CriterioB" />
</criterion-requirements>
<children>
<order-line name="orderline A2" code="PREFIX-00019-00002">
<labels />
<material-assignments />
<advance-measurements>
<advance-measurement value="0.00"
date="2010-03-15T00:00:00+01:00" />
</advance-measurements>
<criterion-requirements>
<direct-criterion-requirement type="LeaveAAKjflasfj"
name="CriterioA" />
<indirect-criterion-requirement valid="true"
type="LeaveAAKjflasfj" name="CriterioB" />
</criterion-requirements>
<hours-groups>
<hours-group working-hours="0" resource-type="WORKER"
code="PREFIX-00019-00001-00001">
<criterion-requirements>
<indirect-criterion-requirement valid="true"
type="LeaveAAKjflasfj" name="CriterioB" />
<indirect-criterion-requirement valid="true"
type="LeaveAAKjflasfj" name="CriterioA" />
</criterion-requirements>
</hours-group>
</hours-groups>
</order-line>
</children>
</order>
<order calendar-name="Default"
dependencies-constraints-have-priority="false"
deadline="2010-03-25T00:00:00+01:00"
init-date="2010-03-15T10:22:24.251+01:00" name="Pedido BBB"
code="PREFIX-00022">
<labels>
<label code="458ade05-dc8c-4678-a28a-50b883415d99" />
</labels>
<material-assignments>
<material-assignment estimated-availability="2010-03-15T10:22:24.251+01:00"
unit-price="5.00" units="0.0" material-code="4141" />
</material-assignments>
<advance-measurements />
<criterion-requirements />
<children />
</order>
</order-list>