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

ItEr14S11CUConfiguracionDeOrganizacionsDeTraballoConUnidadesTraballoItEr13S13: Refactoring package "workorders" (now called "orders") and classes names inside this package.

Browse source
This commit is contained in:
Manuel Rego Casasnovas 2009-06-24 15:53:08 +02:00 • committed by Javier Moran Rua
parent 6d32b869be
commit 82e9a3602a
40 changed files with 1066 additions and 1060 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
navalplanner-business/src/main/java/org/navalplanner/business/workorders/entities/ActivityWork.java → navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java
View file

@ -1,8 +1,8 @@
package org.navalplanner.business.workorders.entities;
package org.navalplanner.business.orders.entities;
import java.math.BigDecimal;
public class ActivityWork {
public class HoursGroup {
private Long id;

23
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/IOrderLineGroup.java Normal file
View file

@ -0,0 +1,23 @@
package org.navalplanner.business.orders.entities;
/**
* Container of {@link OrderElement}. <br />
*
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface IOrderLineGroup {
public void add(OrderElement orderElement);
public void remove(OrderElement orderElement);
public void replace(OrderElement oldOrderElement,
OrderElement newOrderElement);
public void up(OrderElement orderElement);
public void down(OrderElement orderElement);
public void add(int position, OrderElement orderElement);
}

41
navalplanner-business/src/main/java/org/navalplanner/business/workorders/entities/ProjectWork.java → navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/Order.java
View file

@ -1,4 +1,4 @@
package org.navalplanner.business.workorders.entities;
package org.navalplanner.business.orders.entities;
import java.util.ArrayList;
import java.util.Date;
@ -8,10 +8,11 @@ import org.hibernate.validator.NotEmpty;
import org.hibernate.validator.NotNull;
/**
* It represents a project with its related information. <br />
* It represents an {@link Order} with its related information. <br />
*
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class ProjectWork implements ITaskWorkContainer {
public class Order implements IOrderLineGroup {
private static Date copy(Date date) {
return date != null ? new Date(date.getTime()) : date;
@ -36,7 +37,7 @@ public class ProjectWork implements ITaskWorkContainer {
// TODO turn into a many to one relationship when Customer entity is defined
private String customer;
private List<TaskWork> taskWorks = new ArrayList<TaskWork>();
private List<OrderElement> orderElements = new ArrayList<OrderElement>();
public Long getId() {
return id;
@ -98,39 +99,39 @@ public class ProjectWork implements ITaskWorkContainer {
return endDate != null && endDate.before(initDate);
}
public void add(TaskWork task) {
getTasksManipulator().add(task);
public void add(OrderElement orderElement) {
getOrderElementsManipulator().add(orderElement);
}
private TaskWorkListManipulator getTasksManipulator() {
return new TaskWorkListManipulator(taskWorks);
private OrderLineGroupManipulator getOrderElementsManipulator() {
return new OrderLineGroupManipulator(orderElements);
}
public List<TaskWork> getTaskWorks() {
return new ArrayList<TaskWork>(taskWorks);
public List<OrderElement> getOrderElements() {
return new ArrayList<OrderElement>(orderElements);
}
public void remove(TaskWork task) {
getTasksManipulator().remove(task);
public void remove(OrderElement orderElement) {
getOrderElementsManipulator().remove(orderElement);
}
public void replace(TaskWork oldTask, TaskWork newTask) {
getTasksManipulator().replace(oldTask, newTask);
public void replace(OrderElement oldOrderElement, OrderElement orderElement) {
getOrderElementsManipulator().replace(oldOrderElement, orderElement);
}
@Override
public void up(TaskWork task) {
getTasksManipulator().up(task);
public void up(OrderElement orderElement) {
getOrderElementsManipulator().up(orderElement);
}
@Override
public void down(TaskWork task) {
getTasksManipulator().down(task);
public void down(OrderElement orderElement) {
getOrderElementsManipulator().down(orderElement);
}
@Override
public void add(int position, TaskWork task) {
getTasksManipulator().add(position, task);
public void add(int position, OrderElement orderElement) {
getOrderElementsManipulator().add(position, orderElement);
}

12
navalplanner-business/src/main/java/org/navalplanner/business/workorders/entities/TaskWork.java → navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
View file

@ -1,11 +1,11 @@
package org.navalplanner.business.workorders.entities;
package org.navalplanner.business.orders.entities;
import java.util.Date;
import java.util.List;
import org.hibernate.validator.NotNull;
public abstract class TaskWork {
public abstract class OrderElement {
private long id;
@NotNull
@ -23,7 +23,7 @@ public abstract class TaskWork {
public abstract Integer getWorkHours();
public abstract List<ActivityWork> getActivities();
public abstract List<HoursGroup> getHoursGroups();
public long getId() {
return id;
@ -46,7 +46,7 @@ public abstract class TaskWork {
public abstract boolean isLeaf();
public abstract List<TaskWork> getChildren();
public abstract List<OrderElement> getChildren();
public Date getInitDate() {
return initDate;
@ -88,8 +88,8 @@ public abstract class TaskWork {
return description;
}
public abstract TaskWorkContainer asContainer();
public abstract OrderLineGroup asContainer();
public abstract void forceLoadActivities();
public abstract void forceLoadHourGroups();
}

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

@ -0,0 +1,97 @@
package org.navalplanner.business.orders.entities;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class OrderLine extends OrderElement {
private Boolean fixedHours = false;
private Set<HoursGroup> hoursGroups = new HashSet<HoursGroup>();
@Override
public Integer getWorkHours() {
int result = 0;
List<HoursGroup> hoursGroups = getHoursGroups();
for (HoursGroup hoursGroup : hoursGroups) {
Integer workingHours = hoursGroup.getWorkingHours();
if (workingHours != null) {
result += workingHours;
}
}
return result;
}
@Override
public List<OrderElement> getChildren() {
return new ArrayList<OrderElement>();
}
@Override
public boolean isLeaf() {
return true;
}
@Override
public OrderLineGroup asContainer() {
OrderLineGroup result = new OrderLineGroup();
result.setName(getName());
result.setInitDate(getInitDate());
result.setEndDate(getEndDate());
// FIXME
// result.setHoursGroups(getHoursGroups());
return result;
}
public void setWorkHours(Integer workingHours) {
List<HoursGroup> hoursGroups = getHoursGroups();
// FIXME For the moment we have just one HoursGroup for each OrderLine
if (hoursGroups.isEmpty()) {
HoursGroup hourGroup = new HoursGroup();
hourGroup.setWorkingHours(workingHours);
hoursGroups.add(hourGroup);
} else {
HoursGroup hourGroup = hoursGroups.get(0);
hourGroup.setWorkingHours(workingHours);
}
setHoursGroups(hoursGroups);
}
public void setHoursGroups(List<HoursGroup> hoursGroups) {
this.hoursGroups = new HashSet<HoursGroup>(hoursGroups);
}
public void addHoursGroup(HoursGroup hoursGroup) {
hoursGroups.add(hoursGroup);
}
public void deleteHoursGroup(HoursGroup hoursGroup) {
hoursGroups.remove(hoursGroup);
}
@Override
public List<HoursGroup> getHoursGroups() {
return new ArrayList<HoursGroup>(hoursGroups);
}
@Override
public void forceLoadHourGroups() {
for (HoursGroup hoursGroup : hoursGroups) {
hoursGroup.getWorkingHours();
}
}
public void setFixedHours(Boolean fixedHours) {
this.fixedHours = fixedHours;
}
public Boolean isFixedHours() {
return fixedHours;
}
}

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

@ -0,0 +1,85 @@
package org.navalplanner.business.orders.entities;
import java.util.ArrayList;
import java.util.List;
public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
private List<OrderElement> children = new ArrayList<OrderElement>();
@Override
public List<OrderElement> getChildren() {
return new ArrayList<OrderElement>(children);
}
@Override
public boolean isLeaf() {
return false;
}
@Override
public void remove(OrderElement child) {
getManipulator().remove(child);
}
@Override
public void replace(OrderElement oldOrderElement, OrderElement orderElement) {
getManipulator().replace(oldOrderElement, orderElement);
}
@Override
public void add(OrderElement orderElement) {
getManipulator().add(orderElement);
}
@Override
public void up(OrderElement orderElement) {
getManipulator().up(orderElement);
}
private OrderLineGroupManipulator getManipulator() {
return new OrderLineGroupManipulator(children);
}
@Override
public OrderLineGroup asContainer() {
return this;
}
@Override
public void down(OrderElement orderElement) {
getManipulator().down(orderElement);
}
@Override
public void add(int position, OrderElement orderElement) {
children.add(position, orderElement);
}
@Override
public Integer getWorkHours() {
int result = 0;
List<OrderElement> children = getChildren();
for (OrderElement orderElement : children) {
result += orderElement.getWorkHours();
}
return result;
}
@Override
public void forceLoadHourGroups() {
for (OrderElement orderElement : children) {
orderElement.forceLoadHourGroups();
}
}
@Override
public List<HoursGroup> getHoursGroups() {
List<HoursGroup> hoursGroups = new ArrayList<HoursGroup>();
for (OrderElement orderElement : children) {
hoursGroups.addAll(orderElement.getHoursGroups());
}
return hoursGroups;
}
}

57
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroupManipulator.java Normal file
View file

@ -0,0 +1,57 @@
package org.navalplanner.business.orders.entities;
import java.util.Collections;
import java.util.List;
/**
* Implementation of {@link OrderElement}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class OrderLineGroupManipulator implements IOrderLineGroup {
private final List<OrderElement> orderElements;
public OrderLineGroupManipulator(List<OrderElement> orderElements) {
this.orderElements = orderElements;
}
@Override
public void add(OrderElement orderElement) {
orderElements.add(orderElement);
}
@Override
public void remove(OrderElement orderElement) {
orderElements.remove(orderElement);
}
@Override
public void replace(OrderElement oldOrderElement, OrderElement orderElement) {
Collections.replaceAll(orderElements, oldOrderElement, orderElement);
}
@Override
public void up(OrderElement orderElement) {
int position = orderElements.indexOf(orderElement);
if (position < orderElements.size() - 1) {
orderElements.remove(position);
orderElements.add(position + 1, orderElement);
}
}
@Override
public void down(OrderElement orderElement) {
int position = orderElements.indexOf(orderElement);
if (position > 0) {
orderElements.remove(position);
orderElements.add(position - 1, orderElement);
}
}
@Override
public void add(int position, OrderElement orderElement) {
orderElements.add(position, orderElement);
}
}

28
navalplanner-business/src/main/java/org/navalplanner/business/orders/services/IOrderService.java Normal file
View file

@ -0,0 +1,28 @@
package org.navalplanner.business.orders.services;
import java.util.List;
import org.navalplanner.business.common.OnTransaction;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.orders.entities.Order;
/**
* Management of {@link Order} <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface IOrderService {
void save(Order order) throws ValidationException;
boolean exists(Order HoursGroup);
List<Order> getOrders();
void remove(Order HoursGroup) throws InstanceNotFoundException;
Order find(Long workerId) throws InstanceNotFoundException;
public <T> T onTransaction(OnTransaction<T> onTransaction);
}

34
navalplanner-business/src/main/java/org/navalplanner/business/workorders/services/ProjectWorkService.java → navalplanner-business/src/main/java/org/navalplanner/business/orders/services/OrderService.java
View file

@ -1,4 +1,4 @@
package org.navalplanner.business.workorders.services;
package org.navalplanner.business.orders.services;
import java.util.List;
@ -8,7 +8,7 @@ import org.navalplanner.business.common.OnTransaction;
import org.navalplanner.business.common.daos.impl.GenericDaoHibernate;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.orders.entities.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
@ -16,23 +16,23 @@ import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
/**
* Default implementation of {@link IProjectWorkService} <br />
* Default implementation of {@link IOrderService} <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
@Component
@Scope(BeanDefinition.SCOPE_SINGLETON)
@Transactional
public class ProjectWorkService implements IProjectWorkService {
public class OrderService implements IOrderService {
@Autowired
private SessionFactory sessionFactory;
/*
* Because the dao for project work doesn't have special needs, it's not
* Because the dao for orderwork doesn't have special needs, it's not
* created an interface for defining its contract
*/
private GenericDaoHibernate<ProjectWork, Long> dao = new GenericDaoHibernate<ProjectWork, Long>() {
private GenericDaoHibernate<Order, Long> dao = new GenericDaoHibernate<Order, Long>() {
@Override
protected Session getSession() {
@ -42,33 +42,33 @@ public class ProjectWorkService implements IProjectWorkService {
@Override
@Transactional(readOnly = true)
public boolean exists(ProjectWork projectWork) {
return dao.exists(projectWork.getId());
public boolean exists(Order order) {
return dao.exists(order.getId());
}
@Override
public void save(ProjectWork projectWork) throws ValidationException {
if (projectWork.isEndDateBeforeStart()) {
public void save(Order order) throws ValidationException {
if (order.isEndDateBeforeStart()) {
throw new ValidationException("endDate must be after startDate");
}
dao.save(projectWork);
dao.save(order);
}
@Override
public List<ProjectWork> getProjectWorks() {
return dao.list(ProjectWork.class);
public List<Order> getOrders() {
return dao.list(Order.class);
}
@Override
public ProjectWork find(Long projectWorkId)
public Order find(Long orderId)
throws InstanceNotFoundException {
return dao.find(projectWorkId);
return dao.find(orderId);
}
@Override
public void remove(ProjectWork projectWork)
public void remove(Order order)
throws InstanceNotFoundException {
dao.remove(projectWork.getId());
dao.remove(order.getId());
}
@Override

21
navalplanner-business/src/main/java/org/navalplanner/business/workorders/entities/ITaskWorkContainer.java
View file

@ -1,21 +0,0 @@
package org.navalplanner.business.workorders.entities;
/**
* Container of TaskWorks. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface ITaskWorkContainer {
public void add(TaskWork task);
public void remove(TaskWork task);
public void replace(TaskWork oldTask, TaskWork newTask);
public void up(TaskWork task);
public void down(TaskWork task);
public void add(int position, TaskWork task);
}

85
navalplanner-business/src/main/java/org/navalplanner/business/workorders/entities/TaskWorkContainer.java
View file

@ -1,85 +0,0 @@
package org.navalplanner.business.workorders.entities;
import java.util.ArrayList;
import java.util.List;
public class TaskWorkContainer extends TaskWork implements ITaskWorkContainer {
private List<TaskWork> children = new ArrayList<TaskWork>();
@Override
public List<TaskWork> getChildren() {
return new ArrayList<TaskWork>(children);
}
@Override
public boolean isLeaf() {
return false;
}
@Override
public void remove(TaskWork child) {
getManipulator().remove(child);
}
@Override
public void replace(TaskWork oldTask, TaskWork newTask) {
getManipulator().replace(oldTask, newTask);
}
@Override
public void add(TaskWork task) {
getManipulator().add(task);
}
@Override
public void up(TaskWork task) {
getManipulator().up(task);
}
private TaskWorkListManipulator getManipulator() {
return new TaskWorkListManipulator(children);
}
@Override
public TaskWorkContainer asContainer() {
return this;
}
@Override
public void down(TaskWork task) {
getManipulator().down(task);
}
@Override
public void add(int position, TaskWork task) {
children.add(position, task);
}
@Override
public Integer getWorkHours() {
int result = 0;
List<TaskWork> children = getChildren();
for (TaskWork taskWork : children) {
result += taskWork.getWorkHours();
}
return result;
}
@Override
public void forceLoadActivities() {
for (TaskWork taskWork : children) {
taskWork.forceLoadActivities();
}
}
@Override
public List<ActivityWork> getActivities() {
List<ActivityWork> activities = new ArrayList<ActivityWork>();
for (TaskWork taskWork : children) {
activities.addAll(taskWork.getActivities());
}
return activities;
}
}

97
navalplanner-business/src/main/java/org/navalplanner/business/workorders/entities/TaskWorkLeaf.java
View file

@ -1,97 +0,0 @@
package org.navalplanner.business.workorders.entities;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class TaskWorkLeaf extends TaskWork {
private Boolean fixedHours = false;
private Set<ActivityWork> activityWorks = new HashSet<ActivityWork>();
@Override
public Integer getWorkHours() {
int result = 0;
List<ActivityWork> a = getActivities();
for (ActivityWork activityWork : a) {
Integer workingHours = activityWork.getWorkingHours();
if (workingHours != null) {
result += workingHours;
}
}
return result;
}
@Override
public List<TaskWork> getChildren() {
return new ArrayList<TaskWork>();
}
@Override
public boolean isLeaf() {
return true;
}
@Override
public TaskWorkContainer asContainer() {
TaskWorkContainer result = new TaskWorkContainer();
result.setName(getName());
result.setInitDate(getInitDate());
result.setEndDate(getEndDate());
// FIXME
// result.setActivities(getActivities());
return result;
}
public void setWorkHours(Integer workingHours) {
List<ActivityWork> activities = getActivities();
// FIXME For the moment we have just one activity for each TaksWorkLeaf
if (activities.isEmpty()) {
ActivityWork activity = new ActivityWork();
activity.setWorkingHours(workingHours);
activities.add(activity);
} else {
ActivityWork activity = activities.get(0);
activity.setWorkingHours(workingHours);
}
setActivities(activities);
}
public void setActivities(List<ActivityWork> activities) {
this.activityWorks = new HashSet<ActivityWork>(activities);
}
public void addActivity(ActivityWork activityWork) {
activityWorks.add(activityWork);
}
public void deleteActivity(ActivityWork value) {
activityWorks.remove(value);
}
@Override
public List<ActivityWork> getActivities() {
return new ArrayList<ActivityWork>(activityWorks);
}
@Override
public void forceLoadActivities() {
for (ActivityWork activityWork : activityWorks) {
activityWork.getWorkingHours();
}
}
public void setFixedHours(Boolean fixedHours) {
this.fixedHours = fixedHours;
}
public Boolean isFixedHours() {
return fixedHours;
}
}

57
navalplanner-business/src/main/java/org/navalplanner/business/workorders/entities/TaskWorkListManipulator.java
View file

@ -1,57 +0,0 @@
package org.navalplanner.business.workorders.entities;
import java.util.Collections;
import java.util.List;
/**
* Implementation of {@link TaskWork}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class TaskWorkListManipulator implements ITaskWorkContainer {
private final List<TaskWork> taskWorks;
public TaskWorkListManipulator(List<TaskWork> taskWorks) {
this.taskWorks = taskWorks;
}
@Override
public void add(TaskWork task) {
taskWorks.add(task);
}
@Override
public void remove(TaskWork task) {
taskWorks.remove(task);
}
@Override
public void replace(TaskWork oldTask, TaskWork newTask) {
Collections.replaceAll(taskWorks, oldTask, newTask);
}
@Override
public void up(TaskWork task) {
int position = taskWorks.indexOf(task);
if (position < taskWorks.size() - 1) {
taskWorks.remove(position);
taskWorks.add(position + 1, task);
}
}
@Override
public void down(TaskWork task) {
int position = taskWorks.indexOf(task);
if (position > 0) {
taskWorks.remove(position);
taskWorks.add(position - 1, task);
}
}
@Override
public void add(int position, TaskWork task) {
taskWorks.add(position, task);
}
}

28
navalplanner-business/src/main/java/org/navalplanner/business/workorders/services/IProjectWorkService.java
View file

@ -1,28 +0,0 @@
package org.navalplanner.business.workorders.services;
import java.util.List;
import org.navalplanner.business.common.OnTransaction;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.workorders.entities.ProjectWork;
/**
* Management of {@link ProjectWork} <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface IProjectWorkService {
void save(ProjectWork projectWork) throws ValidationException;
boolean exists(ProjectWork projectWork);
List<ProjectWork> getProjectWorks();
void remove(ProjectWork projectWork) throws InstanceNotFoundException;
ProjectWork find(Long workerId) throws InstanceNotFoundException;
public <T> T onTransaction(OnTransaction<T> onTransaction);
}

2
navalplanner-business/src/main/resources/navalplanner-business-spring-config.xml
View file

@ -24,7 +24,7 @@
org/navalplanner/business/resources/entities/Resources.hbm.xml
</value>
<value>
org/navalplanner/business/workorders/entities/WorkOrders.hbm.xml
org/navalplanner/business/orders/entities/Orders.hbm.xml
</value>
</list>
</property>

34
navalplanner-business/src/main/resources/org/navalplanner/business/workorders/entities/WorkOrders.hbm.xml → navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml
View file

@ -1,8 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="org.navalplanner.business.workorders.entities">
<class name="ProjectWork">
<id access="field" name="id">
<hibernate-mapping package="org.navalplanner.business.orders.entities">
<class name="Order" table="order_table">
<id access="field" type="long" name="id">
<generator class="native" />
</id>
<version name="version" access="field" type="long" />
@ -12,14 +12,14 @@
<property name="description" access="field"></property>
<property name="responsible" access="field"></property>
<property name="customer" access="field"></property>
<list name="taskWorks" access="field" cascade="all">
<key column="projectId" not-null="false"></key>
<index column="positionInProject"></index>
<one-to-many class="TaskWork" />
<list name="orderElements" access="field" cascade="all">
<key column="orderId" not-null="false"></key>
<index column="positionInOrder"></index>
<one-to-many class="OrderElement" />
</list>
</class>
<class name="TaskWork" abstract="true">
<class name="OrderElement" abstract="true">
<id name="id" type="long" access="field">
<generator class="native" />
</id>
@ -31,28 +31,28 @@
<property name="mandatoryEnd" access="field" />
<property name="description" access="field" />
<joined-subclass name="TaskWorkContainer">
<key column="TASKWORKID"></key>
<joined-subclass name="OrderLineGroup">
<key column="ORDERELEMENTID"></key>
<list name="children" access="field" cascade="all">
<key column="parent" not-null="false"></key>
<index column="positionInContainer"></index>
<one-to-many class="TaskWork" />
<one-to-many class="OrderElement" />
</list>
</joined-subclass>
<joined-subclass name="TaskWorkLeaf">
<key column="TASKWORKID"></key>
<joined-subclass name="OrderLine">
<key column="ORDERELEMENTID"></key>
<property name="fixedHours" access="field" />
<set name="activityWorks" access="field" cascade="all">
<key column="PARENT_TASK" not-null="false"></key>
<one-to-many class="ActivityWork" />
<set name="hoursGroups" access="field" cascade="all">
<key column="PARENT_ORDER_ELEMENT" not-null="false"></key>
<one-to-many class="HoursGroup" />
</set>
</joined-subclass>
</class>
<class name="ActivityWork">
<class name="HoursGroup">
<id name="id" type="long" access="field">
<generator class="native" />
</id>

42
navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderTest.java Normal file
View file

@ -0,0 +1,42 @@
package org.navalplanner.business.test.orders.entities;
import org.junit.Test;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLineGroup;
import org.navalplanner.business.orders.entities.OrderLine;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
/**
* Tests for {@link Order}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class OrderTest {
@Test
public void testAddingOrderElement() throws Exception {
Order order = new Order();
OrderLineGroup container = new OrderLineGroup();
OrderLine leaf = new OrderLine();
container.add(leaf);
order.add(container);
assertThat(order.getOrderElements().size(), equalTo(1));
}
@Test
public void testPreservesOrder() throws Exception {
OrderLineGroup container = new OrderLineGroup();
OrderLine[] created = new OrderLine[100];
for (int i = 0; i < created.length; i++) {
created[i] = new OrderLine();
container.add(created[i]);
}
for (int i = 0; i < created.length; i++) {
assertThat(container.getChildren().get(i),
equalTo((OrderElement) created[i]));
}
}
}

187
navalplanner-business/src/test/java/org/navalplanner/business/test/orders/services/OrderServiceTest.java Normal file
View file

@ -0,0 +1,187 @@
package org.navalplanner.business.test.orders.services;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.common.OnTransaction;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
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.OrderLineGroup;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.business.orders.services.IOrderService;
import org.navalplanner.business.test.resources.daos.CriterionSatisfactionDAOTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.NotTransactional;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
* Tests for {@link Order}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { BUSINESS_SPRING_CONFIG_FILE,
BUSINESS_SPRING_CONFIG_TEST_FILE })
@Transactional
public class OrderServiceTest {
private static Order createValidOrder() {
Order order = new Order();
order.setDescription("description");
order.setCustomer("blabla");
order.setInitDate(CriterionSatisfactionDAOTest.year(2000));
order.setName("name");
order.setResponsible("responsible");
return order;
}
@Autowired
private IOrderService orderService;
@Test
public void testCreation() throws ValidationException {
Order order = createValidOrder();
orderService.save(order);
assertTrue(orderService.exists(order));
}
@Test
public void testListing() throws Exception {
List<Order> list = orderService.getOrders();
orderService.save(createValidOrder());
assertThat(orderService.getOrders().size(), equalTo(list
.size() + 1));
}
@Test
public void testRemove() throws Exception {
Order order = createValidOrder();
orderService.save(order);
assertTrue(orderService.exists(order));
orderService.remove(order);
assertFalse(orderService.exists(order));
}
@Test(expected = ValidationException.class)
public void shouldSendValidationExceptionIfEndDateIsBeforeThanStartingDate()
throws ValidationException {
Order order = createValidOrder();
order.setEndDate(CriterionSatisfactionDAOTest.year(0));
orderService.save(order);
}
@Test
public void testFind() throws Exception {
Order order = createValidOrder();
orderService.save(order);
assertThat(orderService.find(order.getId()), notNullValue());
}
@Test
@NotTransactional
public void testOrderPreserved() throws ValidationException,
InstanceNotFoundException {
final Order order = createValidOrder();
final OrderElement[] containers = new OrderLineGroup[10];
for (int i = 0; i < containers.length; i++) {
containers[i] = new OrderLineGroup();
containers[i].setName("bla");
order.add(containers[i]);
}
OrderLineGroup container = (OrderLineGroup) containers[0];
container.setName("container");
final OrderElement[] orderElements = new OrderElement[10];
for (int i = 0; i < orderElements.length; i++) {
OrderLine leaf = createValidLeaf("bla");
orderElements[i] = leaf;
container.add(leaf);
}
orderService.save(order);
orderService.onTransaction(new OnTransaction<Void>() {
@Override
public Void execute() {
try {
Order reloaded = orderService.find(order
.getId());
List<OrderElement> elements = reloaded.getOrderElements();
for (int i = 0; i < containers.length; i++) {
assertThat(elements.get(i).getId(),
equalTo(containers[i].getId()));
}
OrderLineGroup container = (OrderLineGroup) reloaded
.getOrderElements().iterator().next();
List<OrderElement> children = container.getChildren();
for (int i = 0; i < orderElements.length; i++) {
assertThat(children.get(i).getId(), equalTo(orderElements[i]
.getId()));
}
return null;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
});
orderService.remove(order);
}
private OrderLine createValidLeaf(String parameter) {
OrderLine result = new OrderLine();
result.setName(parameter);
return result;
}
@Test
@NotTransactional
public void testAddingOrderElement() throws Exception {
final Order order = createValidOrder();
OrderLineGroup container = new OrderLineGroup();
container.setName("bla");
OrderLine leaf = new OrderLine();
leaf.setName("leaf");
container.add(leaf);
order.add(container);
HoursGroup hoursGroup = new HoursGroup();
hoursGroup.setWorkingHours(3);
leaf.addHoursGroup(hoursGroup);
orderService.save(order);
orderService.onTransaction(new OnTransaction<Void>() {
@Override
public Void execute() {
try {
Order reloaded = orderService.find(order
.getId());
assertFalse(order == reloaded);
assertThat(reloaded.getOrderElements().size(), equalTo(1));
OrderLineGroup containerReloaded = (OrderLineGroup) reloaded
.getOrderElements().get(0);
assertThat(containerReloaded.getHoursGroups().size(),
equalTo(1));
assertThat(containerReloaded.getChildren().size(),
equalTo(1));
OrderElement leaf = containerReloaded.getChildren().get(0);
assertThat(leaf.getHoursGroups().size(), equalTo(1));
orderService.remove(order);
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
return null;
}
});
}
}

42
navalplanner-business/src/test/java/org/navalplanner/business/test/workorders/entities/ProjectWorkTest.java
View file

@ -1,42 +0,0 @@
package org.navalplanner.business.test.workorders.entities;
import org.junit.Test;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.workorders.entities.TaskWork;
import org.navalplanner.business.workorders.entities.TaskWorkContainer;
import org.navalplanner.business.workorders.entities.TaskWorkLeaf;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
/**
* Tests for {@link ProjectWork}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class ProjectWorkTest {
@Test
public void testAddingTaskWork() throws Exception {
ProjectWork projectWork = new ProjectWork();
TaskWorkContainer container = new TaskWorkContainer();
TaskWorkLeaf leaf = new TaskWorkLeaf();
container.add(leaf);
projectWork.add(container);
assertThat(projectWork.getTaskWorks().size(), equalTo(1));
}
@Test
public void testPreservesOrder() throws Exception {
TaskWorkContainer container = new TaskWorkContainer();
TaskWorkLeaf[] created = new TaskWorkLeaf[100];
for (int i = 0; i < created.length; i++) {
created[i] = new TaskWorkLeaf();
container.add(created[i]);
}
for (int i = 0; i < created.length; i++) {
assertThat(container.getChildren().get(i),
equalTo((TaskWork) created[i]));
}
}
}

187
navalplanner-business/src/test/java/org/navalplanner/business/test/workorders/services/ProjectWorkServiceTest.java
View file

@ -1,187 +0,0 @@
package org.navalplanner.business.test.workorders.services;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.common.OnTransaction;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.test.resources.daos.CriterionSatisfactionDAOTest;
import org.navalplanner.business.workorders.entities.ActivityWork;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.workorders.entities.TaskWork;
import org.navalplanner.business.workorders.entities.TaskWorkContainer;
import org.navalplanner.business.workorders.entities.TaskWorkLeaf;
import org.navalplanner.business.workorders.services.IProjectWorkService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.NotTransactional;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
* Tests for {@link ProjectWork}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { BUSINESS_SPRING_CONFIG_FILE,
BUSINESS_SPRING_CONFIG_TEST_FILE })
@Transactional
public class ProjectWorkServiceTest {
private static ProjectWork createValidProjectWork() {
ProjectWork projectWork = new ProjectWork();
projectWork.setDescription("description");
projectWork.setCustomer("blabla");
projectWork.setInitDate(CriterionSatisfactionDAOTest.year(2000));
projectWork.setName("name");
projectWork.setResponsible("responsible");
return projectWork;
}
@Autowired
private IProjectWorkService projectWorkService;
@Test
public void testCreation() throws ValidationException {
ProjectWork projectWork = createValidProjectWork();
projectWorkService.save(projectWork);
assertTrue(projectWorkService.exists(projectWork));
}
@Test
public void testListing() throws Exception {
List<ProjectWork> list = projectWorkService.getProjectWorks();
projectWorkService.save(createValidProjectWork());
assertThat(projectWorkService.getProjectWorks().size(), equalTo(list
.size() + 1));
}
@Test
public void testRemove() throws Exception {
ProjectWork projectWork = createValidProjectWork();
projectWorkService.save(projectWork);
assertTrue(projectWorkService.exists(projectWork));
projectWorkService.remove(projectWork);
assertFalse(projectWorkService.exists(projectWork));
}
@Test(expected = ValidationException.class)
public void shouldSendValidationExceptionIfEndDateIsBeforeThanStartingDate()
throws ValidationException {
ProjectWork projectWork = createValidProjectWork();
projectWork.setEndDate(CriterionSatisfactionDAOTest.year(0));
projectWorkService.save(projectWork);
}
@Test
public void testFind() throws Exception {
ProjectWork projectWork = createValidProjectWork();
projectWorkService.save(projectWork);
assertThat(projectWorkService.find(projectWork.getId()), notNullValue());
}
@Test
@NotTransactional
public void testOrderPreserved() throws ValidationException,
InstanceNotFoundException {
final ProjectWork projectWork = createValidProjectWork();
final TaskWork[] containers = new TaskWorkContainer[10];
for (int i = 0; i < containers.length; i++) {
containers[i] = new TaskWorkContainer();
containers[i].setName("bla");
projectWork.add(containers[i]);
}
TaskWorkContainer container = (TaskWorkContainer) containers[0];
container.setName("container");
final TaskWork[] tasks = new TaskWork[10];
for (int i = 0; i < tasks.length; i++) {
TaskWorkLeaf leaf = createValidLeaf("bla");
tasks[i] = leaf;
container.add(leaf);
}
projectWorkService.save(projectWork);
projectWorkService.onTransaction(new OnTransaction<Void>() {
@Override
public Void execute() {
try {
ProjectWork reloaded = projectWorkService.find(projectWork
.getId());
List<TaskWork> taskWorks = reloaded.getTaskWorks();
for (int i = 0; i < containers.length; i++) {
assertThat(taskWorks.get(i).getId(),
equalTo(containers[i].getId()));
}
TaskWorkContainer container = (TaskWorkContainer) reloaded
.getTaskWorks().iterator().next();
List<TaskWork> children = container.getChildren();
for (int i = 0; i < tasks.length; i++) {
assertThat(children.get(i).getId(), equalTo(tasks[i]
.getId()));
}
return null;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
});
projectWorkService.remove(projectWork);
}
private TaskWorkLeaf createValidLeaf(String parameter) {
TaskWorkLeaf result = new TaskWorkLeaf();
result.setName(parameter);
return result;
}
@Test
@NotTransactional
public void testAddingTaskWork() throws Exception {
final ProjectWork projectWork = createValidProjectWork();
TaskWorkContainer container = new TaskWorkContainer();
container.setName("bla");
TaskWorkLeaf leaf = new TaskWorkLeaf();
leaf.setName("leaf");
container.add(leaf);
projectWork.add(container);
ActivityWork activityWork = new ActivityWork();
activityWork.setWorkingHours(3);
leaf.addActivity(activityWork);
projectWorkService.save(projectWork);
projectWorkService.onTransaction(new OnTransaction<Void>() {
@Override
public Void execute() {
try {
ProjectWork reloaded = projectWorkService.find(projectWork
.getId());
assertFalse(projectWork == reloaded);
assertThat(reloaded.getTaskWorks().size(), equalTo(1));
TaskWorkContainer containerReloaded = (TaskWorkContainer) reloaded
.getTaskWorks().get(0);
assertThat(containerReloaded.getActivities().size(),
equalTo(1));
assertThat(containerReloaded.getChildren().size(),
equalTo(1));
TaskWork leaf = containerReloaded.getChildren().get(0);
assertThat(leaf.getActivities().size(), equalTo(1));
projectWorkService.remove(projectWork);
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
return null;
}
});
}
}

2
navalplanner-business/src/test/resources/navalplanner-business-spring-config-test.xml
View file

@ -30,7 +30,7 @@
org/navalplanner/business/resources/entities/Resources.hbm.xml
</value>
<value>
org/navalplanner/business/workorders/entities/WorkOrders.hbm.xml
org/navalplanner/business/orders/entities/Orders.hbm.xml
</value>
</list>
</property>

20
navalplanner-webapp/src/main/java/org/navalplanner/web/common/converters/ProjectWorkConverter.java
View file

@ -1,26 +1,26 @@
package org.navalplanner.web.common.converters;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.workorders.services.IProjectWorkService;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.services.IOrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
/**
* A {@link Converter} for {@link ProjectWork} <br />
* A {@link Converter} for {@link Order} <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
@Component
@Scope(BeanDefinition.SCOPE_SINGLETON)
public class ProjectWorkConverter implements Converter<ProjectWork> {
public class ProjectWorkConverter implements Converter<Order> {
@Autowired
private IProjectWorkService projectWorkService;
private IOrderService projectWorkService;
@Override
public ProjectWork asObject(String stringRepresentation) {
public Order asObject(String stringRepresentation) {
try {
return projectWorkService
.find(Long.parseLong(stringRepresentation));
@ -30,18 +30,18 @@ public class ProjectWorkConverter implements Converter<ProjectWork> {
}
@Override
public String asString(ProjectWork entity) {
public String asString(Order entity) {
return entity.getId() + "";
}
@Override
public String asStringUngeneric(Object entity) {
return asString((ProjectWork) entity);
return asString((Order) entity);
}
@Override
public Class<ProjectWork> getType() {
return ProjectWork.class;
public Class<Order> getType() {
return Order.class;
}
}

31
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IOrderModel.java Normal file
View file

@ -0,0 +1,31 @@
package org.navalplanner.web.orders;
import java.util.List;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.orders.entities.IOrderLineGroup;
import org.navalplanner.business.orders.entities.Order;
/**
* Contract for {@link OrderModel}<br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface IOrderModel {
List<Order> getOrders();
void prepareEditFor(Order order);
void prepareForCreate();
void save() throws ValidationException;
IOrderLineGroup getOrder();
void remove(Order order);
void prepareForRemove(Order order);
OrderElementModel getOrderElementTreeModel();
}

58
navalplanner-webapp/src/main/java/org/navalplanner/web/workorders/ProjectWorkCRUDController.java → navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderCRUDController.java
View file

@ -1,10 +1,10 @@
package org.navalplanner.web.workorders;
package org.navalplanner.web.orders;
import java.util.List;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.workorders.entities.ITaskWorkContainer;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.orders.entities.IOrderLineGroup;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.web.common.IMessagesForUser;
import org.navalplanner.web.common.Level;
import org.navalplanner.web.common.MessagesForUser;
@ -18,9 +18,9 @@ import org.zkoss.zul.api.Window;
* Controller for CRUD actions <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class ProjectWorkCRUDController extends GenericForwardComposer {
public class OrderCRUDController extends GenericForwardComposer {
private IProjectWorkModel projectWorkModel;
private IOrderModel orderModel;
private IMessagesForUser messagesForUser;
@ -36,8 +36,8 @@ public class ProjectWorkCRUDController extends GenericForwardComposer {
private Window confirmRemove;
public List<ProjectWork> getProjects() {
return projectWorkModel.getProjects();
public List<Order> getOrders() {
return orderModel.getOrders();
}
private OnlyOneVisible getVisibility() {
@ -48,14 +48,14 @@ public class ProjectWorkCRUDController extends GenericForwardComposer {
return cachedOnlyOneVisible;
}
public ITaskWorkContainer getProject() {
return projectWorkModel.getProject();
public IOrderLineGroup getOrder() {
return orderModel.getOrder();
}
public void save() {
try {
projectWorkModel.save();
messagesForUser.showMessage(Level.INFO, "proxecto gardado");
orderModel.save();
messagesForUser.showMessage(Level.INFO, "order saved");
goToList();
} catch (ValidationException e) {
messagesForUser.showInvalidValues(e);
@ -71,8 +71,8 @@ public class ProjectWorkCRUDController extends GenericForwardComposer {
goToList();
}
public void confirmRemove(ProjectWork project) {
projectWorkModel.prepareForRemove(project);
public void confirmRemove(Order order) {
orderModel.prepareForRemove(order);
showConfirmingWindow();
}
@ -103,22 +103,22 @@ public class ProjectWorkCRUDController extends GenericForwardComposer {
}
}
public void goToEditForm(ProjectWork project) {
projectWorkModel.prepareEditFor(project);
public void goToEditForm(Order order) {
orderModel.prepareEditFor(order);
getVisibility().showOnly(editWindow);
Util.reloadBindings(editWindow);
}
public void remove(ProjectWork projectWork) {
projectWorkModel.remove(projectWork);
public void remove(Order order) {
orderModel.remove(order);
hideConfirmingWindow();
Util.reloadBindings(listWindow);
messagesForUser.showMessage(Level.INFO, "removed "
+ projectWork.getName());
+ order.getName());
}
public void goToCreateForm() {
projectWorkModel.prepareForCreate();
orderModel.prepareForCreate();
getVisibility().showOnly(createWindow);
Util.reloadBindings(createWindow);
}
@ -130,20 +130,22 @@ public class ProjectWorkCRUDController extends GenericForwardComposer {
comp.setVariable("controller", this, true);
getVisibility().showOnly(listWindow);
TaskWorkController taskWorkController = new TaskWorkController();
taskWorkController.doAfterCompose(comp.getFellow("editTaskWorkPopup"));
OrderElementController orderElementController = new OrderElementController();
orderElementController.doAfterCompose(comp
.getFellow("editOrderElementPopup"));
setupTaskTreeController(comp, "editWindow", taskWorkController);
setupTaskTreeController(comp, "createWindow", taskWorkController);
setupOrderElementTreeController(comp, "editWindow", orderElementController);
setupOrderElementTreeController(comp, "createWindow", orderElementController);
}
private void setupTaskTreeController(Component comp, String window,
TaskWorkController taskWorkController)
private void setupOrderElementTreeController(Component comp, String window,
OrderElementController orderElementController)
throws Exception {
TaskWorksTreeController controller = new TaskWorksTreeController(
projectWorkModel, taskWorkController);
OrderElementTreeController controller = new OrderElementTreeController(
orderModel, orderElementController);
controller
.doAfterCompose(comp.getFellow(window).getFellow("tasksTree"));
.doAfterCompose(comp.getFellow(window).getFellow(
"orderElementTree"));
}
}

146
navalplanner-webapp/src/main/java/org/navalplanner/web/workorders/TaskWorkController.java → navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementController.java
View file

@ -1,16 +1,16 @@
package org.navalplanner.web.workorders;
package org.navalplanner.web.orders;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import org.navalplanner.business.workorders.entities.ActivityWork;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.workorders.entities.TaskWork;
import org.navalplanner.business.workorders.entities.TaskWorkContainer;
import org.navalplanner.business.workorders.entities.TaskWorkLeaf;
import org.navalplanner.business.workorders.entities.ActivityWork.HoursPolicies;
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.orders.entities.OrderLineGroup;
import org.navalplanner.business.orders.entities.HoursGroup.HoursPolicies;
import org.navalplanner.web.common.Util;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.event.Event;
@ -29,47 +29,47 @@ import org.zkoss.zul.Popup;
import org.zkoss.zul.Textbox;
/**
* Controller for {@link TaskWork} view of {@link ProjectWork} entities <br />
* Controller for {@link OrderElement} view of {@link Order} entities <br />
*
* @author Manuel Rego Casasnovas <mrego@igalia.com>
*/
public class TaskWorkController extends GenericForwardComposer {
public class OrderElementController extends GenericForwardComposer {
/**
* {@link TaskWork} that is managed
* {@link OrderElement} that is managed
*/
private TaskWork taskWork;
private OrderElement orderElement;
/**
* {@link Popup} where {@link TaskWork} edition form is showed
* {@link Popup} where {@link OrderElement} edition form is showed
*/
private Popup popup;
/**
* Model of the {@link ActivityWork} list
* Model of the {@link HoursGroup} list
*/
private List<ActivityWork> activityWorksModel;
private List<HoursGroup> hoursGroupsModel;
/**
* {@link Listitem} for every {@link ActivityWork}
* {@link Listitem} for every {@link HoursGroup}
*/
private AcitivyWorkListitemRender renderer = new AcitivyWorkListitemRender();
private HoursGroupListitemRender renderer = new HoursGroupListitemRender();
/**
* {@link Listbox} where {@link ActivityWork} are shown
* {@link Listbox} where {@link HoursGroup} are shown
*/
private Listbox activityWorksListbox;
private Listbox hoursGroupsListbox;
public TaskWork getTaskWork() {
return taskWork;
public OrderElement getOrderElement() {
return orderElement;
}
public List<ActivityWork> getActivityWorksModel() {
return activityWorksModel;
public List<HoursGroup> getHoursGroupsModel() {
return hoursGroupsModel;
}
public AcitivyWorkListitemRender getRenderer() {
public HoursGroupListitemRender getRenderer() {
return renderer;
}
@ -77,43 +77,43 @@ public class TaskWorkController extends GenericForwardComposer {
@Override
public void doAfterCompose(Component comp) throws Exception {
super.doAfterCompose(comp);
comp.setVariable("taskWorkController", this, true);
comp.setVariable("orderElementController", this, true);
popup = (Popup) comp;
}
/**
* Open the popup to edit a {@link TaskWork}. If it's a
* {@link TaskWorkContainer} less fields will be enabled.
* Open the popup to edit a {@link OrderElement}. If it's a
* {@link OrderLineGroup} less fields will be enabled.
*
* @param taskWork
* The {@link TaskWork} to be edited
* @param orderElement
* The {@link OrderElement} to be edited
*/
public void openPopup(TaskWork taskWork) {
this.taskWork = taskWork;
public void openPopup(OrderElement orderElement) {
this.orderElement = orderElement;
this.activityWorksModel = taskWork.getActivities();
this.hoursGroupsModel = orderElement.getHoursGroups();
// If is a container
if (taskWork instanceof TaskWorkContainer) {
// Disable fields just used in the TaskWorkLeaf
if (orderElement instanceof OrderLineGroup) {
// Disable fields just used in the OrderLine
((Textbox) popup.getFellow("totalHours")).setDisabled(true);
// Hide not needed buttons
popup.getFellow("manageCriterions").setVisible(false);
popup.getFellow("addActivityWork").setVisible(false);
popup.getFellow("deleteActivityWork").setVisible(false);
popup.getFellow("addHoursGroup").setVisible(false);
popup.getFellow("deleteHoursGroup").setVisible(false);
} else {
// Enable fields just used in the TaskWorkLeaf
// Enable fields just used in the OrderLine
((Textbox) popup.getFellow("totalHours")).setDisabled(false);
// Show needed buttons
popup.getFellow("manageCriterions").setVisible(true);
popup.getFellow("addActivityWork").setVisible(true);
popup.getFellow("deleteActivityWork").setVisible(true);
popup.getFellow("addHoursGroup").setVisible(true);
popup.getFellow("deleteHoursGroup").setVisible(true);
}
fillFixedHoursCheckbox(taskWork);
fillFixedHoursCheckbox(orderElement);
Util.reloadBindings(popup);
@ -124,13 +124,13 @@ public class TaskWorkController extends GenericForwardComposer {
* Private method that just fills the Div with id "fixedHoursCheckbox" in
* the .zul.
*
* If the parameter is a {@link TaskWorkLeaf} the method adds the needed
* If the parameter is a {@link OrderLine} the method adds the needed
* checkbox.
*
* @param taskWork
* {@link TaskWork} that is been rendered
* @param orderElement
* {@link OrderElement} that is been rendered
*/
private void fillFixedHoursCheckbox(final TaskWork taskWork) {
private void fillFixedHoursCheckbox(final OrderElement orderElement) {
// Get the Div with id "fixedHoursCheckbox"
Component fixedHoursCheckbox = popup.getFellow("fixedHoursCheckbox");
@ -144,20 +144,20 @@ public class TaskWorkController extends GenericForwardComposer {
}
// If is a leaf
if (taskWork instanceof TaskWorkLeaf) {
if (orderElement instanceof OrderLine) {
// Add specific fields
fixedHoursCheckbox.appendChild(Util.bind(new Checkbox(),
new Util.Getter<Boolean>() {
@Override
public Boolean get() {
return ((TaskWorkLeaf) taskWork).isFixedHours();
return ((OrderLine) orderElement).isFixedHours();
}
}, new Util.Setter<Boolean>() {
@Override
public void set(Boolean value) {
((TaskWorkLeaf) taskWork).setFixedHours(value);
((OrderLine) orderElement).setFixedHours(value);
}
}));
fixedHoursCheckbox.appendChild(new Label("Fixed hours"));
@ -181,48 +181,48 @@ public class TaskWorkController extends GenericForwardComposer {
}
/**
* Adds a new {@link ActivityWork} to the current {@link TaskWork}
* Adds a new {@link HoursGroup} to the current {@link OrderElement}
*
* The {@link TaskWork} should be a {@link TaskWorkLeaf}
* The {@link OrderElement} should be a {@link OrderLine}
*/
public void addActivityWork() {
ActivityWork activity = new ActivityWork();
public void addHoursGroup() {
HoursGroup hoursGroup = new HoursGroup();
((TaskWorkLeaf) taskWork).addActivity(activity);
((OrderLine) orderElement).addHoursGroup(hoursGroup);
this.activityWorksModel = taskWork.getActivities();
this.hoursGroupsModel = orderElement.getHoursGroups();
Util.reloadBindings(popup);
}
/**
* Deletes the selected {@link ActivityWork} for the current
* {@link TaskWork}
* Deletes the selected {@link HoursGroup} for the current
* {@link OrderElement}
*
* The {@link TaskWork} should be a {@link TaskWorkLeaf}
* The {@link OrderElement} should be a {@link OrderLine}
*/
public void deleteActivityWorks() {
Set<Listitem> selectedItems = activityWorksListbox.getSelectedItems();
public void deleteHoursGroups() {
Set<Listitem> selectedItems = hoursGroupsListbox.getSelectedItems();
for (Listitem item : selectedItems) {
((TaskWorkLeaf) taskWork).deleteActivity((ActivityWork) item
((OrderLine) orderElement).deleteHoursGroup((HoursGroup) item
.getValue());
}
this.activityWorksModel = taskWork.getActivities();
this.hoursGroupsModel = orderElement.getHoursGroups();
Util.reloadBindings(popup);
}
/**
* Represents every {@link AcitivyWork} with an edition form if needed
* Represents every {@link HoursGroup} with an edition form if needed
*
* @author Manuel Rego Casasnovas <mrego@igalia.com>
*/
public class AcitivyWorkListitemRender implements ListitemRenderer {
public class HoursGroupListitemRender implements ListitemRenderer {
@Override
public void render(Listitem item, Object data) throws Exception {
final ActivityWork activity = (ActivityWork) data;
final HoursGroup hoursGroup = (HoursGroup) data;
item.setValue(activity);
item.setValue(hoursGroup);
Listcell cellWorkingHours = new Listcell();
cellWorkingHours.setParent(item);
@ -244,7 +244,7 @@ public class TaskWorkController extends GenericForwardComposer {
}
// If is a container
if (taskWork instanceof TaskWorkContainer) {
if (orderElement instanceof OrderLineGroup) {
// Just getters are needed
// Working hours
@ -253,7 +253,7 @@ public class TaskWorkController extends GenericForwardComposer {
@Override
public Integer get() {
return activity.getWorkingHours();
return hoursGroup.getWorkingHours();
}
}));
@ -263,12 +263,12 @@ public class TaskWorkController extends GenericForwardComposer {
@Override
public BigDecimal get() {
return activity.getPercentage();
return hoursGroup.getPercentage();
}
}));
// Hours policy
hoursPolicyListBox.setSelectedIndex(activity.getHoursPolicy()
hoursPolicyListBox.setSelectedIndex(hoursGroup.getHoursPolicy()
.ordinal());
hoursPolicyListBox.setDisabled(true);
cellHoursPolicy.appendChild(hoursPolicyListBox);
@ -280,13 +280,13 @@ public class TaskWorkController extends GenericForwardComposer {
@Override
public Integer get() {
return activity.getWorkingHours();
return hoursGroup.getWorkingHours();
}
}, new Util.Setter<Integer>() {
@Override
public void set(Integer value) {
activity.setWorkingHours(value);
hoursGroup.setWorkingHours(value);
}
});
@ -295,18 +295,18 @@ public class TaskWorkController extends GenericForwardComposer {
@Override
public BigDecimal get() {
return activity.getPercentage();
return hoursGroup.getPercentage();
}
}, new Util.Setter<BigDecimal>() {
@Override
public void set(BigDecimal value) {
activity.setPercentage(value);
hoursGroup.setPercentage(value);
}
});
// Hours policy
hoursPolicyListBox.setSelectedIndex(activity.getHoursPolicy()
hoursPolicyListBox.setSelectedIndex(hoursGroup.getHoursPolicy()
.ordinal());
hoursPolicyListBox.addEventListener(Events.ON_SELECT,
new EventListener() {
@ -315,7 +315,7 @@ public class TaskWorkController extends GenericForwardComposer {
public void onEvent(Event event) throws Exception {
HoursPolicies policy = (HoursPolicies) hoursPolicyListBox
.getSelectedItem().getValue();
activity.setHoursPolicy(policy);
hoursGroup.setHoursPolicy(policy);
// Disable components depending on the policy
disableComponents(workingHours, percentage,

127
navalplanner-webapp/src/main/java/org/navalplanner/web/workorders/TaskTreeModel.java → navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementModel.java
View file

@ -1,89 +1,90 @@
package org.navalplanner.web.workorders;
package org.navalplanner.web.orders;
import java.util.ArrayList;
import java.util.List;
import org.navalplanner.business.workorders.entities.ITaskWorkContainer;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.workorders.entities.TaskWork;
import org.navalplanner.business.workorders.entities.TaskWorkContainer;
import org.navalplanner.business.workorders.entities.TaskWorkLeaf;
import org.navalplanner.business.orders.entities.IOrderLineGroup;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.business.orders.entities.OrderLineGroup;
import org.zkoss.zul.SimpleTreeModel;
import org.zkoss.zul.SimpleTreeNode;
/**
* Model for a the tasks tree for a project <br />
* Model for a the {@link OrderElement} tree for a {@link Order} <br />
*
* @author Lorenzo Tilve Álvaro <ltilve@igalia.com>
*/
public class TaskTreeModel extends SimpleTreeModel {
public class OrderElementModel extends SimpleTreeModel {
private static List<SimpleTreeNode> asNodes(List<TaskWork> taskWorks) {
private static List<SimpleTreeNode> asNodes(List<OrderElement> orderElements) {
ArrayList<SimpleTreeNode> result = new ArrayList<SimpleTreeNode>();
for (TaskWork taskWork : taskWorks) {
result.add(asNode(taskWork));
for (OrderElement orderElement : orderElements) {
result.add(asNode(orderElement));
}
return result;
}
private static SimpleTreeNode asNode(TaskWork taskWork) {
taskWork.forceLoadActivities();
return new SimpleTreeNode(taskWork, asNodes(taskWork.getChildren()));
private static SimpleTreeNode asNode(OrderElement orderElement) {
orderElement.forceLoadHourGroups();
return new SimpleTreeNode(orderElement, asNodes(orderElement.getChildren()));
}
private static SimpleTreeNode createRootNodeAndDescendants(
ProjectWork project) {
return new SimpleTreeNode(project, asNodes(project.getTaskWorks()));
Order order) {
return new SimpleTreeNode(order, asNodes(order.getOrderElements()));
}
public TaskTreeModel(ProjectWork projectWork) {
super(createRootNodeAndDescendants(projectWork));
public OrderElementModel(Order order) {
super(createRootNodeAndDescendants(order));
}
public void reloadFromProjectWork() {
ProjectWork root = getRootAsProject();
public void reloadFromOrder() {
Order root = getRootAsOrder();
SimpleTreeNode rootAsNode = getRootAsNode();
rootAsNode.getChildren().clear();
rootAsNode.getChildren().addAll(asNodes(root.getTaskWorks()));
rootAsNode.getChildren().addAll(asNodes(root.getOrderElements()));
}
public void addTask() {
addTaskAtImpl(getRootAsNode());
reloadFromProjectWork();
public void addOrderElement() {
addOrderElementAtImpl(getRootAsNode());
reloadFromOrder();
}
private TaskWork createNewTask() {
TaskWork newTask = new TaskWorkLeaf();
newTask.setName("Nova Tarefa");
return newTask;
private OrderElement createNewOrderElement() {
OrderElement newOrderElement = new OrderLine();
newOrderElement.setName("New Order Element");
return newOrderElement;
}
public void addTaskAt(SimpleTreeNode node) {
addTaskAtImpl(node);
reloadFromProjectWork();
public void addOrderElementAt(SimpleTreeNode node) {
addOrderElementAtImpl(node);
reloadFromOrder();
}
private void addTaskAtImpl(SimpleTreeNode node) {
addTaskAtImpl(node, createNewTask());
private void addOrderElementAtImpl(SimpleTreeNode node) {
addOrderElementAtImpl(node, createNewOrderElement());
}
private void addTaskAtImpl(SimpleTreeNode node, TaskWork task) {
addTaskAtImpl(node, task, node.getChildCount());
private void addOrderElementAtImpl(SimpleTreeNode node, OrderElement orderElement) {
addOrderElementAtImpl(node, orderElement, node.getChildCount());
}
private void addTaskAtImpl(SimpleTreeNode destinationNode, TaskWork task,
private void addOrderElementAtImpl(SimpleTreeNode destinationNode, OrderElement orderElement,
int position) {
ITaskWorkContainer container = turnIntoContainerIfNeeded(destinationNode);
container.add(position, task);
IOrderLineGroup container = turnIntoContainerIfNeeded(destinationNode);
container.add(position, orderElement);
}
private ITaskWorkContainer turnIntoContainerIfNeeded(
private IOrderLineGroup turnIntoContainerIfNeeded(
SimpleTreeNode selectedForTurningIntoContainer) {
ITaskWorkContainer parentContainer = asTaskContainer(getParent(selectedForTurningIntoContainer));
if (selectedForTurningIntoContainer.getData() instanceof ITaskWorkContainer)
return (ITaskWorkContainer) selectedForTurningIntoContainer
IOrderLineGroup parentContainer = asOrderLineGroup(getParent(selectedForTurningIntoContainer));
if (selectedForTurningIntoContainer.getData() instanceof IOrderLineGroup)
return (IOrderLineGroup) selectedForTurningIntoContainer
.getData();
TaskWork toBeTurned = asTask(selectedForTurningIntoContainer);
TaskWorkContainer asContainer = toBeTurned.asContainer();
OrderElement toBeTurned = asOrderLine(selectedForTurningIntoContainer);
OrderLineGroup asContainer = toBeTurned.asContainer();
parentContainer.replace(toBeTurned, asContainer);
return asContainer;
}
@ -124,7 +125,7 @@ public class TaskTreeModel extends SimpleTreeModel {
SimpleTreeNode destination = (SimpleTreeNode) parentOfSelected
.getChildren().get(position - 1);
moveImpl(nodeToIndent, destination, destination.getChildCount());
reloadFromProjectWork();
reloadFromOrder();
}
public void unindent(SimpleTreeNode nodeToUnindent) {
@ -135,12 +136,12 @@ public class TaskTreeModel extends SimpleTreeModel {
SimpleTreeNode destination = getParent(parent);
moveImpl(nodeToUnindent, destination, destination.getChildren()
.indexOf(parent) + 1);
reloadFromProjectWork();
reloadFromOrder();
}
public void move(SimpleTreeNode toBeMoved, SimpleTreeNode destination) {
moveImpl(toBeMoved, destination, destination.getChildCount());
reloadFromProjectWork();
reloadFromOrder();
}
private void moveImpl(SimpleTreeNode toBeMoved, SimpleTreeNode destination,
@ -149,7 +150,7 @@ public class TaskTreeModel extends SimpleTreeModel {
return;// it's already moved
}
removeNodeImpl(toBeMoved);
addTaskAtImpl(destination, asTask(toBeMoved), position);
addOrderElementAtImpl(destination, asOrderLine(toBeMoved), position);
}
public int[] getPath(SimpleTreeNode destination) {
@ -158,27 +159,27 @@ public class TaskTreeModel extends SimpleTreeModel {
}
public void up(SimpleTreeNode node) {
ITaskWorkContainer taskWorkContainer = asTaskContainer(getParent(node));
taskWorkContainer.up(asTask(node));
reloadFromProjectWork();
IOrderLineGroup orderLineGroup = asOrderLineGroup(getParent(node));
orderLineGroup.up(asOrderLine(node));
reloadFromOrder();
}
public void down(SimpleTreeNode node) {
ITaskWorkContainer taskWorkContainer = asTaskContainer(getParent(node));
taskWorkContainer.down(asTask(node));
reloadFromProjectWork();
IOrderLineGroup orderLineGroup = asOrderLineGroup(getParent(node));
orderLineGroup.down(asOrderLine(node));
reloadFromOrder();
}
private ProjectWork getRootAsProject() {
return (ProjectWork) getRootAsNode().getData();
private Order getRootAsOrder() {
return (Order) getRootAsNode().getData();
}
private static TaskWork asTask(SimpleTreeNode node) {
return (TaskWork) node.getData();
private static OrderElement asOrderLine(SimpleTreeNode node) {
return (OrderElement) node.getData();
}
private static ITaskWorkContainer asTaskContainer(SimpleTreeNode node) {
return (ITaskWorkContainer) node.getData();
private static IOrderLineGroup asOrderLineGroup(SimpleTreeNode node) {
return (IOrderLineGroup) node.getData();
}
private SimpleTreeNode getRootAsNode() {
@ -187,14 +188,14 @@ public class TaskTreeModel extends SimpleTreeModel {
public void removeNode(SimpleTreeNode value) {
removeNodeImpl(value);
reloadFromProjectWork();
reloadFromOrder();
}
private void removeNodeImpl(SimpleTreeNode value) {
if (value == getRootAsNode())
return;
ITaskWorkContainer taskContainer = asTaskContainer(getParent(value));
taskContainer.remove(asTask(value));
IOrderLineGroup orderLineGroup = asOrderLineGroup(getParent(value));
orderLineGroup.remove(asOrderLine(value));
}
}

98
navalplanner-webapp/src/main/java/org/navalplanner/web/workorders/TaskWorksTreeController.java → navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementTreeController.java
View file

@ -1,4 +1,4 @@
package org.navalplanner.web.workorders;
package org.navalplanner.web.orders;
import java.util.Date;
import java.util.HashMap;
@ -8,9 +8,9 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.workorders.entities.TaskWork;
import org.navalplanner.business.workorders.entities.TaskWorkLeaf;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.web.common.Util;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.event.DropEvent;
@ -29,49 +29,49 @@ import org.zkoss.zul.Treerow;
import org.zkoss.zul.api.Tree;
/**
* Controller for {@link WorkOrganization} view of WorkOrder entities <br />
* Controller for {@link OrderElement} tree view of {@link Order} entities <br />
*
* @author Lorenzo Tilve Álvaro <ltilve@igalia.com>
* @author Manuel Rego Casasnovas <mrego@igalia.com>
*/
public class TaskWorksTreeController extends GenericForwardComposer {
public class OrderElementTreeController extends GenericForwardComposer {
private Tree tree;
private TaskWorkTreeitemRenderer renderer = new TaskWorkTreeitemRenderer();
private OrderElementTreeitemRenderer renderer = new OrderElementTreeitemRenderer();
private TreeViewStateSnapshot snapshotOfOpenedNodes;
private final IProjectWorkModel projectWorkModel;
private final IOrderModel orderModel;
private final TaskWorkController taskWorkController;
private final OrderElementController orderElementController;
public TaskWorkTreeitemRenderer getRenderer() {
public OrderElementTreeitemRenderer getRenderer() {
return renderer;
}
public TaskWorksTreeController(IProjectWorkModel projectWorkModel,
TaskWorkController taskWorkController) {
this.projectWorkModel = projectWorkModel;
this.taskWorkController = taskWorkController;
public OrderElementTreeController(IOrderModel orderModel,
OrderElementController orderElementController) {
this.orderModel = orderModel;
this.orderElementController = orderElementController;
}
public void indent() {
snapshotOfOpenedNodes = TreeViewStateSnapshot.snapshotOpened(tree);
if (tree.getSelectedCount() == 1) {
getTasksTreeModel().indent(getSelectedNode());
getOrderElementTreeModel().indent(getSelectedNode());
Util.reloadBindings(tree);
}
}
public TaskTreeModel getTasksTreeModel() {
return projectWorkModel.getTasksTreeModel();
public OrderElementModel getOrderElementTreeModel() {
return orderModel.getOrderElementTreeModel();
}
public void unindent() {
snapshotOfOpenedNodes = TreeViewStateSnapshot.snapshotOpened(tree);
if (tree.getSelectedCount() == 1) {
getTasksTreeModel().unindent(getSelectedNode());
getOrderElementTreeModel().unindent(getSelectedNode());
Util.reloadBindings(tree);
}
}
@ -79,7 +79,7 @@ public class TaskWorksTreeController extends GenericForwardComposer {
public void up() {
snapshotOfOpenedNodes = TreeViewStateSnapshot.snapshotOpened(tree);
if (tree.getSelectedCount() == 1) {
getTasksTreeModel().up(getSelectedNode());
getOrderElementTreeModel().up(getSelectedNode());
Util.reloadBindings(tree);
}
}
@ -87,7 +87,7 @@ public class TaskWorksTreeController extends GenericForwardComposer {
public void down() {
snapshotOfOpenedNodes = TreeViewStateSnapshot.snapshotOpened(tree);
if (tree.getSelectedCount() == 1) {
getTasksTreeModel().down(getSelectedNode());
getOrderElementTreeModel().down(getSelectedNode());
Util.reloadBindings(tree);
}
}
@ -104,16 +104,16 @@ public class TaskWorksTreeController extends GenericForwardComposer {
.getValue();
SimpleTreeNode toNode = (SimpleTreeNode) ((Treeitem) to.getParent())
.getValue();
getTasksTreeModel().move(fromNode, toNode);
getOrderElementTreeModel().move(fromNode, toNode);
Util.reloadBindings(tree);
}
public void addTaskWork() {
public void addOrderElement() {
snapshotOfOpenedNodes = TreeViewStateSnapshot.snapshotOpened(tree);
if (tree.getSelectedCount() == 1) {
getTasksTreeModel().addTaskAt(getSelectedNode());
getOrderElementTreeModel().addOrderElementAt(getSelectedNode());
} else {
getTasksTreeModel().addTask();
getOrderElementTreeModel().addOrderElement();
}
Util.reloadBindings(tree);
}
@ -162,86 +162,86 @@ public class TaskWorksTreeController extends GenericForwardComposer {
}
}
public void removeTaskWork() {
public void removeOrderElement() {
Set<Treeitem> selectedItems = tree.getSelectedItems();
for (Treeitem treeItem : selectedItems) {
SimpleTreeNode value = (SimpleTreeNode) treeItem.getValue();
getTasksTreeModel().removeNode(value);
getOrderElementTreeModel().removeNode(value);
}
Util.reloadBindings(tree);
}
void doEditFor(ProjectWork projectWork) {
void doEditFor(Order order) {
Util.reloadBindings(tree);
}
@Override
public void doAfterCompose(Component comp) throws Exception {
super.doAfterCompose(comp);
comp.setVariable("tasksTreeController", this, true);
comp.setVariable("orderElementTreeController", this, true);
}
public class TaskWorkTreeitemRenderer implements TreeitemRenderer {
public class OrderElementTreeitemRenderer implements TreeitemRenderer {
private Map<SimpleTreeNode, Intbox> map = new HashMap<SimpleTreeNode, Intbox>();
public void TaskWorkTreeitemRenderer() {
public OrderElementTreeitemRenderer() {
}
@Override
public void render(Treeitem item, Object data) throws Exception {
final SimpleTreeNode t = (SimpleTreeNode) data;
item.setValue(data);
final TaskWork taskWork = (TaskWork) t.getData();
final OrderElement orderElement = (OrderElement) t.getData();
if (snapshotOfOpenedNodes != null) {
snapshotOfOpenedNodes.openIfRequired(item);
}
// Contruct treecells
int[] path = getTasksTreeModel().getPath(t);
// Construct treecells
int[] path = getOrderElementTreeModel().getPath(t);
Treecell cellForName = new Treecell(pathAsString(path));
cellForName.appendChild(Util.bind(new Textbox(),
new Util.Getter<String>() {
@Override
public String get() {
return taskWork.getName();
return orderElement.getName();
}
}, new Util.Setter<String>() {
@Override
public void set(String value) {
taskWork.setName(value);
orderElement.setName(value);
}
}));
Treecell cellForHours = new Treecell();
Intbox intboxHours = new Intbox();
map.put(t, intboxHours);
if (taskWork instanceof TaskWorkLeaf) {
if (orderElement instanceof OrderLine) {
// If it's a leaf hours cell is editable
cellForHours.appendChild(Util.bind(intboxHours,
new Util.Getter<Integer>() {
@Override
public Integer get() {
return taskWork.getWorkHours();
return orderElement.getWorkHours();
}
}, new Util.Setter<Integer>() {
@Override
public void set(Integer value) {
((TaskWorkLeaf) taskWork).setWorkHours(value);
((OrderLine) orderElement).setWorkHours(value);
List<SimpleTreeNode> parentNodes = getTasksTreeModel()
List<SimpleTreeNode> parentNodes = getOrderElementTreeModel()
.getParents(t);
// Remove the last element becuase it's a
// ProjectWork node, not a TaskWork
// Remove the last element becuase it's an
// Order node, not an OrderElement
parentNodes.remove(parentNodes.size() - 1);
for (SimpleTreeNode node : parentNodes) {
Intbox intbox = map.get(node);
TaskWork parentTaskWork = (TaskWork) node
OrderElement parentOrderElement = (OrderElement) node
.getData();
intbox.setValue(parentTaskWork
intbox.setValue(parentOrderElement
.getWorkHours());
}
}
@ -253,7 +253,7 @@ public class TaskWorksTreeController extends GenericForwardComposer {
@Override
public Integer get() {
return taskWork.getWorkHours();
return orderElement.getWorkHours();
}
}));
}
@ -263,13 +263,13 @@ public class TaskWorksTreeController extends GenericForwardComposer {
@Override
public Date get() {
return taskWork.getInitDate();
return orderElement.getInitDate();
}
}, new Util.Setter<Date>() {
@Override
public void set(Date value) {
taskWork.setInitDate(value);
orderElement.setInitDate(value);
}
}));
Treecell tcDateEnd = new Treecell();
@ -278,13 +278,13 @@ public class TaskWorksTreeController extends GenericForwardComposer {
@Override
public Date get() {
return taskWork.getEndDate();
return orderElement.getEndDate();
}
}, new Util.Setter<Date>() {
@Override
public void set(Date value) {
taskWork.setEndDate(value);
orderElement.setEndDate(value);
}
}));
@ -326,7 +326,7 @@ public class TaskWorksTreeController extends GenericForwardComposer {
@Override
public void onEvent(Event event) throws Exception {
taskWorkController.openPopup(taskWork);
orderElementController.openPopup(orderElement);
}
});

102
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderModel.java Normal file
View file

@ -0,0 +1,102 @@
package org.navalplanner.web.orders;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang.Validate;
import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.orders.entities.IOrderLineGroup;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.services.IOrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
/**
* Model for UI operations related to {@link Order}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class OrderModel implements IOrderModel {
private final IOrderService orderService;
private Order order;
private ClassValidator<Order> orderValidator = new ClassValidator<Order>(
Order.class);
private OrderElementModel orderElementTreeModel;
@Autowired
public OrderModel(IOrderService orderService) {
Validate.notNull(orderService);
this.orderService = orderService;
}
@Override
@Transactional(readOnly = true)
public List<Order> getOrders() {
return orderService.getOrders();
}
@Override
@Transactional(readOnly = true)
public void prepareEditFor(Order order) {
Validate.notNull(order);
try {
this.order = orderService.find(order.getId());
this.orderElementTreeModel = new OrderElementModel(this.order);
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
@Override
public void prepareForCreate() {
this.order = new Order();
this.orderElementTreeModel = new OrderElementModel(this.order);
this.order.setInitDate(new Date());
}
@Override
@Transactional
public void save() throws ValidationException {
InvalidValue[] invalidValues = orderValidator
.getInvalidValues(order);
if (invalidValues.length > 0)
throw new ValidationException(invalidValues);
this.orderService.save(order);
}
@Override
public IOrderLineGroup getOrder() {
return order;
}
@Override
public void remove(Order order) {
try {
this.orderService.remove(order);
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
@Override
public void prepareForRemove(Order order) {
this.order = order;
}
@Override
public OrderElementModel getOrderElementTreeModel() {
return orderElementTreeModel;
}
}

31
navalplanner-webapp/src/main/java/org/navalplanner/web/workorders/IProjectWorkModel.java
View file

@ -1,31 +0,0 @@
package org.navalplanner.web.workorders;
import java.util.List;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.workorders.entities.ITaskWorkContainer;
import org.navalplanner.business.workorders.entities.ProjectWork;
/**
* Contract for {@link ProjectWorkModel}<br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public interface IProjectWorkModel {
List<ProjectWork> getProjects();
void prepareEditFor(ProjectWork project);
void prepareForCreate();
void save() throws ValidationException;
ITaskWorkContainer getProject();
void remove(ProjectWork projectWork);
void prepareForRemove(ProjectWork project);
TaskTreeModel getTasksTreeModel();
}

102
navalplanner-webapp/src/main/java/org/navalplanner/web/workorders/ProjectWorkModel.java
View file

@ -1,102 +0,0 @@
package org.navalplanner.web.workorders;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang.Validate;
import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.workorders.entities.ITaskWorkContainer;
import org.navalplanner.business.workorders.entities.ProjectWork;
import org.navalplanner.business.workorders.services.IProjectWorkService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
/**
* Model for UI operations related to {@link ProjectWork}. <br />
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class ProjectWorkModel implements IProjectWorkModel {
private final IProjectWorkService projectService;
private ProjectWork project;
private ClassValidator<ProjectWork> projectValidator = new ClassValidator<ProjectWork>(
ProjectWork.class);
private TaskTreeModel tasksTreeModel;
@Autowired
public ProjectWorkModel(IProjectWorkService projectService) {
Validate.notNull(projectService);
this.projectService = projectService;
}
@Override
@Transactional(readOnly = true)
public List<ProjectWork> getProjects() {
return projectService.getProjectWorks();
}
@Override
@Transactional(readOnly = true)
public void prepareEditFor(ProjectWork project) {
Validate.notNull(project);
try {
this.project = projectService.find(project.getId());
this.tasksTreeModel = new TaskTreeModel(this.project);
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
@Override
public void prepareForCreate() {
this.project = new ProjectWork();
this.tasksTreeModel = new TaskTreeModel(this.project);
this.project.setInitDate(new Date());
}
@Override
@Transactional
public void save() throws ValidationException {
InvalidValue[] invalidValues = projectValidator
.getInvalidValues(project);
if (invalidValues.length > 0)
throw new ValidationException(invalidValues);
this.projectService.save(project);
}
@Override
public ITaskWorkContainer getProject() {
return project;
}
@Override
public void remove(ProjectWork projectWork) {
try {
this.projectService.remove(projectWork);
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
@Override
public void prepareForRemove(ProjectWork project) {
this.project = project;
}
@Override
public TaskTreeModel getTasksTreeModel() {
return tasksTreeModel;
}
}

4
navalplanner-webapp/src/main/webapp/WEB-INF/i3-label.properties
View file

@ -29,5 +29,5 @@ mainmenu.help=Axuda
mainmenu.about=Acerca de
mainmenu.aclunaga=Aclunaga
mainmenu.manage_criterions=Administrar criterios
mainmenu.workorders=Traballos
mainmenu.list_projects=Proxectos
mainmenu.orders=Pedidos
mainmenu.list_orders=Lista de pedidos

4
navalplanner-webapp/src/main/webapp/WEB-INF/i3-label_en_US.properties
View file

@ -29,5 +29,5 @@ mainmenu.help=Help
mainmenu.about=About
mainmenu.aclunaga=Aclunaga
mainmenu.manage_criterions=Manage criterions
mainmenu.workorders=Work
mainmenu.list_projects=Projects
mainmenu.orders=Orders
mainmenu.list_orders=Orders list

6
navalplanner-webapp/src/main/webapp/common/layout/template.zul
View file

@ -36,10 +36,10 @@
</menupopup>
</menu>
<menu label="${c:l('mainmenu.workorders')}">
<menu label="${c:l('mainmenu.orders')}">
<menupopup>
<menuitem label="${c:l('mainmenu.list_projects')}"
href='/workorders/projects.zul' />
<menuitem label="${c:l('mainmenu.list_orders')}"
href='/orders/orders.zul' />
</menupopup>
</menu>

34
navalplanner-webapp/src/main/webapp/workorders/_editTaskWork.zul → navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul
View file

@ -5,19 +5,19 @@
<label value="${arg.title}" />
<hbox>
<label value="Task Name" />
<label value="Order Element Name" />
<textbox id="name"
value="@{taskWorkController.taskWork.name,
value="@{orderElementController.orderElement.name,
save-when='saveButton.onClick'}" />
</hbox>
<hbox>
<label value="Init Date" />
<datebox id="initDate"
value="@{taskWorkController.taskWork.initDate,
value="@{orderElementController.orderElement.initDate,
save-when='saveButton.onClick'}" />
<checkbox id="mandatoryInit"
checked="@{taskWorkController.taskWork.mandatoryInit},
checked="@{orderElementController.orderElement.mandatoryInit},
save-when='saveButton.onClick'" />
<label value="Mandatory" />
</hbox>
@ -25,10 +25,10 @@
<hbox>
<label value="End Date" />
<datebox id="endDate"
value="@{taskWorkController.taskWork.endDate,
value="@{orderElementController.orderElement.endDate,
save-when='saveButton.onClick'}" />
<checkbox id="mandatoryEnd"
checked="@{taskWorkController.taskWork.mandatoryEnd,
checked="@{orderElementController.orderElement.mandatoryEnd,
save-when='saveButton.onClick'}" />
<label value="Mandatory" />
</hbox>
@ -36,13 +36,13 @@
<hbox>
<label value="Total hours" />
<textbox id="totalHours"
value="@{taskWorkController.taskWork.workHours}" />
value="@{orderElementController.orderElement.workHours}" />
<div id="fixedHoursCheckbox" />
</hbox>
<listbox id="activityWorksListbox" multiple="true"
model="@{taskWorkController.activityWorksModel}"
itemRenderer="@{taskWorkController.renderer}">
<listbox id="hoursGroupsListbox" multiple="true"
model="@{orderElementController.hoursGroupsModel}"
itemRenderer="@{orderElementController.renderer}">
<listhead sizable="true">
<listheader label="Hours" />
<listheader label="%" />
@ -51,22 +51,22 @@
</listbox>
<hbox>
<button id="addActivityWork" label="Add activity work"
onClick="taskWorkController.addActivityWork();" />
<button id="deleteActivityWork" label="Delete activity work"
onClick="taskWorkController.deleteActivityWorks();" />
<button id="addHoursGroup" label="Add hours group"
onClick="orderElementController.addHoursGroup();" />
<button id="deleteHoursGroup" label="Delete hours group"
onClick="orderElementController.deleteHoursGroups();" />
<button id="manageCriterions" label="Manage criterions" />
</hbox>
<textbox id="description" rows="4"
value="@{taskWorkController.taskWork.description,
value="@{orderElementController.orderElement.description,
save-when='saveButton.onClick'}" />
<hbox>
<button onClick="taskWorkController.cancel();"
<button onClick="orderElementController.cancel();"
label="${arg.cancel_button_label}" />
<button id="saveButton"
onClick="taskWorkController.save();"
onClick="orderElementController.save();"
label="${arg.save_button_label}" />
</hbox>

32
navalplanner-webapp/src/main/webapp/workorders/_edition.zul → navalplanner-webapp/src/main/webapp/orders/_edition.zul
View file

@ -1,49 +1,49 @@
<?component name="tasksTree" inline="true" macroURI="_tasksTree.zul"?>
<?component name="orderElementTree" inline="true" macroURI="_orderElementTree.zul"?>
<window id="${arg.top_id}" title="${arg.title}">
<tabbox>
<tabs>
<tab label="Edición"></tab>
<tab label="Tarefas"></tab>
<tab label="Edition"></tab>
<tab label="Order Elements"></tab>
</tabs>
<tabpanels>
<tabpanel>
<grid fixedLayout="false">
<rows>
<row>
<label value="Nome" />
<textbox value="@{controller.project.name}" />
<label value="Name" />
<textbox value="@{controller.order.name}" />
</row>
<row>
<label value="Comezo" />
<label value="Init date" />
<datebox
value="@{controller.project.initDate}" />
value="@{controller.order.initDate}" />
</row>
<row>
<label value="Final" />
<label value="End date" />
<datebox
value="@{controller.project.endDate}" />
value="@{controller.order.endDate}" />
</row>
<row>
<label value="Responsable" />
<label value="Responsible" />
<textbox
value="@{controller.project.responsible}" />
value="@{controller.order.responsible}" />
</row>
<row>
<label value="Cliente" />
<label value="Customer" />
<textbox
value="@{controller.project.customer}" />
value="@{controller.order.customer}" />
</row>
<row>
<label value="Descripción" />
<label value="Description" />
<textbox
value="@{controller.project.description}"
value="@{controller.order.description}"
rows="4" />
</row>
</rows>
</grid>
</tabpanel>
<tabpanel>
<tasksTree />
<orderElementTree />
</tabpanel>
</tabpanels>
</tabbox>

36
navalplanner-webapp/src/main/webapp/orders/_list.zul Normal file
View file

@ -0,0 +1,36 @@
<window id="${arg.top_id}" title="Orders List">
<grid id="listing" model="@{controller.orders}" mold="paging"
pageSize="5">
<columns>
<column label="Operations" />
<column label="Name" sort="auto(name)" />
<column label="Init date" sort="auto(initDate)" />
<column label="End date" sort="auto(endDate)" />
<column label="Responsible" sort="auto(responsible)" />
<column label="Customer" sort="auto(customer)" />
<column label="Description" sort="auto(description)" />
</columns>
<rows>
<row self="@{each='order'}" value="@{order}">
<hbox>
<button label="Edit"
onClick="controller.goToEditForm(self.parent.parent.value);">
</button>
<button label="Remove"
onClick="controller.confirmRemove(self.parent.parent.value);">
</button>
</hbox>
<label value="@{order.name}" />
<label value="@{order.initDate}" />
<label value="@{order.endDate}" />
<label value="@{order.responsible}" />
<label value="@{order.customer}" />
<label value="@{order.description}" />
</row>
</rows>
</grid>
<button id="show_create_form" onClick="controller.goToCreateForm();"
label="Create">
</button>
</window>

40
navalplanner-webapp/src/main/webapp/orders/_orderElementTree.zul Normal file
View file

@ -0,0 +1,40 @@
<vbox id="orderElementTree">
<vbox>
<hbox>
<button label="New order element"
onClick="orderElementTreeController.addOrderElement();">
</button>
<button label="Remove order element"
onClick="orderElementTreeController.removeOrderElement();">
</button>
<button label="Indent"
onClick="orderElementTreeController.indent();">
</button>
<button label="Unindent" onClick="orderElementTreeController.unindent();" />
<button label="Down" onClick="orderElementTreeController.up();"></button>
<button label="Up" onClick="orderElementTreeController.down();"></button>
</hbox>
</vbox>
<vbox>
<tree id="tree" width="900px" multiple="true" droppable="true"
onDrop="orderElementTreeController.move(self, event.dragged)"
model="@{orderElementTreeController.orderElementTreeModel}"
treeitemRenderer="@{orderElementTreeController.renderer}" pageSize="5">
<treecols sizable="true">
<treecol label="Name and description" />
<treecol label="Estimated init" />
<treecol label="Estimated end" />
<treecol label="Hours" />
</treecols>
</tree>
</vbox>
<!--zscript>
void move(Component dragged) {
if (self instanceof Treerow) {
self.parent.insertBefore(dragged, self.getNextSibling() );
} else {
self.appendChild(dragged);
}
}
</zscript-->
</vbox>

14
navalplanner-webapp/src/main/webapp/workorders/projects.zul → navalplanner-webapp/src/main/webapp/orders/orders.zul
View file

@ -7,29 +7,29 @@
<?variable-resolver class="org.zkoss.zkplus.spring.DelegatingVariableResolver"?>
<?component name="list" inline="true" macroURI="_list.zul"?>
<?component name="edition" inline="true" macroURI="_edition.zul"?>
<?component name="taskWorkPopup" inline="true" macroURI="_editTaskWork.zul"?>
<?component name="orderElementPopup" inline="true" macroURI="_editOrderElement.zul"?>
<zk >
<window self="@{define(content)}"
apply="org.navalplanner.web.workorders.ProjectWorkCRUDController">
apply="org.navalplanner.web.orders.OrderCRUDController">
<vbox id="messagesContainer"></vbox>
<list top_id="listWindow" />
<edition top_id="createWindow" title="Create"
save_button_label="Save" cancel_button_label="Cancel" />
<edition top_id="editWindow" title="Edit Personal Data"
save_button_label="Save" cancel_button_label="Cancel" />
<taskWorkPopup top_id="editTaskWorkPopup" title="Edit Task Work"
<orderElementPopup top_id="editOrderElementPopup" title="Edit Order Element"
save_button_label="Save" cancel_button_label="Cancel" />
<window visible="@{controller.confirmingRemove}"
id="confirmRemove" title="Confirmación" width="500px"
position="center">
<vbox>
<hbox>
¿Desexa borrar <label value="@{controller.project.name}"/> ?
¿Desexa borrar <label value="@{controller.order.name}"/> ?
</hbox>
<hbox>
<button label="Si"
onClick="controller.remove(controller.project);" />
<button label="Non"
<button label="Yes"
onClick="controller.remove(controller.order);" />
<button label="No"
onClick="controller.cancelRemove();" />
</hbox>
</vbox>

36
navalplanner-webapp/src/main/webapp/workorders/_list.zul
View file

@ -1,36 +0,0 @@
<window id="${arg.top_id}" title="Listado Proxectos">
<grid id="listing" model="@{controller.projects}" mold="paging"
pageSize="5">
<columns>
<column label="Operacións" />
<column label="Nome" sort="auto(name)" />
<column label="Comezo" sort="auto(initDate)" />
<column label="Final" sort="auto(endDate)" />
<column label="Responsable" sort="auto(responsible)" />
<column label="Cliente" sort="auto(customer)" />
<column label="Descripción" sort="auto(description)" />
</columns>
<rows>
<row self="@{each='project'}" value="@{project}">
<hbox>
<button label="Edit"
onClick="controller.goToEditForm(self.parent.parent.value);">
</button>
<button label="Remove"
onClick="controller.confirmRemove(self.parent.parent.value);">
</button>
</hbox>
<label value="@{project.name}" />
<label value="@{project.initDate}" />
<label value="@{project.endDate}" />
<label value="@{project.responsible}" />
<label value="@{project.customer}" />
<label value="@{project.description}" />
</row>
</rows>
</grid>
<button id="show_create_form" onClick="controller.goToCreateForm();"
label="Create">
</button>
</window>

40
navalplanner-webapp/src/main/webapp/workorders/_tasksTree.zul
View file

@ -1,40 +0,0 @@
<vbox id="tasksTree">
<vbox>
<hbox>
<button label="Nova tarefa"
onClick="tasksTreeController.addTaskWork();">
</button>
<button label="Eliminar tarefa"
onClick="tasksTreeController.removeTaskWork();">
</button>
<button label="Convertir en subtarefa"
onClick="tasksTreeController.indent();">
</button>
<button label="Unindent" onClick="tasksTreeController.unindent();" />
<button label="Baixar" onClick="tasksTreeController.up();"></button>
<button label="Subir" onClick="tasksTreeController.down();"></button>
</hbox>
</vbox>
<vbox>
<tree id="tree" width="900px" multiple="true" droppable="true"
onDrop="tasksTreeController.move(self, event.dragged)"
model="@{tasksTreeController.tasksTreeModel}"
treeitemRenderer="@{tasksTreeController.renderer}" pageSize="5">
<treecols sizable="true">
<treecol label="Nome e descripción" />
<treecol label="Comezo estimado" />
<treecol label="Fin estimado" />
<treecol label="Horas" />
</treecols>
</tree>
</vbox>
<!--zscript>
void move(Component dragged) {
if (self instanceof Treerow) {
self.parent.insertBefore(dragged, self.getNextSibling() );
} else {
self.appendChild(dragged);
}
}
</zscript-->
</vbox>