diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/HoursGroupDao.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/HoursGroupDao.java new file mode 100644 index 000000000..8f7114676 --- /dev/null +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/HoursGroupDao.java @@ -0,0 +1,18 @@ +package org.navalplanner.business.orders.daos; + +import org.navalplanner.business.common.daos.impl.GenericDaoHibernate; +import org.navalplanner.business.orders.entities.HoursGroup; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Repository; + +/** + * Dao for {@link HoursGroup} + * + * @author Óscar González Fernández + */ +@Repository +@Scope(BeanDefinition.SCOPE_SINGLETON) +public class HoursGroupDao extends GenericDaoHibernate + implements IHoursGroupDao { +} diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IHoursGroupDao.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IHoursGroupDao.java new file mode 100644 index 000000000..17db82680 --- /dev/null +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/daos/IHoursGroupDao.java @@ -0,0 +1,13 @@ +package org.navalplanner.business.orders.daos; + +import org.navalplanner.business.common.daos.IGenericDao; +import org.navalplanner.business.orders.entities.HoursGroup; + +/** + * Contract for {@link HoursGroupDao} + * + * @author Manuel Rego Casasnovas + */ +public interface IHoursGroupDao extends IGenericDao { + +} diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java index aef9cbce8..6462696fc 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java @@ -31,10 +31,4 @@ public class SpecificResourceAllocation extends ResourceAllocation { this.worker = worker; } - public void forceLoadWorker() { - if (worker != null) { - worker.getId(); - } - } - } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/Task.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/Task.java index 2ca7e47f9..b73f60826 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/Task.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/Task.java @@ -65,8 +65,4 @@ public class Task extends TaskElement { resourceAllocations.remove(resourceAllocation); } - public void forceLoadResourceAllocations() { - resourceAllocations.size(); - } - } diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml index 68b7cf5ca..2e16ff68d 100644 --- a/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml +++ b/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml @@ -10,7 +10,7 @@ - + diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/Tasks.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/Tasks.hbm.xml index 81cf1e91d..28e1daf72 100644 --- a/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/Tasks.hbm.xml +++ b/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/Tasks.hbm.xml @@ -27,7 +27,7 @@ - + diff --git a/navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/TaskList.java b/navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/TaskList.java index e03625ddc..195cf4740 100644 --- a/navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/TaskList.java +++ b/navalplanner-gantt-zk/src/main/java/org/zkoss/ganttz/TaskList.java @@ -245,4 +245,4 @@ public class TaskList extends XulElement implements AfterCompose { } } -} \ No newline at end of file +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IOrderPlanningModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IOrderPlanningModel.java index 3c9e31811..1469da359 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IOrderPlanningModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IOrderPlanningModel.java @@ -14,6 +14,7 @@ public interface IOrderPlanningModel { } void createConfiguration(Order order, + ResourceAllocationController resourceAllocationController, ConfigurationOnTransaction onTransaction); } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IResourceAllocationCommand.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IResourceAllocationCommand.java new file mode 100644 index 000000000..d4ff63b5c --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IResourceAllocationCommand.java @@ -0,0 +1,16 @@ +package org.navalplanner.web.planner; + +import org.navalplanner.business.planner.entities.TaskElement; +import org.zkoss.ganttz.extensions.ICommandOnTask; + +/** + * Contract for {@link ResourceAllocationCommand}. + * + * @author Manuel Rego Casasnovas + */ +public interface IResourceAllocationCommand extends ICommandOnTask { + + void setResourceAllocationController( + ResourceAllocationController resourceAllocationController); + +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IResourceAllocationModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IResourceAllocationModel.java new file mode 100644 index 000000000..b73654788 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/IResourceAllocationModel.java @@ -0,0 +1,106 @@ +package org.navalplanner.web.planner; + +import java.util.Set; + +import org.navalplanner.business.planner.entities.ResourceAllocation; +import org.navalplanner.business.planner.entities.SpecificResourceAllocation; +import org.navalplanner.business.planner.entities.Task; +import org.navalplanner.business.resources.entities.Criterion; +import org.navalplanner.business.resources.entities.Worker; + +/** + * Contract for {@link Task}. + * + * @author Manuel Rego Casasnovas + */ +public interface IResourceAllocationModel { + + /** + * Gets the current {@link Task} object. + * + * @return A {@link Task} + */ + Task getTask(); + + /** + * Adds a new {@link ResourceAllocation} to the current {@link Task}. + */ + void addResourceAllocation(); + + /** + * Removes the {@link ResourceAllocation} from the current {@link Task}. + * + * @param resourceAllocation + * The object to be removed + */ + void removeResourceAllocation(ResourceAllocation resourceAllocation); + + /** + * Tries to find a {@link Worker} with the specified NIF. + * + * @param nif + * The NIF to search the {@link Worker} + * @return The {@link Worker} with this NIF or null if it's not + * found + */ + Worker findWorkerByNif(String nif); + + /** + * Relates a {@link Worker} and a {@link Task} through a + * {@link SpecificResourceAllocation}. + * + * @param resourceAllocation + * A {@link SpecificResourceAllocation} to set the {@link Worker} + * @param worker + * A {@link Worker} for the {@link SpecificResourceAllocation} + */ + void setWorker(SpecificResourceAllocation resourceAllocation, Worker worker); + + /** + * Sets the current {@link Task}, where the user is allocating resources. + * + * @param task + * A {@link Task} + */ + void setTask(Task task); + + /** + * Gets the {@link Set} of {@link Criterion} of the current task. + * + * @return A {@link Set} of {@link Criterion} + */ + Set getCriterions(); + + /** + * Gets the {@link Set} of {@link ResourceAllocation} of the current task. + * + * @return A {@link Set} of {@link ResourceAllocation} + */ + Set getResourceAllocations(); + + /** + * Sets the current {@link ResourceAllocation} to be rendered. + * + * @param resourceAllocation + * The current {@link ResourceAllocation} + */ + void setResourceAllocation(ResourceAllocation resourceAllocation); + + /** + * Gets the {@link Worker} of the current {@link ResourceAllocation}. + * + * @return A {@link Worker} + */ + Worker getWorker(); + + /** + * Checks if the {@link Worker} of the current {@link ResourceAllocation} + * satisfies the {@link Criterion} of the current {@link Task}. + * + * @return True if the {@link Worker} satisfies the {@link Criterion} + * required. Or if the current {@link Worker} is null. + * Or if the {@link Criterion} list is empty. + */ + boolean workerSatisfiesCriterions(); + +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/OrderPlanningController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/OrderPlanningController.java index 9859dcebb..9c1b0db91 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/OrderPlanningController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/OrderPlanningController.java @@ -20,6 +20,13 @@ import org.zkoss.ganttz.adapters.PlannerConfiguration; public class OrderPlanningController implements IOrderPlanningControllerEntryPoints { + @Autowired + private ResourceAllocationController resourceAllocationController; + + public ResourceAllocationController getResourceAllocationController() { + return resourceAllocationController; + } + @Autowired private IURLHandlerRegistry urlHandlerRegistry; @@ -33,7 +40,8 @@ public class OrderPlanningController implements @Override public void showSchedule(Order order) { - model.createConfiguration(order, new ConfigurationOnTransaction() { + model.createConfiguration(order, resourceAllocationController, + new ConfigurationOnTransaction() { @Override public void use(PlannerConfiguration configuration) { diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/OrderPlanningModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/OrderPlanningModel.java index 60da089e2..1ae79ea0a 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/OrderPlanningModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/OrderPlanningModel.java @@ -39,17 +39,25 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel { } } + @Override @Transactional(readOnly = true) public void createConfiguration(Order order, + ResourceAllocationController resourceAllocationController, ConfigurationOnTransaction onTransaction) { Order orderReloaded = reload(order); if (!orderReloaded.isSomeTaskElementScheduled()) throw new IllegalArgumentException("the order " + order + " must be scheduled"); PlannerConfiguration configuration = createConfiguration(orderReloaded); + ISaveCommand saveCommand = getSaveCommand(); saveCommand.setState(state); configuration.addGlobalCommand(saveCommand); + IResourceAllocationCommand resourceAllocationCommand = getResourceAllocationCommand(); + resourceAllocationCommand + .setResourceAllocationController(resourceAllocationController); + configuration.addCommandOnTask(resourceAllocationCommand); + onTransaction.use(configuration); } @@ -82,6 +90,8 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel { protected abstract ISaveCommand getSaveCommand(); + protected abstract IResourceAllocationCommand getResourceAllocationCommand(); + private Order reload(Order order) { try { return orderService.find(order.getId()); diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationCommand.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationCommand.java new file mode 100644 index 000000000..fc3a364c5 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationCommand.java @@ -0,0 +1,42 @@ +package org.navalplanner.web.planner; + +import org.navalplanner.business.planner.entities.Task; +import org.navalplanner.business.planner.entities.TaskElement; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Component; +import org.zkoss.ganttz.extensions.IContext; + +/** + * A command that opens a window to make the resource allocation of a task. + * + * @author Manuel Rego Casasnovas + */ +@Component +@Scope(BeanDefinition.SCOPE_PROTOTYPE) +public class ResourceAllocationCommand implements IResourceAllocationCommand { + + private ResourceAllocationController resourceAllocationController; + + public ResourceAllocationCommand() { + } + + @Override + public void doAction(IContext context, TaskElement task) { + if (task instanceof Task) { + this.resourceAllocationController.showWindow((Task) task); + } + } + + @Override + public String getName() { + return "Resource allocation"; + } + + @Override + public void setResourceAllocationController( + ResourceAllocationController resourceAllocationController) { + this.resourceAllocationController = resourceAllocationController; + } + +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationController.java new file mode 100644 index 000000000..db047bea7 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationController.java @@ -0,0 +1,197 @@ +package org.navalplanner.web.planner; + +import java.math.BigDecimal; +import java.util.Set; + +import org.navalplanner.business.planner.entities.ResourceAllocation; +import org.navalplanner.business.planner.entities.SpecificResourceAllocation; +import org.navalplanner.business.planner.entities.Task; +import org.navalplanner.business.resources.entities.Criterion; +import org.navalplanner.business.resources.entities.Worker; +import org.navalplanner.web.common.Util; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Scope; +import org.zkoss.zk.ui.Component; +import org.zkoss.zk.ui.SuspendNotAllowedException; +import org.zkoss.zk.ui.WrongValueException; +import org.zkoss.zk.ui.event.Event; +import org.zkoss.zk.ui.event.EventListener; +import org.zkoss.zk.ui.event.Events; +import org.zkoss.zk.ui.util.Clients; +import org.zkoss.zk.ui.util.GenericForwardComposer; +import org.zkoss.zul.Decimalbox; +import org.zkoss.zul.Label; +import org.zkoss.zul.Listbox; +import org.zkoss.zul.Listcell; +import org.zkoss.zul.Listitem; +import org.zkoss.zul.ListitemRenderer; +import org.zkoss.zul.Textbox; +import org.zkoss.zul.api.Window; + +/** + * Controller for {@link ResourceAllocation} view. + * + * @author Manuel Rego Casasnovas + */ +@org.springframework.stereotype.Component("resourceAllocationController") +@Scope(BeanDefinition.SCOPE_PROTOTYPE) +public class ResourceAllocationController extends GenericForwardComposer { + + private IResourceAllocationModel resourceAllocationModel; + + private ResourceAllocationListitemRender resourceAllocationRenderer = new ResourceAllocationListitemRender(); + + private Listbox resourcesList; + + private Window window; + + public Set getCriterions() { + return resourceAllocationModel.getCriterions(); + } + + public Set getResourceAllocations() { + return resourceAllocationModel.getResourceAllocations(); + } + + public ResourceAllocationListitemRender getResourceAllocationRenderer() { + return resourceAllocationRenderer; + } + + public void addResourceAllocation() { + resourceAllocationModel.addResourceAllocation(); + Util.reloadBindings(resourcesList); + } + + public void removeResourceAllocation() { + Set selectedItems = resourcesList.getSelectedItems(); + for (Listitem listitem : selectedItems) { + ResourceAllocation resourceAllocation = (ResourceAllocation) listitem + .getValue(); + resourceAllocationModel.removeResourceAllocation(resourceAllocation); + } + Util.reloadBindings(resourcesList); + } + + @Override + public void doAfterCompose(Component comp) throws Exception { + super.doAfterCompose(comp); + this.window = (Window) comp; + } + + + public void showWindow(Task task) { + resourceAllocationModel.setTask(task); + Util.reloadBindings(window); + try { + window.doModal(); + } catch (SuspendNotAllowedException e) { + throw new RuntimeException(e); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + + public void back() { + Set resourceAllocations = resourceAllocationModel.getResourceAllocations(); + for (ResourceAllocation resourceAllocation : resourceAllocations) { + if (((SpecificResourceAllocation) resourceAllocation).getWorker() == null) { + throw new WrongValueException( + window.getFellow("resourcesList"), + "Worker not valid in some resource allocation"); + } + } + + Clients.closeErrorBox(window.getFellow("resourcesList")); + window.setVisible(false); + } + + /** + * Renders every {@link ResourceAllocation} showing a form to modify its + * information. + * + * @author Manuel Rego Casasnovas + */ + public class ResourceAllocationListitemRender implements ListitemRenderer { + + @Override + public void render(Listitem item, Object data) throws Exception { + final ResourceAllocation resourceAllocation = (ResourceAllocation) data; + item.setValue(resourceAllocation); + + resourceAllocationModel.setResourceAllocation(resourceAllocation); + + final Worker worker = resourceAllocationModel.getWorker(); + + Listcell cellResource = new Listcell(); + final Textbox resourceTextbox = new Textbox(); + Util.bind( + resourceTextbox, new Util.Getter() { + + @Override + public String get() { + if (worker == null) { + return ""; + } + return worker.getNif(); + } + }, new Util.Setter() { + + @Override + public void set(String value) { + Worker worker = resourceAllocationModel + .findWorkerByNif(value); + if (worker == null) { + throw new WrongValueException(resourceTextbox, + "Worker not found"); + } else { + resourceAllocationModel + .setWorker( + (SpecificResourceAllocation) resourceAllocation, + worker); + } + } + }); + resourceTextbox.addEventListener(Events.ON_CHANGE, + new EventListener() { + + @Override + public void onEvent(Event event) throws Exception { + Util.reloadBindings(resourcesList); + } + }); + cellResource.appendChild(resourceTextbox); + cellResource.setParent(item); + + Listcell cellPercentage = new Listcell(); + cellPercentage.appendChild(Util.bind( + new Decimalbox(), + new Util.Getter() { + + @Override + public BigDecimal get() { + return resourceAllocation.getPercentage(); + } + }, new Util.Setter() { + + @Override + public void set(BigDecimal value) { + resourceAllocation.setPercentage(value); + } + })); + cellPercentage.setParent(item); + + Listcell cellMessage = new Listcell(); + String message = ""; + + if (worker != null) { + if (!resourceAllocationModel.workerSatisfiesCriterions()) { + message = "The worker does not satisfy the criterions"; + } + } + + cellMessage.appendChild(new Label(message)); + cellMessage.setParent(item); + } + } + +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationModel.java new file mode 100644 index 000000000..06a7a8d07 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/ResourceAllocationModel.java @@ -0,0 +1,166 @@ +package org.navalplanner.web.planner; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.navalplanner.business.common.exceptions.InstanceNotFoundException; +import org.navalplanner.business.orders.daos.IHoursGroupDao; +import org.navalplanner.business.orders.entities.HoursGroup; +import org.navalplanner.business.planner.daos.IResourceAllocationDAO; +import org.navalplanner.business.planner.daos.ITaskElementDao; +import org.navalplanner.business.planner.entities.ResourceAllocation; +import org.navalplanner.business.planner.entities.SpecificResourceAllocation; +import org.navalplanner.business.planner.entities.Task; +import org.navalplanner.business.resources.daos.IWorkerDao; +import org.navalplanner.business.resources.entities.Criterion; +import org.navalplanner.business.resources.entities.CriterionCompounder; +import org.navalplanner.business.resources.entities.CriterionSatisfaction; +import org.navalplanner.business.resources.entities.ICriterion; +import org.navalplanner.business.resources.entities.Worker; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +/** + * Model for UI operations related to {@link Task}. + * + * @author Manuel Rego Casasnovas + */ +@Service +@Scope(BeanDefinition.SCOPE_PROTOTYPE) +public class ResourceAllocationModel implements IResourceAllocationModel { + + @Autowired + private ITaskElementDao taskElementDAO; + + @Autowired + private IWorkerDao workerDAO; + + @Autowired + private IHoursGroupDao hoursGroupDAO; + + @Autowired + private IResourceAllocationDAO resourceAllocationDAO; + + private Task task; + + private ResourceAllocation resourceAllocation; + + @Override + @Transactional(readOnly = true) + public void setTask(Task task) { + taskElementDAO.save(task); + task.getResourceAllocations().size(); + + HoursGroup hoursGroup = task.getHoursGroup(); + hoursGroupDAO.save(hoursGroup); + hoursGroup.getCriterions().size(); + + this.task = task; + } + + @Override + public Task getTask() { + return task; + } + + @Override + public void addResourceAllocation() { + ResourceAllocation resourceAllocation = new SpecificResourceAllocation( + task); + task.addResourceAllocation(resourceAllocation); + } + + @Override + public void removeResourceAllocation(ResourceAllocation resourceAllocation) { + task.removeResourceAllocation(resourceAllocation); + } + + @Override + @Transactional(readOnly = true) + public Worker findWorkerByNif(String nif) { + try { + return workerDAO.findUniqueByNif(nif); + } catch (InstanceNotFoundException e) { + return null; + } + } + + @Override + public void setWorker(SpecificResourceAllocation resourceAllocation, + Worker worker) { + resourceAllocation.setWorker(worker); + } + + @Override + public Set getCriterions() { + if (task == null) { + return new HashSet(); + } + return task.getHoursGroup().getCriterions(); + } + + @Override + public Set getResourceAllocations() { + if (task == null) { + return new HashSet(); + } + return task.getResourceAllocations(); + } + + @Override + @Transactional(readOnly = true) + public void setResourceAllocation(ResourceAllocation resourceAllocation) { + boolean wasTransient = resourceAllocation.isTransient(); + + resourceAllocationDAO.save(resourceAllocation); + + Worker worker = ((SpecificResourceAllocation) resourceAllocation) + .getWorker(); + if (worker != null) { + workerDAO.save(worker); + Set criterionSatisfactions = worker + .getAllSatisfactions(); + for (CriterionSatisfaction criterionSatisfaction : criterionSatisfactions) { + criterionSatisfaction.getCriterion().getName(); + criterionSatisfaction.getCriterion().getType().getName(); + } + } + + if (wasTransient) { + resourceAllocation.makeTransientAgain(); + } + + this.resourceAllocation = resourceAllocation; + } + + @Override + public Worker getWorker() { + if (resourceAllocation == null) { + return null; + } + return ((SpecificResourceAllocation) resourceAllocation).getWorker(); + } + + @Override + public boolean workerSatisfiesCriterions() { + Worker worker = getWorker(); + if (worker == null) { + return true; + } + + List criterions = new ArrayList(getCriterions()); + if (criterions.isEmpty()) { + return true; + } + + ICriterion compositedCriterion = CriterionCompounder.buildAnd(criterions) + .getResult(); + return compositedCriterion.isSatisfiedBy(worker); + } + +} \ No newline at end of file diff --git a/navalplanner-webapp/src/main/resources/navalplanner-webapp-spring-config.xml b/navalplanner-webapp/src/main/resources/navalplanner-webapp-spring-config.xml index 603df0341..b67e33a54 100644 --- a/navalplanner-webapp/src/main/resources/navalplanner-webapp-spring-config.xml +++ b/navalplanner-webapp/src/main/resources/navalplanner-webapp-spring-config.xml @@ -18,6 +18,7 @@ + diff --git a/navalplanner-webapp/src/main/webapp/planner/main.zul b/navalplanner-webapp/src/main/webapp/planner/main.zul index 14fe1d12e..c0eacc4a4 100644 --- a/navalplanner-webapp/src/main/webapp/planner/main.zul +++ b/navalplanner-webapp/src/main/webapp/planner/main.zul @@ -1,13 +1,16 @@ + +