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

Move PlanningState to within PlanningStateCreator

Browse source 
This allows to use directly the Spring beans injected on
PlanningStateCreator by PlanningState. No need to provide them in the
constructors, so bloat is reduced.

FEA: ItEr75S11PreventLooseChanges
This commit is contained in:
Óscar González Fernández 2011-07-19 18:17:02 +02:00
parent 215e03174f
commit 561ad86a4a
35 changed files with 458 additions and 566 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/advances/AdvanceAssignmentPlanningCommand.java
View file

@ -27,7 +27,7 @@ import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.web.planner.order.IEditTaskUtilities;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/advances/AdvanceAssignmentPlanningController.java
View file

@ -30,7 +30,7 @@ import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.common.Util;
import org.navalplanner.web.orders.ManageOrderElementAdvancesController;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.zkoss.ganttz.TaskComponent;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/advances/AdvanceAssignmentPlanningModel.java
View file

@ -33,7 +33,7 @@ import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.planner.daos.ITaskElementDAO;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/advances/IAdvanceAssignmentPlanningCommand.java
View file

@ -22,7 +22,7 @@
package org.navalplanner.web.planner.advances;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.ICommandOnTask;
/**

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/advances/IAdvanceAssignmentPlanningModel.java
View file

@ -24,7 +24,7 @@ package org.navalplanner.web.planner.advances;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.IContextWithPlannerTask;
/**

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/allocation/IResourceAllocationCommand.java
View file

@ -22,7 +22,7 @@
package org.navalplanner.web.planner.allocation;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.taskedition.EditTaskController;
import org.zkoss.ganttz.extensions.ICommandOnTask;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/allocation/IResourceAllocationModel.java
View file

@ -30,7 +30,7 @@ import org.navalplanner.business.orders.entities.AggregatedHoursGroup;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.allocation.AllocationRowsHandler.Warnings;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.IContextWithPlannerTask;
/**

5
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/allocation/ResourceAllocationCommand.java
View file

@ -26,7 +26,7 @@ import static org.navalplanner.web.I18nHelper._;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.IEditTaskUtilities;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.taskedition.EditTaskController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
@ -75,8 +75,7 @@ public class ResourceAllocationCommand implements IResourceAllocationCommand {
}
@Override
public void initialize(
EditTaskController editTaskController,
public void initialize(EditTaskController editTaskController,
PlanningState planningState) {
this.editTaskController = editTaskController;
this.planningState = planningState;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/allocation/ResourceAllocationController.java
View file

@ -47,7 +47,7 @@ import org.navalplanner.web.common.components.NewAllocationSelector;
import org.navalplanner.web.common.components.NewAllocationSelectorCombo;
import org.navalplanner.web.common.components.ResourceAllocationBehaviour;
import org.navalplanner.web.planner.allocation.TaskInformation.ITotalHoursCalculationListener;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.taskedition.EditTaskController;
import org.navalplanner.web.planner.taskedition.TaskPropertiesController;
import org.springframework.beans.factory.config.BeanDefinition;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/allocation/ResourceAllocationModel.java
View file

@ -57,7 +57,7 @@ import org.navalplanner.business.resources.entities.Resource;
import org.navalplanner.business.resources.entities.ResourceEnum;
import org.navalplanner.business.resources.entities.Worker;
import org.navalplanner.web.planner.allocation.AllocationRowsHandler.Warnings;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/AdvanceConsolidationCommand.java
View file

@ -26,7 +26,7 @@ import static org.navalplanner.web.I18nHelper._;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.IEditTaskUtilities;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/AdvanceConsolidationController.java
View file

@ -29,7 +29,7 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.common.Util;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.zkoss.ganttz.TaskComponent;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/AdvanceConsolidationModel.java
View file

@ -52,7 +52,7 @@ import org.navalplanner.business.planner.entities.consolidations.NonCalculatedCo
import org.navalplanner.business.planner.entities.consolidations.NonCalculatedConsolidation;
import org.navalplanner.business.workingday.EffortDuration;
import org.navalplanner.business.workingday.IntraDayDate;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/IAdvanceConsolidationCommand.java
View file

@ -22,7 +22,7 @@
package org.navalplanner.web.planner.consolidations;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.ICommandOnTask;
/**

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/consolidations/IAdvanceConsolidationModel.java
View file

@ -25,7 +25,7 @@ import java.util.List;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.IContextWithPlannerTask;
/**

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/limiting/allocation/ILimitingResourceAllocationModel.java
View file

@ -27,7 +27,7 @@ import org.navalplanner.business.orders.entities.AggregatedHoursGroup;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.allocation.INewAllocationsAdder;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.IContextWithPlannerTask;
/**

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/limiting/allocation/LimitingResourceAllocationController.java
View file

@ -35,7 +35,7 @@ import org.navalplanner.web.common.components.NewAllocationSelectorCombo;
import org.navalplanner.web.common.components.ResourceAllocationBehaviour;
import org.navalplanner.web.planner.allocation.TaskInformation;
import org.navalplanner.web.planner.allocation.TaskInformation.ITotalHoursCalculationListener;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.taskedition.EditTaskController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/limiting/allocation/LimitingResourceAllocationModel.java
View file

@ -51,7 +51,7 @@ import org.navalplanner.business.resources.entities.Resource;
import org.navalplanner.business.resources.entities.ResourceEnum;
import org.navalplanner.web.common.IMessagesForUser;
import org.navalplanner.web.common.Level;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/milestone/AddMilestoneCommand.java
View file

@ -27,7 +27,7 @@ import org.navalplanner.business.planner.daos.ITaskElementDAO;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.business.planner.entities.TaskMilestone;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/milestone/DeleteMilestoneCommand.java
View file

@ -24,7 +24,7 @@ import static org.navalplanner.web.I18nHelper._;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskMilestone;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/milestone/IAddMilestoneCommand.java
View file

@ -22,7 +22,7 @@
package org.navalplanner.web.planner.milestone;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.ICommandOnTask;
/**

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/milestone/IDeleteMilestoneCommand.java
View file

@ -21,7 +21,7 @@
package org.navalplanner.web.planner.milestone;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.ICommandOnTask;
/**

1
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/IOrderPlanningModel.java
View file

@ -29,6 +29,7 @@ import org.navalplanner.web.common.ViewSwitcher;
import org.navalplanner.web.planner.advances.AdvanceAssignmentPlanningController;
import org.navalplanner.web.planner.calendar.CalendarAllocationController;
import org.navalplanner.web.planner.consolidations.AdvanceConsolidationController;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.taskedition.EditTaskController;
import org.zkoss.ganttz.Planner;
import org.zkoss.ganttz.extensions.ICommand;

1
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/ISaveCommand.java
View file

@ -22,6 +22,7 @@
package org.navalplanner.web.planner.order;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.adapters.PlannerConfiguration;
import org.zkoss.ganttz.extensions.ICommand;

1
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/ISubcontractCommand.java
View file

@ -22,6 +22,7 @@
package org.navalplanner.web.planner.order;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.taskedition.EditTaskController;
import org.zkoss.ganttz.extensions.ICommandOnTask;

1
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/OrderPlanningModel.java
View file

@ -92,6 +92,7 @@ import org.navalplanner.web.planner.consolidations.IAdvanceConsolidationCommand;
import org.navalplanner.web.planner.milestone.IAddMilestoneCommand;
import org.navalplanner.web.planner.milestone.IDeleteMilestoneCommand;
import org.navalplanner.web.planner.order.ISaveCommand.IAfterSaveListener;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.reassign.IReassignCommand;
import org.navalplanner.web.planner.taskedition.EditTaskController;
import org.navalplanner.web.planner.taskedition.ITaskPropertiesCommand;

514
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/PlanningState.java
View file

@ -1,514 +0,0 @@
/*
* This file is part of NavalPlan
*
* Copyright (C) 2009-2010 Fundación para o Fomento da Calidade Industrial e
* Desenvolvemento Tecnolóxico de Galicia
* Copyright (C) 2010-2011 Igalia, S.L.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.navalplanner.web.planner.order;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.commons.lang.Validate;
import org.navalplanner.business.orders.daos.IOrderDAO;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.TaskSource;
import org.navalplanner.business.planner.daos.ITaskSourceDAO;
import org.navalplanner.business.planner.entities.DayAssignment;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.business.planner.entities.TaskMilestone;
import org.navalplanner.business.resources.daos.ICriterionDAO;
import org.navalplanner.business.resources.daos.IResourceDAO;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionSatisfaction;
import org.navalplanner.business.resources.entities.IAssignmentsOnResourceCalculator;
import org.navalplanner.business.resources.entities.Resource;
import org.navalplanner.business.scenarios.daos.IOrderVersionDAO;
import org.navalplanner.business.scenarios.daos.IScenarioDAO;
import org.navalplanner.business.scenarios.entities.OrderVersion;
import org.navalplanner.business.scenarios.entities.Scenario;
public abstract class PlanningState {
public static IScenarioInfo ownerScenarioInfo(
IOrderVersionDAO orderVersionDAO, Scenario scenario,
OrderVersion currentVersionForScenario) {
return new UsingOwnerScenario(orderVersionDAO, scenario,
currentVersionForScenario);
}
public static IScenarioInfo forNotOwnerScenario(
IAssignmentsOnResourceCalculator assigmentsOnResourceCalculator,
IOrderDAO orderDAO,
IScenarioDAO scenarioDAO, ITaskSourceDAO taskSourceDAO,
Order order, OrderVersion previousVersion,
Scenario currentScenario, OrderVersion newVersion) {
return new UsingNotOwnerScenario(assigmentsOnResourceCalculator,
orderDAO, scenarioDAO, taskSourceDAO,
order, previousVersion,
currentScenario, newVersion);
}
public interface IScenarioInfo {
public IAssignmentsOnResourceCalculator getAssignmentsCalculator();
public Scenario getCurrentScenario();
public boolean isUsingTheOwnerScenario();
/**
* @throws IllegalStateException
* if it's using the owner scenario
*/
public void saveVersioningInfo() throws IllegalStateException;
public void afterCommit();
}
private static class EmptySchedulingScenarioInfo implements IScenarioInfo {
private final Scenario currentScenario;
public EmptySchedulingScenarioInfo(Scenario currentScenario) {
this.currentScenario = currentScenario;
}
@Override
public void afterCommit() {
}
@Override
public Scenario getCurrentScenario() {
return currentScenario;
}
@Override
public boolean isUsingTheOwnerScenario() {
return true;
}
@Override
public void saveVersioningInfo()
throws IllegalStateException {
}
@Override
public IAssignmentsOnResourceCalculator getAssignmentsCalculator() {
return new Resource.AllResourceAssignments();
}
}
private static class UsingOwnerScenario implements IScenarioInfo {
private final Scenario currentScenario;
private final OrderVersion currentVersionForScenario;
private final IOrderVersionDAO orderVersionDAO;
public UsingOwnerScenario(IOrderVersionDAO orderVersionDAO,
Scenario currentScenario, OrderVersion currentVersionForScenario) {
Validate.notNull(orderVersionDAO);
Validate.notNull(currentScenario);
Validate.notNull(currentVersionForScenario);
this.orderVersionDAO = orderVersionDAO;
this.currentScenario = currentScenario;
this.currentVersionForScenario = currentVersionForScenario;
}
@Override
public boolean isUsingTheOwnerScenario() {
return true;
}
@Override
public void saveVersioningInfo() throws IllegalStateException {
currentVersionForScenario.savingThroughOwner();
orderVersionDAO.save(currentVersionForScenario);
}
@Override
public void afterCommit() {
// do nothing
}
@Override
public Scenario getCurrentScenario() {
return currentScenario;
}
@Override
public IAssignmentsOnResourceCalculator getAssignmentsCalculator() {
return new Resource.AllResourceAssignments();
}
}
private static class UsingNotOwnerScenario implements IScenarioInfo {
private final IOrderDAO orderDAO;
private final IScenarioDAO scenarioDAO;
private final ITaskSourceDAO taskSourceDAO;
private final OrderVersion previousVersion;
private final Scenario currentScenario;
private final OrderVersion newVersion;
private final Order order;
private boolean versionSaved = false;
private final IAssignmentsOnResourceCalculator assigmentsOnResourceCalculator;
public UsingNotOwnerScenario(
IAssignmentsOnResourceCalculator assigmentsOnResourceCalculator,
IOrderDAO orderDAO,
IScenarioDAO scenarioDAO, ITaskSourceDAO taskSourceDAO,
Order order, OrderVersion previousVersion,
Scenario currentScenario,
OrderVersion newVersion) {
Validate.notNull(assigmentsOnResourceCalculator);
Validate.notNull(order);
Validate.notNull(previousVersion);
Validate.notNull(currentScenario);
Validate.notNull(newVersion);
Validate.notNull(orderDAO);
Validate.notNull(scenarioDAO);
Validate.notNull(taskSourceDAO);
this.assigmentsOnResourceCalculator = assigmentsOnResourceCalculator;
this.orderDAO = orderDAO;
this.scenarioDAO = scenarioDAO;
this.taskSourceDAO = taskSourceDAO;
this.previousVersion = previousVersion;
this.currentScenario = currentScenario;
this.newVersion = newVersion;
this.order = order;
}
@Override
public boolean isUsingTheOwnerScenario() {
return versionSaved;
}
@Override
public void saveVersioningInfo() throws IllegalStateException {
if (versionSaved) {
return;
}
orderDAO.save(order);
TaskSource taskSource = order.getTaskSource();
taskSourceDAO.save(taskSource);
taskSource.dontPoseAsTransientObjectAnymore();
taskSource.getTask().dontPoseAsTransientObjectAnymore();
scenarioDAO.updateDerivedScenariosWithNewVersion(previousVersion,
order, currentScenario, newVersion);
}
@Override
public void afterCommit() {
versionSaved = true;
}
@Override
public Scenario getCurrentScenario() {
return currentScenario;
}
@Override
public IAssignmentsOnResourceCalculator getAssignmentsCalculator() {
return assigmentsOnResourceCalculator;
}
}
public static PlanningState create(TaskGroup rootTask,
Collection<? extends TaskElement> initialState,
Collection<? extends Resource> initialResources,
ICriterionDAO criterionDAO, IResourceDAO resourceDAO,
IScenarioInfo scenarioInfo) {
return new WithDataPlanningState(rootTask, initialState,
initialResources, criterionDAO, resourceDAO, scenarioInfo);
}
public static PlanningState createEmpty(Scenario currentScenario,
Order order) {
return new EmptyPlannigState(currentScenario, order);
}
private final Order order;
public PlanningState(Order order) {
Validate.notNull(order);
this.order = order;
}
public Order getOrder() {
return order;
}
public abstract boolean isEmpty();
/**
* <p>
* When the scenario was not owner, the previous {@link DayAssignment day
* assingments} for the scenario must be avoided. Since the previous
* scenario was not an owner, all tasks and related information are copied,
* but the resource keeps pointing to the scenario's previous assignments.
* </p>
* <p>
* If the scenario is the owner, the assignments are returned directly.
* </p>
* @return the {@link IAssignmentsOnResourceCalculator} to use.
* @see IAssignmentsOnResourceCalculator
* @see AvoidStaleAssignments
*/
public IAssignmentsOnResourceCalculator getAssignmentsCalculator() {
return getScenarioInfo().getAssignmentsCalculator();
}
public abstract Collection<? extends TaskElement> getTasksToSave();
public abstract List<TaskElement> getInitial();
public abstract void reassociateResourcesWithSession();
public abstract Collection<? extends TaskElement> getToRemove();
public abstract void removed(TaskElement taskElement);
public abstract void added(TaskElement taskElement);
public abstract TaskGroup getRootTask();
public abstract IScenarioInfo getScenarioInfo();
public Scenario getCurrentScenario() {
return getScenarioInfo().getCurrentScenario();
}
static class WithDataPlanningState extends PlanningState {
private final ArrayList<TaskElement> initial;
private final Set<TaskElement> toSave;
private final Set<TaskElement> toRemove;
private Set<Resource> resources = new HashSet<Resource>();
private final TaskGroup rootTask;
private final ICriterionDAO criterionDAO;
private final IResourceDAO resourceDAO;
private final IScenarioInfo scenarioInfo;
private WithDataPlanningState(TaskGroup rootTask,
Collection<? extends TaskElement> initialState,
Collection<? extends Resource> initialResources,
ICriterionDAO criterionDAO, IResourceDAO resourceDAO,
IScenarioInfo scenarioInfo) {
super((Order) rootTask.getOrderElement());
this.rootTask = rootTask;
this.criterionDAO = criterionDAO;
this.resourceDAO = resourceDAO;
this.scenarioInfo = scenarioInfo;
this.initial = new ArrayList<TaskElement>(initialState);
this.toSave = new HashSet<TaskElement>(initialState);
this.toRemove = new HashSet<TaskElement>();
this.resources = OrderPlanningModel
.loadRequiredDataFor(new HashSet<Resource>(
initialResources));
associateWithScenario(this.resources);
}
private void associateWithScenario(
Collection<? extends Resource> resources) {
Scenario currentScenario = getCurrentScenario();
for (Resource each : resources) {
each.useScenario(currentScenario);
}
}
@Override
public Collection<? extends TaskElement> getTasksToSave() {
return Collections.unmodifiableCollection(toSave);
}
@Override
public List<TaskElement> getInitial() {
return new ArrayList<TaskElement>(initial);
}
@Override
public void reassociateResourcesWithSession() {
for (Resource resource : resources) {
resourceDAO.reattach(resource);
}
// ensuring no repeated instances of criterions
reattachCriterions(getExistentCriterions(resources));
addingNewlyCreated(resourceDAO);
}
private void reattachCriterions(Set<Criterion> criterions) {
for (Criterion each : criterions) {
criterionDAO.reattachUnmodifiedEntity(each);
}
}
private Set<Criterion> getExistentCriterions(Set<Resource> resources) {
Set<Criterion> result = new HashSet<Criterion>();
for (Resource resource : resources) {
for (CriterionSatisfaction each : resource
.getCriterionSatisfactions()) {
result.add(each.getCriterion());
}
}
return result;
}
private void addingNewlyCreated(IResourceDAO resourceDAO) {
Set<Resource> newResources = getNewResources(resourceDAO);
OrderPlanningModel.loadRequiredDataFor(newResources);
associateWithScenario(newResources);
resources.addAll(newResources);
}
private Set<Resource> getNewResources(IResourceDAO resourceDAO) {
Set<Resource> result = new HashSet<Resource>(resourceDAO
.list(Resource.class));
result.removeAll(resources);
return result;
}
@Override
public Collection<? extends TaskElement> getToRemove() {
return Collections
.unmodifiableCollection(onlyNotTransient(toRemove));
}
private List<TaskElement> onlyNotTransient(
Collection<? extends TaskElement> toRemove) {
ArrayList<TaskElement> result = new ArrayList<TaskElement>();
for (TaskElement taskElement : toRemove) {
if (taskElement.getId() != null) {
result.add(taskElement);
}
}
return result;
}
@Override
public void removed(TaskElement taskElement) {
taskElement.detach();
if (!isTopLevel(taskElement)) {
return;
}
toSave.remove(taskElement);
toRemove.add(taskElement);
}
private boolean isTopLevel(TaskElement taskElement) {
if (taskElement instanceof TaskMilestone) {
return true;
}
return taskElement.getParent() == null;
}
@Override
public void added(TaskElement taskElement) {
if (!isTopLevel(taskElement)) {
return;
}
toRemove.remove(taskElement);
toSave.add(taskElement);
}
@Override
public TaskGroup getRootTask() {
return rootTask;
}
@Override
public IScenarioInfo getScenarioInfo() {
return scenarioInfo;
}
@Override
public boolean isEmpty() {
return false;
}
}
private static class EmptyPlannigState extends PlanningState {
private final Scenario currentScenario;
private EmptyPlannigState(Scenario currentScenario, Order order) {
super(order);
this.currentScenario = currentScenario;
}
@Override
public void added(TaskElement taskElement) {
}
@Override
public List<TaskElement> getInitial() {
return Collections.emptyList();
}
@Override
public TaskGroup getRootTask() {
return null;
}
@Override
public Collection<? extends TaskElement> getTasksToSave() {
return Collections.emptyList();
}
@Override
public Collection<? extends TaskElement> getToRemove() {
return Collections.emptyList();
}
@Override
public void reassociateResourcesWithSession() {
}
public void removed(TaskElement taskElement) {
}
@Override
public IScenarioInfo getScenarioInfo() {
return new EmptySchedulingScenarioInfo(currentScenario);
}
@Override
public boolean isEmpty() {
return true;
}
}
}

447
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/PlanningStateCreator.java
View file

@ -21,14 +21,17 @@ package org.navalplanner.web.planner.order;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.commons.lang.Validate;
import org.hibernate.Hibernate;
import org.navalplanner.business.orders.daos.IOrderDAO;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.TaskSource;
import org.navalplanner.business.planner.daos.ITaskElementDAO;
import org.navalplanner.business.planner.daos.ITaskSourceDAO;
import org.navalplanner.business.planner.entities.DayAssignment;
@ -37,9 +40,11 @@ import org.navalplanner.business.planner.entities.GenericResourceAllocation;
import org.navalplanner.business.planner.entities.ResourceAllocation;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.business.planner.entities.TaskMilestone;
import org.navalplanner.business.resources.daos.ICriterionDAO;
import org.navalplanner.business.resources.daos.IResourceDAO;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionSatisfaction;
import org.navalplanner.business.resources.entities.IAssignmentsOnResourceCalculator;
import org.navalplanner.business.resources.entities.Resource;
import org.navalplanner.business.scenarios.IScenarioManager;
@ -48,7 +53,6 @@ import org.navalplanner.business.scenarios.daos.IScenarioDAO;
import org.navalplanner.business.scenarios.entities.OrderVersion;
import org.navalplanner.business.scenarios.entities.Scenario;
import org.navalplanner.web.calendars.BaseCalendarModel;
import org.navalplanner.web.planner.order.PlanningState.IScenarioInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
@ -138,7 +142,7 @@ public class PlanningStateCreator {
private PlanningState createInitialPlanning(Order orderReloaded) {
Scenario currentScenario = scenarioManager.getCurrent();
if (!orderReloaded.isSomeTaskElementScheduled()) {
return PlanningState.createEmpty(currentScenario, orderReloaded);
return new EmptyPlannigState(currentScenario, orderReloaded);
}
final List<Resource> allResources = resourceDAO.list(Resource.class);
criterionDAO.list(Criterion.class);
@ -147,9 +151,9 @@ public class PlanningStateCreator {
forceLoadDayAssignments(orderReloaded.getResources());
switchAllocationsToScenario(currentScenario, taskElement);
PlanningState result = PlanningState.create(taskElement,
orderReloaded.getAssociatedTasks(), allResources, criterionDAO,
resourceDAO, buildScenarioInfo(orderReloaded));
PlanningState result = new WithDataPlanningState(taskElement,
orderReloaded.getAssociatedTasks(), allResources,
buildScenarioInfo(orderReloaded));
forceLoadOfDependenciesCollections(result.getInitial());
forceLoadOfWorkingHours(result.getInitial());
@ -223,26 +227,23 @@ public class PlanningStateCreator {
private IScenarioInfo buildScenarioInfo(Order orderReloaded) {
Scenario currentScenario = scenarioManager.getCurrent();
if (orderReloaded.isUsingTheOwnerScenario()) {
return createOwnerScenarioInfoFor(orderReloaded, currentScenario);
return new UsingOwnerScenario(currentScenario, currentScenario.getOrderVersion(orderReloaded));
}
final List<DayAssignment> previousAssignments = orderReloaded
.getDayAssignments();
OrderVersion previousVersion = currentScenario
.getOrderVersion(orderReloaded);
OrderVersion newVersion = OrderVersion
.createInitialVersion(currentScenario);
orderReloaded.writeSchedulingDataChangesTo(currentScenario, newVersion);
switchAllocationsToScenario(currentScenario,
orderReloaded.getAssociatedTaskElement());
return createScenarioInfoForNotOwnerScenario(new AvoidStaleAssignments(
previousAssignments), orderReloaded, previousVersion,
newVersion, currentScenario);
}
private IScenarioInfo createOwnerScenarioInfoFor(Order orderReloaded, Scenario currentScenario) {
return PlanningState
.ownerScenarioInfo(orderVersionDAO, currentScenario,
currentScenario.getOrderVersion(orderReloaded));
return new UsingNotOwnerScenario(new AvoidStaleAssignments(
previousAssignments), orderReloaded, previousVersion,
currentScenario, newVersion);
}
private static void switchAllocationsToScenario(Scenario scenario,
@ -252,15 +253,6 @@ public class PlanningStateCreator {
}
}
private IScenarioInfo createScenarioInfoForNotOwnerScenario(
IAssignmentsOnResourceCalculator returningNewAssignments,
Order orderReloaded, OrderVersion previousVersion,
OrderVersion newVersion, Scenario currentScenario) {
return PlanningState.forNotOwnerScenario(returningNewAssignments,
orderDAO, scenarioDAO, taskSourceDAO, orderReloaded,
previousVersion, currentScenario, newVersion);
}
private void forceLoadOfDependenciesCollections(
Collection<? extends TaskElement> elements) {
for (TaskElement task : elements) {
@ -304,4 +296,413 @@ public class PlanningStateCreator {
}
}
public interface IScenarioInfo {
public IAssignmentsOnResourceCalculator getAssignmentsCalculator();
public Scenario getCurrentScenario();
public boolean isUsingTheOwnerScenario();
/**
* @throws IllegalStateException
* if it's using the owner scenario
*/
public void saveVersioningInfo() throws IllegalStateException;
public void afterCommit();
}
private static class EmptySchedulingScenarioInfo implements IScenarioInfo {
private final Scenario currentScenario;
public EmptySchedulingScenarioInfo(Scenario currentScenario) {
this.currentScenario = currentScenario;
}
@Override
public void afterCommit() {
}
@Override
public Scenario getCurrentScenario() {
return currentScenario;
}
@Override
public boolean isUsingTheOwnerScenario() {
return true;
}
@Override
public void saveVersioningInfo() throws IllegalStateException {
}
@Override
public IAssignmentsOnResourceCalculator getAssignmentsCalculator() {
return new Resource.AllResourceAssignments();
}
}
private class UsingOwnerScenario implements IScenarioInfo {
private final Scenario currentScenario;
private final OrderVersion currentVersionForScenario;
public UsingOwnerScenario(Scenario currentScenario,
OrderVersion currentVersionForScenario) {
Validate.notNull(currentScenario);
Validate.notNull(currentVersionForScenario);
this.currentScenario = currentScenario;
this.currentVersionForScenario = currentVersionForScenario;
}
@Override
public boolean isUsingTheOwnerScenario() {
return true;
}
@Override
public void saveVersioningInfo() throws IllegalStateException {
currentVersionForScenario.savingThroughOwner();
orderVersionDAO.save(currentVersionForScenario);
}
@Override
public void afterCommit() {
// do nothing
}
@Override
public Scenario getCurrentScenario() {
return currentScenario;
}
@Override
public IAssignmentsOnResourceCalculator getAssignmentsCalculator() {
return new Resource.AllResourceAssignments();
}
}
private class UsingNotOwnerScenario implements IScenarioInfo {
private final OrderVersion previousVersion;
private final Scenario currentScenario;
private final OrderVersion newVersion;
private final Order order;
private boolean versionSaved = false;
private final IAssignmentsOnResourceCalculator assigmentsOnResourceCalculator;
public UsingNotOwnerScenario(
IAssignmentsOnResourceCalculator assigmentsOnResourceCalculator,
Order order,
OrderVersion previousVersion, Scenario currentScenario,
OrderVersion newVersion) {
Validate.notNull(assigmentsOnResourceCalculator);
Validate.notNull(order);
Validate.notNull(previousVersion);
Validate.notNull(currentScenario);
Validate.notNull(newVersion);
this.assigmentsOnResourceCalculator = assigmentsOnResourceCalculator;
this.previousVersion = previousVersion;
this.currentScenario = currentScenario;
this.newVersion = newVersion;
this.order = order;
}
@Override
public boolean isUsingTheOwnerScenario() {
return versionSaved;
}
@Override
public void saveVersioningInfo() throws IllegalStateException {
if (versionSaved) {
return;
}
orderDAO.save(order);
TaskSource taskSource = order.getTaskSource();
taskSourceDAO.save(taskSource);
taskSource.dontPoseAsTransientObjectAnymore();
taskSource.getTask().dontPoseAsTransientObjectAnymore();
scenarioDAO.updateDerivedScenariosWithNewVersion(previousVersion,
order, currentScenario, newVersion);
}
@Override
public void afterCommit() {
versionSaved = true;
}
@Override
public Scenario getCurrentScenario() {
return currentScenario;
}
@Override
public IAssignmentsOnResourceCalculator getAssignmentsCalculator() {
return assigmentsOnResourceCalculator;
}
}
public abstract class PlanningState {
private final Order order;
public PlanningState(Order order) {
Validate.notNull(order);
this.order = order;
}
public Order getOrder() {
return order;
}
public abstract boolean isEmpty();
/**
* <p>
* When the scenario was not owner, the previous {@link DayAssignment
* day assingments} for the scenario must be avoided. Since the previous
* scenario was not an owner, all tasks and related information are
* copied, but the resource keeps pointing to the scenario's previous
* assignments.
* </p>
* <p>
* If the scenario is the owner, the assignments are returned directly.
* </p>
* @return the {@link IAssignmentsOnResourceCalculator} to use.
* @see IAssignmentsOnResourceCalculator
* @see AvoidStaleAssignments
*/
public IAssignmentsOnResourceCalculator getAssignmentsCalculator() {
return getScenarioInfo().getAssignmentsCalculator();
}
public abstract Collection<? extends TaskElement> getTasksToSave();
public abstract List<TaskElement> getInitial();
public abstract void reassociateResourcesWithSession();
public abstract Collection<? extends TaskElement> getToRemove();
public abstract void removed(TaskElement taskElement);
public abstract void added(TaskElement taskElement);
public abstract TaskGroup getRootTask();
public abstract IScenarioInfo getScenarioInfo();
public Scenario getCurrentScenario() {
return getScenarioInfo().getCurrentScenario();
}
}
private class EmptyPlannigState extends PlanningState {
private final Scenario currentScenario;
private EmptyPlannigState(Scenario currentScenario, Order order) {
super(order);
this.currentScenario = currentScenario;
}
@Override
public void added(TaskElement taskElement) {
}
@Override
public List<TaskElement> getInitial() {
return Collections.emptyList();
}
@Override
public TaskGroup getRootTask() {
return null;
}
@Override
public Collection<? extends TaskElement> getTasksToSave() {
return Collections.emptyList();
}
@Override
public Collection<? extends TaskElement> getToRemove() {
return Collections.emptyList();
}
@Override
public void reassociateResourcesWithSession() {
}
public void removed(TaskElement taskElement) {
}
@Override
public IScenarioInfo getScenarioInfo() {
return new EmptySchedulingScenarioInfo(currentScenario);
}
@Override
public boolean isEmpty() {
return true;
}
}
private class WithDataPlanningState extends PlanningState {
private final ArrayList<TaskElement> initial;
private final Set<TaskElement> toSave;
private final Set<TaskElement> toRemove;
private Set<Resource> resources = new HashSet<Resource>();
private final TaskGroup rootTask;
private final IScenarioInfo scenarioInfo;
private WithDataPlanningState(TaskGroup rootTask,
Collection<? extends TaskElement> initialState,
Collection<? extends Resource> initialResources,
IScenarioInfo scenarioInfo) {
super((Order) rootTask.getOrderElement());
this.rootTask = rootTask;
this.scenarioInfo = scenarioInfo;
this.initial = new ArrayList<TaskElement>(initialState);
this.toSave = new HashSet<TaskElement>(initialState);
this.toRemove = new HashSet<TaskElement>();
this.resources = OrderPlanningModel
.loadRequiredDataFor(new HashSet<Resource>(initialResources));
associateWithScenario(this.resources);
}
private void associateWithScenario(
Collection<? extends Resource> resources) {
Scenario currentScenario = getCurrentScenario();
for (Resource each : resources) {
each.useScenario(currentScenario);
}
}
@Override
public Collection<? extends TaskElement> getTasksToSave() {
return Collections.unmodifiableCollection(toSave);
}
@Override
public List<TaskElement> getInitial() {
return new ArrayList<TaskElement>(initial);
}
@Override
public void reassociateResourcesWithSession() {
for (Resource resource : resources) {
resourceDAO.reattach(resource);
}
// ensuring no repeated instances of criterions
reattachCriterions(getExistentCriterions(resources));
addingNewlyCreated(resourceDAO);
}
private void reattachCriterions(Set<Criterion> criterions) {
for (Criterion each : criterions) {
criterionDAO.reattachUnmodifiedEntity(each);
}
}
private Set<Criterion> getExistentCriterions(Set<Resource> resources) {
Set<Criterion> result = new HashSet<Criterion>();
for (Resource resource : resources) {
for (CriterionSatisfaction each : resource
.getCriterionSatisfactions()) {
result.add(each.getCriterion());
}
}
return result;
}
private void addingNewlyCreated(IResourceDAO resourceDAO) {
Set<Resource> newResources = getNewResources(resourceDAO);
OrderPlanningModel.loadRequiredDataFor(newResources);
associateWithScenario(newResources);
resources.addAll(newResources);
}
private Set<Resource> getNewResources(IResourceDAO resourceDAO) {
Set<Resource> result = new HashSet<Resource>(
resourceDAO.list(Resource.class));
result.removeAll(resources);
return result;
}
@Override
public Collection<? extends TaskElement> getToRemove() {
return Collections
.unmodifiableCollection(onlyNotTransient(toRemove));
}
private List<TaskElement> onlyNotTransient(
Collection<? extends TaskElement> toRemove) {
ArrayList<TaskElement> result = new ArrayList<TaskElement>();
for (TaskElement taskElement : toRemove) {
if (taskElement.getId() != null) {
result.add(taskElement);
}
}
return result;
}
@Override
public void removed(TaskElement taskElement) {
taskElement.detach();
if (!isTopLevel(taskElement)) {
return;
}
toSave.remove(taskElement);
toRemove.add(taskElement);
}
private boolean isTopLevel(TaskElement taskElement) {
if (taskElement instanceof TaskMilestone) {
return true;
}
return taskElement.getParent() == null;
}
@Override
public void added(TaskElement taskElement) {
if (!isTopLevel(taskElement)) {
return;
}
toRemove.remove(taskElement);
toSave.add(taskElement);
}
@Override
public TaskGroup getRootTask() {
return rootTask;
}
@Override
public IScenarioInfo getScenarioInfo() {
return scenarioInfo;
}
@Override
public boolean isEmpty() {
return false;
}
}
}

1
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/SaveCommand.java
View file

@ -69,6 +69,7 @@ import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueue
import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueElement;
import org.navalplanner.web.common.concurrentdetection.OnConcurrentModification;
import org.navalplanner.web.planner.TaskElementAdapter;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

1
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/SubcontractCommand.java
View file

@ -25,6 +25,7 @@ import static org.navalplanner.web.I18nHelper._;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.taskedition.EditTaskController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/reassign/IReassignCommand.java
View file

@ -21,7 +21,7 @@
package org.navalplanner.web.planner.reassign;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.ICommand;
/**

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/reassign/ReassignCommand.java
View file

@ -40,7 +40,7 @@ import org.navalplanner.business.resources.daos.ICriterionTypeDAO;
import org.navalplanner.business.resources.daos.IResourcesSearcher;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionType;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/taskedition/EditTaskController.java
View file

@ -45,7 +45,7 @@ import org.navalplanner.web.planner.allocation.AllocationResult;
import org.navalplanner.web.planner.allocation.FormBinder;
import org.navalplanner.web.planner.allocation.ResourceAllocationController;
import org.navalplanner.web.planner.limiting.allocation.LimitingResourceAllocationController;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.navalplanner.web.planner.order.SubcontractController;
import org.navalplanner.web.planner.taskedition.TaskPropertiesController.ResourceAllocationTypeEnum;
import org.springframework.beans.factory.annotation.Autowired;

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/taskedition/ITaskPropertiesCommand.java
View file

@ -22,7 +22,7 @@
package org.navalplanner.web.planner.taskedition;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.zkoss.ganttz.extensions.ICommandOnTask;
/**

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/taskedition/TaskPropertiesCommand.java
View file

@ -25,7 +25,7 @@ import static org.navalplanner.web.I18nHelper._;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.web.planner.order.IEditTaskUtilities;
import org.navalplanner.web.planner.order.PlanningState;
import org.navalplanner.web.planner.order.PlanningStateCreator.PlanningState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;