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

Use GanttDates in GanttDiagramGraph when enforcing constraints and dependencies

Browse source 
FEA: ItEr61S08TimeUnitConfigurablePlanning
This commit is contained in:
Óscar González Fernández 2010-10-07 00:14:26 +02:00
parent a96e67b2f1
commit 31a5eb4c25
15 changed files with 183 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
ganttzk/src/main/java/org/zkoss/ganttz/DependencyComponent.java
View file

@ -22,11 +22,11 @@ package org.zkoss.ganttz;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Date;
import org.apache.commons.lang.Validate;
import org.zkoss.ganttz.data.Dependency;
import org.zkoss.ganttz.data.DependencyType;
import org.zkoss.ganttz.data.GanttDate;
import org.zkoss.ganttz.data.Task;
import org.zkoss.ganttz.data.constraint.Constraint;
import org.zkoss.ganttz.data.constraint.Constraint.IConstraintViolationListener;
@ -49,7 +49,7 @@ public class DependencyComponent extends XulElement implements AfterCompose {
private Dependency dependency;
private IConstraintViolationListener<Date> violationListener;
private IConstraintViolationListener<GanttDate> violationListener;
public DependencyComponent(TaskComponent source, TaskComponent destination,
Dependency dependency) {
@ -62,11 +62,11 @@ public class DependencyComponent extends XulElement implements AfterCompose {
this.source = source;
this.destination = destination;
this.dependency = dependency;
violationListener = new IConstraintViolationListener<Date>() {
violationListener = new IConstraintViolationListener<GanttDate>() {
@Override
public void constraintViolated(Constraint<Date> constraint,
Date value) {
public void constraintViolated(Constraint<GanttDate> constraint,
GanttDate value) {
// TODO mark graphically dependency as violated
}
};

8
ganttzk/src/main/java/org/zkoss/ganttz/TaskComponent.java
View file

@ -193,11 +193,11 @@ public class TaskComponent extends Div implements AfterCompose {
setId(UUID.randomUUID().toString());
this.disabilityConfiguration = disabilityConfiguration;
taskViolationListener = new IConstraintViolationListener<Date>() {
taskViolationListener = new IConstraintViolationListener<GanttDate>() {
@Override
public void constraintViolated(Constraint<Date> constraint,
Date value) {
public void constraintViolated(Constraint<GanttDate> constraint,
GanttDate value) {
// TODO mark graphically task as violated
}
};
@ -291,7 +291,7 @@ public class TaskComponent extends Div implements AfterCompose {
private final Task task;
private transient PropertyChangeListener propertiesListener;
private IConstraintViolationListener<Date> taskViolationListener;
private IConstraintViolationListener<GanttDate> taskViolationListener;
public TaskRow getRow() {
if (getParent() == null) {

12
ganttzk/src/main/java/org/zkoss/ganttz/adapters/PlannerConfiguration.java
View file

@ -31,6 +31,7 @@ import java.util.Map;
import org.apache.commons.lang.Validate;
import org.zkoss.ganttz.Planner;
import org.zkoss.ganttz.data.GanttDate;
import org.zkoss.ganttz.data.GanttDiagramGraph.IGraphChangeListener;
import org.zkoss.ganttz.data.constraint.Constraint;
import org.zkoss.ganttz.extensions.ICommand;
@ -264,12 +265,13 @@ public class PlannerConfiguration<T> implements IDisabilityConfiguration {
this.editingDatesEnabled = editingDatesEnabled;
}
public List<Constraint<Date>> getStartConstraints() {
return getStartConstraintsGiven(this.notBeforeThan);
public List<Constraint<GanttDate>> getStartConstraints() {
return getStartConstraintsGiven(GanttDate
.createFrom(this.notBeforeThan));
}
public static List<Constraint<Date>> getStartConstraintsGiven(
Date notBeforeThan) {
public static List<Constraint<GanttDate>> getStartConstraintsGiven(
GanttDate notBeforeThan) {
if (notBeforeThan != null) {
return Collections.singletonList(biggerOrEqualThan(notBeforeThan));
} else {
@ -277,7 +279,7 @@ public class PlannerConfiguration<T> implements IDisabilityConfiguration {
}
}
public List<Constraint<Date>> getEndConstraints() {
public List<Constraint<GanttDate>> getEndConstraints() {
return Collections.emptyList();
}

2
ganttzk/src/main/java/org/zkoss/ganttz/data/DefaultFundamentalProperties.java
View file

@ -177,7 +177,7 @@ public class DefaultFundamentalProperties implements ITaskFundamentalProperties
}
@Override
public List<Constraint<Date>> getStartConstraints() {
public List<Constraint<GanttDate>> getStartConstraints() {
return Collections.emptyList();
}

21
ganttzk/src/main/java/org/zkoss/ganttz/data/Dependency.java
View file

@ -22,7 +22,6 @@ package org.zkoss.ganttz.data;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang.builder.EqualsBuilder;
@ -43,36 +42,36 @@ public class Dependency implements IDependency<Task> {
private enum Calculation {
START {
@Override
public List<Constraint<Date>> toConstraints(Task source,
public List<Constraint<GanttDate>> toConstraints(Task source,
DependencyType type) {
return type.getStartConstraints(source);
}
},
END {
@Override
public List<Constraint<Date>> toConstraints(Task source,
public List<Constraint<GanttDate>> toConstraints(Task source,
DependencyType type) {
return type.getEndConstraints(source);
}
};
abstract List<Constraint<Date>> toConstraints(Task source,
abstract List<Constraint<GanttDate>> toConstraints(Task source,
DependencyType type);
}
public static List<Constraint<Date>> getStartConstraints(
public static List<Constraint<GanttDate>> getStartConstraints(
Collection<Dependency> dependencies) {
return getConstraintsFor(dependencies, Calculation.START);
}
public static List<Constraint<Date>> getEndConstraints(
public static List<Constraint<GanttDate>> getEndConstraints(
Collection<Dependency> incoming) {
return getConstraintsFor(incoming, Calculation.END);
}
private static List<Constraint<Date>> getConstraintsFor(
private static List<Constraint<GanttDate>> getConstraintsFor(
Collection<Dependency> dependencies, Calculation calculation) {
List<Constraint<Date>> result = new ArrayList<Constraint<Date>>();
List<Constraint<GanttDate>> result = new ArrayList<Constraint<GanttDate>>();
for (Dependency dependency : dependencies) {
result.addAll(dependency.toConstraints(calculation));
}
@ -87,7 +86,7 @@ public class Dependency implements IDependency<Task> {
private final boolean visible;
private ConstraintViolationNotificator<Date> violationsNotificator = ConstraintViolationNotificator
private ConstraintViolationNotificator<GanttDate> violationsNotificator = ConstraintViolationNotificator
.create();
public Dependency(Task source, Task destination,
@ -112,13 +111,13 @@ public class Dependency implements IDependency<Task> {
this(source, destination, type, true);
}
private List<Constraint<Date>> toConstraints(Calculation calculation) {
private List<Constraint<GanttDate>> toConstraints(Calculation calculation) {
return violationsNotificator.withListener(calculation.toConstraints(
source, type));
}
public void addConstraintViolationListener(
IConstraintViolationListener<Date> listener) {
IConstraintViolationListener<GanttDate> listener) {
violationsNotificator.addConstraintViolationListener(listener);
}

30
ganttzk/src/main/java/org/zkoss/ganttz/data/DependencyType.java
View file

@ -49,12 +49,12 @@ public enum DependencyType {
return current;
}
public <V> List<Constraint<Date>> getStartConstraints(V source,
public <V> List<Constraint<GanttDate>> getStartConstraints(V source,
IAdapter<V, ?> adapter) {
return Collections.emptyList();
}
public <V> List<Constraint<Date>> getEndConstraints(V source,
public <V> List<Constraint<GanttDate>> getEndConstraints(V source,
IAdapter<V, ?> adapter) {
return Collections.emptyList();
}
@ -78,13 +78,13 @@ public enum DependencyType {
current);
}
public <V> List<Constraint<Date>> getStartConstraints(V source,
public <V> List<Constraint<GanttDate>> getStartConstraints(V source,
IAdapter<V, ?> adapter) {
return Collections.singletonList(biggerThanTaskEndDate(adapter,
source));
}
public <V> List<Constraint<Date>> getEndConstraints(V source,
public <V> List<Constraint<GanttDate>> getEndConstraints(V source,
GanttDiagramGraph.IAdapter<V, ?> adapter) {
return Collections.emptyList();
}
@ -108,13 +108,13 @@ public enum DependencyType {
current);
}
public <V> List<Constraint<Date>> getStartConstraints(V source,
public <V> List<Constraint<GanttDate>> getStartConstraints(V source,
GanttDiagramGraph.IAdapter<V, ?> adapter) {
return Collections.singletonList(biggerThanTaskStartDate(adapter,
source));
}
public <V> List<Constraint<Date>> getEndConstraints(V source,
public <V> List<Constraint<GanttDate>> getEndConstraints(V source,
GanttDiagramGraph.IAdapter<V, ?> adapter) {
return Collections.emptyList();
}
@ -143,25 +143,25 @@ public enum DependencyType {
}
@Override
public <V> List<Constraint<Date>> getEndConstraints(V source,
public <V> List<Constraint<GanttDate>> getEndConstraints(V source,
IAdapter<V, ?> adapter) {
return Collections.singletonList(biggerThanTaskEndDate(adapter,
source));
}
@Override
public <V> List<Constraint<Date>> getStartConstraints(V source,
public <V> List<Constraint<GanttDate>> getStartConstraints(V source,
IAdapter<V, ?> adapter) {
return Collections.emptyList();
}
};
protected <V> Constraint<Date> biggerThanTaskEndDate(
protected <V> Constraint<GanttDate> biggerThanTaskEndDate(
IAdapter<V, ?> adapter, V source) {
return biggerOrEqualThan(adapter.getEndDateFor(source));
}
protected <V> Constraint<Date> biggerThanTaskStartDate(
protected <V> Constraint<GanttDate> biggerThanTaskStartDate(
IAdapter<V, ?> adapter, V source) {
return biggerOrEqualThan(adapter.getStartDate(source));
}
@ -179,18 +179,18 @@ public enum DependencyType {
public abstract Date calculateStartDestinyTask(Task originTask,
Date current);
public final List<Constraint<Date>> getStartConstraints(Task source) {
public final List<Constraint<GanttDate>> getStartConstraints(Task source) {
return getStartConstraints(source, GanttDiagramGraph.taskAdapter());
}
public abstract <V> List<Constraint<Date>> getStartConstraints(V source,
IAdapter<V, ?> adapter);
public abstract <V> List<Constraint<GanttDate>> getStartConstraints(
V source, IAdapter<V, ?> adapter);
public final List<Constraint<Date>> getEndConstraints(Task source) {
public final List<Constraint<GanttDate>> getEndConstraints(Task source) {
return getEndConstraints(source, GanttDiagramGraph.taskAdapter());
}
public abstract <V> List<Constraint<Date>> getEndConstraints(V source,
public abstract <V> List<Constraint<GanttDate>> getEndConstraints(V source,
IAdapter<V, ?> adapter);
public abstract PointType getPointModified();

4
ganttzk/src/main/java/org/zkoss/ganttz/data/GanttDate.java
View file

@ -199,4 +199,8 @@ public abstract class GanttDate implements Comparable<GanttDate> {
protected abstract int compareToLocalDate(LocalDate localDate);
}
public boolean after(GanttDate other) {
return compareTo(other) > 0;
}
}

119
ganttzk/src/main/java/org/zkoss/ganttz/data/GanttDiagramGraph.java
View file

@ -23,7 +23,6 @@ package org.zkoss.ganttz.data;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
@ -85,25 +84,27 @@ public class GanttDiagramGraph<V, D> {
void registerDependenciesEnforcerHookOn(V task,
IDependenciesEnforcerHookFactory<V> hookFactory);
Date getStartDate(V task);
GanttDate getStartDate(V task);
void setStartDateFor(V task, Date newStart);
void setStartDateFor(V task, GanttDate newStart);
Date getEndDateFor(V task);
GanttDate getEndDateFor(V task);
void setEndDateFor(V task, Date newEnd);
void setEndDateFor(V task, GanttDate newEnd);
Date getSmallestBeginDateFromChildrenFor(V container);
GanttDate getSmallestBeginDateFromChildrenFor(V container);
Constraint<Date> getCurrentLenghtConstraintFor(V task);
Constraint<GanttDate> getCurrentLenghtConstraintFor(V task);
Constraint<Date> getEndDateBiggerThanStartDateConstraintFor(V task);
Constraint<GanttDate> getEndDateBiggerThanStartDateConstraintFor(V task);
List<Constraint<Date>> getEndConstraintsGivenIncoming(Set<D> incoming);
List<Constraint<GanttDate>> getEndConstraintsGivenIncoming(
Set<D> incoming);
List<Constraint<Date>> getStartCosntraintsGiven(Set<D> withDependencies);
List<Constraint<GanttDate>> getStartConstraintsGiven(
Set<D> withDependencies);
List<Constraint<Date>> getStartConstraintsFor(V task);
List<Constraint<GanttDate>> getStartConstraintsFor(V task);
V getSource(D dependency);
@ -179,57 +180,57 @@ public class GanttDiagramGraph<V, D> {
}
@Override
public Date getEndDateFor(Task task) {
return task.getEndDate().toDateApproximation();
public GanttDate getEndDateFor(Task task) {
return task.getEndDate();
}
@Override
public Constraint<Date> getCurrentLenghtConstraintFor(Task task) {
public Constraint<GanttDate> getCurrentLenghtConstraintFor(Task task) {
return task.getCurrentLengthConstraint();
}
@Override
public Constraint<Date> getEndDateBiggerThanStartDateConstraintFor(
public Constraint<GanttDate> getEndDateBiggerThanStartDateConstraintFor(
Task task) {
return task.getEndDateBiggerThanStartDate();
}
@Override
public List<Constraint<Date>> getEndConstraintsGivenIncoming(
public List<Constraint<GanttDate>> getEndConstraintsGivenIncoming(
Set<Dependency> incoming) {
return Dependency.getEndConstraints(incoming);
}
@Override
public void setEndDateFor(Task task, Date newEnd) {
task.setEndDate(GanttDate.createFrom(newEnd));
public void setEndDateFor(Task task, GanttDate newEnd) {
task.setEndDate(newEnd);
}
@Override
public Date getStartDate(Task task) {
return task.getBeginDate().toDateApproximation();
public GanttDate getStartDate(Task task) {
return task.getBeginDate();
}
@Override
public void setStartDateFor(Task task, Date newStart) {
task.setBeginDate(GanttDate.createFrom(newStart));
public void setStartDateFor(Task task, GanttDate newStart) {
task.setBeginDate(newStart);
}
@Override
public List<Constraint<Date>> getStartCosntraintsGiven(
public List<Constraint<GanttDate>> getStartConstraintsGiven(
Set<Dependency> withDependencies) {
return Dependency.getStartConstraints(withDependencies);
}
@Override
public List<Constraint<Date>> getStartConstraintsFor(Task task) {
public List<Constraint<GanttDate>> getStartConstraintsFor(Task task) {
return task.getStartConstraints();
}
@Override
public Date getSmallestBeginDateFromChildrenFor(Task container) {
public GanttDate getSmallestBeginDateFromChildrenFor(Task container) {
return ((TaskContainer) container)
.getSmallestBeginDateFromChildren().toDateApproximation();
.getSmallestBeginDateFromChildren();
}
@Override
@ -244,8 +245,8 @@ public class GanttDiagramGraph<V, D> {
ICriticalPathCalculable<Task> {
private GanttZKDiagramGraph(
List<Constraint<Date>> globalStartConstraints,
List<Constraint<Date>> globalEndConstraints,
List<Constraint<GanttDate>> globalStartConstraints,
List<Constraint<GanttDate>> globalEndConstraints,
boolean dependenciesConstraintsHavePriority) {
super(GANTTZK_ADAPTER, globalStartConstraints,
globalEndConstraints,
@ -259,8 +260,8 @@ public class GanttDiagramGraph<V, D> {
}
public static GanttZKDiagramGraph create(
List<Constraint<Date>> globalStartConstraints,
List<Constraint<Date>> globalEndConstraints,
List<Constraint<GanttDate>> globalStartConstraints,
List<Constraint<GanttDate>> globalEndConstraints,
boolean dependenciesConstraintsHavePriority) {
return new GanttZKDiagramGraph(globalStartConstraints,
globalEndConstraints, dependenciesConstraintsHavePriority);
@ -274,9 +275,9 @@ public class GanttDiagramGraph<V, D> {
private Map<V, V> fromChildToParent = new HashMap<V, V>();
private final List<Constraint<Date>> globalStartConstraints;
private final List<Constraint<GanttDate>> globalStartConstraints;
private final List<Constraint<Date>> globalEndConstraints;
private final List<Constraint<GanttDate>> globalEndConstraints;
private DependenciesEnforcer enforcer = new DependenciesEnforcer();
@ -344,16 +345,16 @@ public class GanttDiagramGraph<V, D> {
}
public static <V, D> GanttDiagramGraph<V, D> create(IAdapter<V, D> adapter,
List<Constraint<Date>> globalStartConstraints,
List<Constraint<Date>> globalEndConstraints,
List<Constraint<GanttDate>> globalStartConstraints,
List<Constraint<GanttDate>> globalEndConstraints,
boolean dependenciesConstraintsHavePriority) {
return new GanttDiagramGraph<V, D>(adapter, globalStartConstraints,
globalEndConstraints, dependenciesConstraintsHavePriority);
}
protected GanttDiagramGraph(IAdapter<V, D> adapter,
List<Constraint<Date>> globalStartConstraints,
List<Constraint<Date>> globalEndConstraints,
List<Constraint<GanttDate>> globalStartConstraints,
List<Constraint<GanttDate>> globalEndConstraints,
boolean dependenciesConstraintsHavePriority) {
this.adapter = adapter;
this.globalStartConstraints = globalStartConstraints;
@ -849,10 +850,10 @@ public class GanttDiagramGraph<V, D> {
}
boolean enforceParentShrinkage(V container) {
Date oldBeginDate = adapter.getStartDate(container);
Date firstStart = adapter
GanttDate oldBeginDate = adapter.getStartDate(container);
GanttDate firstStart = adapter
.getSmallestBeginDateFromChildrenFor(container);
Date previousEnd = adapter.getEndDateFor(container);
GanttDate previousEnd = adapter.getEndDateFor(container);
if (firstStart.after(oldBeginDate)) {
adapter.setStartDateFor(container, firstStart);
adapter.setEndDateFor(container, previousEnd);
@ -1019,7 +1020,7 @@ public class GanttDiagramGraph<V, D> {
private boolean enforceStartAndEnd(V task) {
Set<D> incoming = graph.incomingEdgesOf(task);
Date previousEndDate = adapter.getEndDateFor(task);
GanttDate previousEndDate = adapter.getEndDateFor(task);
boolean startDateChanged = enforceStartDate(task, incoming);
boolean endDateChanged = !parentRecalculation
&& enforceEndDate(task, previousEndDate, incoming);
@ -1028,26 +1029,27 @@ public class GanttDiagramGraph<V, D> {
private boolean enforceEnd(V task) {
Set<D> incoming = graph.incomingEdgesOf(task);
Date previousEndDate = adapter.getEndDateFor(task);
GanttDate previousEndDate = adapter.getEndDateFor(task);
return enforceEndDate(task, previousEndDate, incoming);
}
@SuppressWarnings("unchecked")
private boolean enforceEndDate(V task, Date previousEndDate,
private boolean enforceEndDate(V task, GanttDate previousEndDate,
Set<D> incoming) {
if (adapter.isFixed(task)) {
return false;
}
Constraint<Date> currentLength = adapter
Constraint<GanttDate> currentLength = adapter
.getCurrentLenghtConstraintFor(task);
Constraint<Date> respectStartDate = adapter
Constraint<GanttDate> respectStartDate = adapter
.getEndDateBiggerThanStartDateConstraintFor(task);
Date newEnd = Constraint.<Date> initialValue(null)
GanttDate newEnd = Constraint
.<GanttDate> initialValue(null)
.withConstraints(currentLength)
.withConstraints(adapter.getEndConstraintsGivenIncoming(incoming))
.withConstraints(respectStartDate)
.apply();
if (!adapter.getEndDateFor(task).equals(newEnd)) {
if (hasChanged(previousEndDate, newEnd)) {
adapter.setEndDateFor(task, newEnd);
}
return !previousEndDate.equals(newEnd);
@ -1057,26 +1059,35 @@ public class GanttDiagramGraph<V, D> {
if (adapter.isFixed(task)) {
return false;
}
Date newStart = calculateStartDateFor(task, incoming);
if (!adapter.getStartDate(task).equals(newStart)) {
GanttDate newStart = calculateStartDateFor(task, incoming);
GanttDate old = adapter.getStartDate(task);
if (hasChanged(old, newStart)) {
adapter.setStartDateFor(task, newStart);
return true;
}
return false;
}
private Date calculateStartDateFor(V task, Set<D> withDependencies) {
List<Constraint<Date>> dependencyConstraints = adapter
.getStartCosntraintsGiven(withDependencies);
Date newStart;
private boolean hasChanged(GanttDate old, GanttDate newValue) {
if (old == newValue) {
return false;
}
return (old == null) != (newValue == null)
|| old.compareTo(newValue) != 0;
}
private GanttDate calculateStartDateFor(V task, Set<D> withDependencies) {
List<Constraint<GanttDate>> dependencyConstraints = adapter
.getStartConstraintsGiven(withDependencies);
GanttDate newStart;
if (dependenciesConstraintsHavePriority) {
newStart = Constraint.<Date> initialValue(null)
newStart = Constraint.<GanttDate> initialValue(null)
.withConstraints(adapter.getStartConstraintsFor(task))
.withConstraints(dependencyConstraints)
.withConstraints(globalStartConstraints).apply();
} else {
newStart = Constraint.<Date> initialValue(null)
newStart = Constraint.<GanttDate> initialValue(null)
.withConstraints(dependencyConstraints)
.withConstraints(adapter.getStartConstraintsFor(task))
.withConstraints(globalStartConstraints).apply();

2
ganttzk/src/main/java/org/zkoss/ganttz/data/ITaskFundamentalProperties.java
View file

@ -74,7 +74,7 @@ public interface ITaskFundamentalProperties {
public String getResourcesText();
List<Constraint<Date>> getStartConstraints();
List<Constraint<GanttDate>> getStartConstraints();
public void moveTo(GanttDate date);

17
ganttzk/src/main/java/org/zkoss/ganttz/data/Task.java
View file

@ -70,7 +70,7 @@ public abstract class Task implements ITaskFundamentalProperties {
private boolean inCriticalPath = false;
private ConstraintViolationNotificator<Date> violationNotificator = ConstraintViolationNotificator
private ConstraintViolationNotificator<GanttDate> violationNotificator = ConstraintViolationNotificator
.create();
private IDependenciesEnforcerHook dependenciesEnforcerHook = GanttDiagramGraph.doNothingHook();
@ -102,7 +102,7 @@ public abstract class Task implements ITaskFundamentalProperties {
}
@Override
public List<Constraint<Date>> getStartConstraints() {
public List<Constraint<GanttDate>> getStartConstraints() {
return violationNotificator.withListener(fundamentalProperties
.getStartConstraints());
}
@ -217,18 +217,17 @@ public abstract class Task implements ITaskFundamentalProperties {
return fundamentalProperties.getEndDate();
}
public Constraint<Date> getCurrentLengthConstraint() {
public Constraint<GanttDate> getCurrentLengthConstraint() {
if (isContainer()) {
return Constraint.emptyConstraint();
}
return violationNotificator.withListener(biggerOrEqualThan(getEndDate()
.toDateApproximation()));
return violationNotificator
.withListener(biggerOrEqualThan(getEndDate()));
}
public Constraint<Date> getEndDateBiggerThanStartDate() {
public Constraint<GanttDate> getEndDateBiggerThanStartDate() {
return violationNotificator
.withListener(biggerOrEqualThan(getBeginDate()
.toDateApproximation()));
.withListener(biggerOrEqualThan(getBeginDate()));
}
public String getNotes() {
@ -327,7 +326,7 @@ public abstract class Task implements ITaskFundamentalProperties {
}
public void addConstraintViolationListener(
IConstraintViolationListener<Date> listener) {
IConstraintViolationListener<GanttDate> listener) {
violationNotificator.addConstraintViolationListener(listener);
}

30
ganttzk/src/main/java/org/zkoss/ganttz/data/criticalpath/CriticalPathCalculator.java
View file

@ -22,7 +22,6 @@ package org.zkoss.ganttz.data.criticalpath;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
@ -141,7 +140,7 @@ public class CriticalPathCalculator<T extends ITaskFundamentalProperties> {
Node<T> node = nodes.get(task);
DependencyType dependencyType = getDependencyTypeEndStartByDefault(
currentTask, task);
Constraint<Date> constraint = getDateConstraint(task);
Constraint<GanttDate> constraint = getDateConstraint(task);
switch (dependencyType) {
case START_START:
@ -168,23 +167,24 @@ public class CriticalPathCalculator<T extends ITaskFundamentalProperties> {
}
private void setEarliestStart(Node<T> node, int earliestStart,
Constraint<Date> constraint) {
Constraint<GanttDate> constraint) {
if (constraint != null) {
Date date = initDate.plusDays(earliestStart)
.toDateTimeAtStartOfDay().toDate();
GanttDate date = GanttDate.createFrom(initDate
.plusDays(earliestStart));
date = constraint.applyTo(date);
earliestStart = Days.daysBetween(initDate, new LocalDate(date))
earliestStart = Days.daysBetween(initDate,
LocalDate.fromDateFields(date.toDateApproximation()))
.getDays();
}
node.setEarliestStart(earliestStart);
}
private Constraint<Date> getDateConstraint(T task) {
private Constraint<GanttDate> getDateConstraint(T task) {
if (task == null) {
return null;
}
List<Constraint<Date>> constraints = task.getStartConstraints();
List<Constraint<GanttDate>> constraints = task.getStartConstraints();
if (constraints == null) {
return null;
}
@ -214,7 +214,7 @@ public class CriticalPathCalculator<T extends ITaskFundamentalProperties> {
Node<T> node = nodes.get(task);
DependencyType dependencyType = getDependencyTypeEndStartByDefault(
task, currentTask);
Constraint<Date> constraint = getDateConstraint(task);
Constraint<GanttDate> constraint = getDateConstraint(task);
switch (dependencyType) {
case START_START:
@ -241,15 +241,15 @@ public class CriticalPathCalculator<T extends ITaskFundamentalProperties> {
}
private void setLatestFinish(Node<T> node, int latestFinish,
Constraint<Date> constraint) {
Constraint<GanttDate> constraint) {
if (constraint != null) {
int duration = node.getDuration();
Date date = initDate.plusDays(latestFinish - duration)
.toDateTimeAtStartOfDay().toDate();
GanttDate date = GanttDate.createFrom(initDate.plusDays(latestFinish - duration));
date = constraint.applyTo(date);
latestFinish = Days.daysBetween(initDate, new LocalDate(date))
.getDays()
+ duration;
int daysBetween = Days.daysBetween(initDate,
LocalDate.fromDateFields(date.toDateApproximation()))
.getDays();
latestFinish = daysBetween + duration;
}
node.setLatestFinish(latestFinish);
}

3
ganttzk/src/test/java/org/zkoss/ganttz/data/constraint/ConstraintOnComparableValuesTest.java
View file

@ -44,7 +44,8 @@ public class ConstraintOnComparableValuesTest {
@Test
public void biggerOrEqualThanNullLeaveValuesUnmodified() {
Constraint<Date> biggerThanNull = biggerOrEqualThan(null);
Constraint<Date> biggerThanNull = ConstraintOnComparableValues
.<Date> biggerOrEqualThan(null);
Date eraStart = new Date(0);
assertThat(biggerThanNull.applyConstraintTo(new Date(0)),
equalTo(eraStart));

11
ganttzk/src/test/java/org/zkoss/ganttz/data/criticalpath/CriticalPathCalculatorTest.java
View file

@ -29,7 +29,6 @@ import static org.junit.Assert.assertThat;
import static org.zkoss.ganttz.data.constraint.ConstraintOnComparableValues.biggerOrEqualThan;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
@ -70,9 +69,8 @@ public class CriticalPathCalculatorTest {
expect(result.getBeginDate()).andReturn(toDate(start)).anyTimes();
expect(result.getEndDate()).andReturn(
toDate(start.plusDays(durationDays))).anyTimes();
Constraint<Date> constraint = biggerOrEqualThan(date
.toDateTimeAtStartOfDay().toDate());
GanttDate ganttDate = GanttDate.createFrom(date);
Constraint<GanttDate> constraint = biggerOrEqualThan(ganttDate);
expect(result.getStartConstraints()).andReturn(
Arrays.asList(constraint)).anyTimes();
@ -87,8 +85,9 @@ public class CriticalPathCalculatorTest {
expect(result.getEndDate()).andReturn(
toDate(start.plusDays(durationDays))).anyTimes();
Constraint<Date> constraint = ConstraintOnComparableValues.equalTo(date
.toDateTimeAtStartOfDay().toDate());
GanttDate ganttDate = GanttDate.createFrom(date);
Constraint<GanttDate> constraint = ConstraintOnComparableValues
.equalTo(ganttDate);
expect(result.getStartConstraints()).andReturn(
Arrays.asList(constraint)).anyTimes();

56
navalplanner-webapp/src/main/java/org/navalplanner/web/common/TemplateModel.java
View file

@ -21,11 +21,12 @@
package org.navalplanner.web.common;
import static org.navalplanner.business.i18n.I18nHelper._;
import static org.navalplanner.web.planner.TaskElementAdapter.toGantt;
import static org.navalplanner.web.planner.TaskElementAdapter.toIntraDay;
import static org.zkoss.ganttz.data.constraint.ConstraintOnComparableValues.biggerOrEqualThan;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map.Entry;
@ -102,10 +103,9 @@ public class TemplateModel implements ITemplateModel {
.getDestination(), toGraphicalType(each.getType()), true);
}
public static List<Constraint<Date>> getStartConstraintsGiven(
Adapter adapter,
Set<DependencyWithVisibility> withDependencies) {
List<Constraint<Date>> result = new ArrayList<Constraint<Date>>();
public static List<Constraint<GanttDate>> getStartConstraintsGiven(
Adapter adapter, Set<DependencyWithVisibility> withDependencies) {
List<Constraint<GanttDate>> result = new ArrayList<Constraint<GanttDate>>();
for (DependencyWithVisibility each : withDependencies) {
TaskElement source = each.getSource();
DependencyType type = each.getGraphicalType();
@ -114,10 +114,10 @@ public class TemplateModel implements ITemplateModel {
return result;
}
public static List<Constraint<Date>> getEndConstraintsGiven(
public static List<Constraint<GanttDate>> getEndConstraintsGiven(
Adapter adapter,
Set<DependencyWithVisibility> withDependencies) {
List<Constraint<Date>> result = new ArrayList<Constraint<Date>>();
List<Constraint<GanttDate>> result = new ArrayList<Constraint<GanttDate>>();
for (DependencyWithVisibility each : withDependencies) {
TaskElement source = each.getSource();
DependencyType type = each.getGraphicalType();
@ -235,14 +235,15 @@ public class TemplateModel implements ITemplateModel {
}
@Override
public List<Constraint<Date>> getEndConstraintsGivenIncoming(
public List<Constraint<GanttDate>> getEndConstraintsGivenIncoming(
Set<DependencyWithVisibility> incoming) {
return DependencyWithVisibility.getEndConstraintsGiven(this,
incoming);
}
@Override
public Constraint<Date> getCurrentLenghtConstraintFor(TaskElement task) {
public Constraint<GanttDate> getCurrentLenghtConstraintFor(
TaskElement task) {
if (isContainer(task)) {
return Constraint.emptyConstraint();
}
@ -267,22 +268,21 @@ public class TemplateModel implements ITemplateModel {
}
@Override
public Constraint<Date> getEndDateBiggerThanStartDateConstraintFor(
public Constraint<GanttDate> getEndDateBiggerThanStartDateConstraintFor(
TaskElement task) {
return biggerOrEqualThan(getStartDate(task));
}
@Override
public Date getEndDateFor(TaskElement task) {
return task.getEndDate();
public GanttDate getEndDateFor(TaskElement task) {
return toGantt(task.getIntraDayEndDate());
}
@Override
public Date getSmallestBeginDateFromChildrenFor(TaskElement container) {
public GanttDate getSmallestBeginDateFromChildrenFor(
TaskElement container) {
TaskGroup taskGroup = (TaskGroup) container;
IntraDayDate smallestStart = taskGroup
.getSmallestStartDateFromChildren();
return smallestStart.toDateTimeAtStartOfDay().toDate();
return toGantt(taskGroup.getSmallestStartDateFromChildren());
}
@Override
@ -291,20 +291,21 @@ public class TemplateModel implements ITemplateModel {
}
@Override
public List<Constraint<Date>> getStartConstraintsFor(TaskElement task) {
public List<Constraint<GanttDate>> getStartConstraintsFor(
TaskElement task) {
return TaskElementAdapter.getStartConstraintsFor(task);
}
@Override
public List<Constraint<Date>> getStartCosntraintsGiven(
public List<Constraint<GanttDate>> getStartConstraintsGiven(
Set<DependencyWithVisibility> withDependencies) {
return DependencyWithVisibility.getStartConstraintsGiven(this,
withDependencies);
}
@Override
public Date getStartDate(TaskElement task) {
return task.getStartDate();
public GanttDate getStartDate(TaskElement task) {
return toGantt(task.getIntraDayStartDate());
}
@Override
@ -330,13 +331,13 @@ public class TemplateModel implements ITemplateModel {
}
@Override
public void setEndDateFor(TaskElement task, Date newEnd) {
task.setEndDate(newEnd);
public void setEndDateFor(TaskElement task, GanttDate newEnd) {
task.setIntraDayEndDate(toIntraDay(newEnd));
}
@Override
public void setStartDateFor(TaskElement task, Date newStart) {
task.moveTo(scenario, LocalDate.fromDateFields(newStart));
public void setStartDateFor(TaskElement task, GanttDate newStart) {
task.moveTo(scenario, toIntraDay(newStart));
}
@Override
@ -565,9 +566,10 @@ public class TemplateModel implements ITemplateModel {
private GanttDiagramGraph<TaskElement, DependencyWithVisibility> createFor(
Order order, IAdapter<TaskElement, DependencyWithVisibility> adapter) {
List<Constraint<Date>> startConstraints = PlannerConfiguration
.getStartConstraintsGiven(order.getInitDate());
List<Constraint<Date>> endConstraints = Collections.emptyList();
List<Constraint<GanttDate>> startConstraints = PlannerConfiguration
.getStartConstraintsGiven(GanttDate.createFrom(order
.getInitDate()));
List<Constraint<GanttDate>> endConstraints = Collections.emptyList();
GanttDiagramGraph<TaskElement, DependencyWithVisibility> result = GanttDiagramGraph
.create(adapter, startConstraints, endConstraints,
order.getDependenciesConstraintsHavePriority());

20
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/TaskElementAdapter.java
View file

@ -99,7 +99,7 @@ public class TaskElementAdapter implements ITaskElementAdapter {
this.preventCalculateResourcesText = preventCalculateResourcesText;
}
public static List<Constraint<Date>> getStartConstraintsFor(
public static List<Constraint<GanttDate>> getStartConstraintsFor(
TaskElement taskElement) {
if (taskElement instanceof ITaskLeafConstraint) {
ITaskLeafConstraint task = (ITaskLeafConstraint) taskElement;
@ -110,11 +110,12 @@ public class TaskElementAdapter implements ITaskElementAdapter {
case AS_SOON_AS_POSSIBLE:
return Collections.emptyList();
case START_IN_FIXED_DATE:
return Collections.singletonList(equalTo(asDate(startConstraint
return Collections
.singletonList(equalTo(toGantt(startConstraint
.getConstraintDate())));
case START_NOT_EARLIER_THAN:
return Collections
.singletonList(biggerOrEqualThan(asDate(startConstraint
.singletonList(biggerOrEqualThan(toGantt(startConstraint
.getConstraintDate())));
default:
throw new RuntimeException("can't handle " + constraintType);
@ -124,10 +125,6 @@ public class TaskElementAdapter implements ITaskElementAdapter {
}
}
private static Date asDate(LocalDate date) {
return date.toDateTimeAtStartOfDay().toDate();
}
@Autowired
private IAdHocTransactionService transactionService;
@ -161,6 +158,13 @@ public class TaskElementAdapter implements ITaskElementAdapter {
return new GanttDateAdapter(date);
}
public static GanttDate toGantt(LocalDate date) {
if (date == null) {
return null;
}
return GanttDate.createFrom(date);
}
public static IntraDayDate toIntraDay(GanttDate date) {
if (date == null) {
return null;
@ -605,7 +609,7 @@ public class TaskElementAdapter implements ITaskElementAdapter {
}
@Override
public List<Constraint<Date>> getStartConstraints() {
public List<Constraint<GanttDate>> getStartConstraints() {
return getStartConstraintsFor(this.taskElement);
}