Java tutorial
/* The contents of this file are subject to the Common Public Attribution License Version 1.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.projity.com/license . The License is based on the Mozilla Public License Version 1.1 but Sections 14 and 15 have been added to cover use of software over a computer network and provide for limited attribution for the Original Developer. In addition, Exhibit A has been modified to be consistent with Exhibit B. Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. The Original Code is OpenProj. The Original Developer is the Initial Developer and is Projity, Inc. All portions of the code written by Projity are Copyright (c) 2006, 2007. All Rights Reserved. Contributors Projity, Inc. Alternatively, the contents of this file may be used under the terms of the Projity End-User License Agreeement (the Projity License), in which case the provisions of the Projity License are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of the Projity License and not to allow others to use your version of this file under the CPAL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the Projity License. If you do not delete the provisions above, a recipient may use your version of this file under either the CPAL or the Projity License. [NOTE: The text of this license may differ slightly from the text of the notices in Exhibits A and B of the license at http://www.projity.com/license. You should use the latest text at http://www.projity.com/license for your modifications. You may not remove this license text from the source files.] Attribution Information: Attribution Copyright Notice: Copyright (c) 2006, 2007 Projity, Inc. Attribution Phrase (not exceeding 10 words): Powered by OpenProj, an open source solution from Projity. Attribution URL: http://www.projity.com Graphic Image as provided in the Covered Code as file: openproj_logo.png with alternatives listed on http://www.projity.com/logo Display of Attribution Information is required in Larger Works which are defined in the CPAL as a work which combines Covered Code or portions thereof with code not governed by the terms of the CPAL. However, in addition to the other notice obligations, all copies of the Covered Code in Executable and Source Code form distributed must, as a form of attribution of the original author, include on each user interface screen the "OpenProj" logo visible to all users. The OpenProj logo should be located horizontally aligned with the menu bar and left justified on the top left of the screen adjacent to the File menu. The logo must be at least 100 x 25 pixels. When users click on the "OpenProj" logo it must direct them back to http://www.projity.com. */ package com.projity.pm.assignment; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.Collection; import java.util.Comparator; import java.util.Date; import org.apache.commons.collections.Closure; import org.apache.commons.collections.Predicate; import com.projity.algorithm.CollectionIntervalGenerator; import com.projity.algorithm.DoubleValue; import com.projity.algorithm.InstantIntervalGenerator; import com.projity.algorithm.IntervalGeneratorSet; import com.projity.algorithm.Merge; import com.projity.algorithm.Query; import com.projity.algorithm.RangeIntervalGenerator; import com.projity.algorithm.ReverseQuery; import com.projity.algorithm.SelectFrom; import com.projity.algorithm.TimeIteratorGenerator; import com.projity.algorithm.buffer.CalculatedValues; import com.projity.association.Association; import com.projity.association.InvalidAssociationException; import com.projity.configuration.Configuration; import com.projity.datatype.CanSupplyRateUnit; import com.projity.datatype.Duration; import com.projity.datatype.DurationFormat; import com.projity.datatype.ImageLink; import com.projity.datatype.Rate; import com.projity.datatype.RateFormat; import com.projity.datatype.TimeUnit; import com.projity.document.Document; import com.projity.field.Field; import com.projity.field.FieldContext; import com.projity.functor.IntervalConsumer; import com.projity.functor.ObjectVisitor; import com.projity.options.AdvancedOption; import com.projity.pm.assignment.contour.AbstractContour; import com.projity.pm.assignment.contour.AbstractContourBucket; import com.projity.pm.assignment.contour.ContourBucketIntervalGenerator; import com.projity.pm.assignment.contour.ContourFactory; import com.projity.pm.assignment.contour.PersonalContour; import com.projity.pm.assignment.functor.AssignmentFieldClosureCollection; import com.projity.pm.assignment.functor.AssignmentFieldFunctor; import com.projity.pm.assignment.functor.CalculatedValuesFunctor; import com.projity.pm.assignment.functor.CostFunctor; import com.projity.pm.assignment.functor.DateAtValueFunctor; import com.projity.pm.assignment.functor.FixedCostFunctor; import com.projity.pm.assignment.functor.PercentAllocFunctor; import com.projity.pm.assignment.functor.PersonalContourMaker; import com.projity.pm.assignment.functor.PrintValueFunctor; import com.projity.pm.assignment.functor.ResourceAvailabilityFunctor; import com.projity.pm.assignment.functor.ValueAtInstant; import com.projity.pm.assignment.functor.WorkComparator; import com.projity.pm.assignment.functor.WorkFunctor; import com.projity.pm.assignment.functor.ZeroFunctor; import com.projity.pm.assignment.timesheet.AssignmentWorkflowState; import com.projity.pm.assignment.timesheet.TimesheetHelper; import com.projity.pm.assignment.timesheet.TimesheetStatus; import com.projity.pm.assignment.timesheet.UpdatesFromTimesheet; import com.projity.pm.calendar.WorkCalendar; import com.projity.pm.costing.Accrual; import com.projity.pm.costing.EarnedValueCalculator; import com.projity.pm.costing.EarnedValueFields; import com.projity.pm.costing.EarnedValueValues; import com.projity.pm.costing.HasCostRateIndex; import com.projity.pm.criticalpath.TaskSchedule; import com.projity.pm.key.HasKey; import com.projity.pm.key.HasKeyImpl; import com.projity.pm.resource.Resource; import com.projity.pm.resource.ResourceImpl; import com.projity.pm.scheduling.BarClosure; import com.projity.pm.scheduling.ConstraintType; import com.projity.pm.scheduling.Delayable; import com.projity.pm.scheduling.Schedule; import com.projity.pm.scheduling.ScheduleInterval; import com.projity.pm.scheduling.ScheduleUtil; import com.projity.pm.scheduling.SchedulingType; import com.projity.pm.snapshot.Snapshottable; import com.projity.pm.task.BelongsToDocument; import com.projity.pm.task.NormalTask; import com.projity.pm.task.Project; import com.projity.pm.task.Task; import com.projity.pm.time.HasStartAndEnd; import com.projity.pm.time.ImmutableInterval; import com.projity.pm.time.Interval; import com.projity.pm.time.MutableInterval; import com.projity.server.data.DataObject; import com.projity.strings.Messages; import com.projity.util.Alert; import com.projity.util.Environment; /** * Class representing resource assignments * @stereotype thing */ public final class Assignment implements Schedule, Association, Allocation, Delayable, HasTimeDistributedData, TimeDistributedFields, EarnedValueValues, EarnedValueFields, AssignmentSpecificFields, HasKey, BelongsToDocument, HasRequestDemandType, UpdatesFromTimesheet, CanSupplyRateUnit, HasCostRateIndex, Cloneable, DataObject { static final long serialVersionUID = 56779404923241L; AssignmentDetail detail = null; private transient HasKeyImpl hasKey = new HasKeyImpl(true, this); //local ids only for assignments private static Field unitsFieldInstance = null; private transient Date cachedStart = null; private transient Date cachedEnd = null; private transient int timesheetStatus = TimesheetStatus.NO_DATA; private transient long lastTimesheetUpdate = 0; private transient int workflowState = AssignmentWorkflowState.NEW; private transient boolean timesheetAssignment = false; public static Field getUnitsField() { if (unitsFieldInstance == null) unitsFieldInstance = Configuration.getFieldFromId("Field.assignmentUnits"); return unitsFieldInstance; } private static Field rateFieldInstance = null; public static Field getRateField() { if (rateFieldInstance == null) rateFieldInstance = Configuration.getFieldFromId("Field.rate"); return rateFieldInstance; } private static Field requestDemandTypeInstance = null; public static Field getRequestDemandTypeField() { if (requestDemandTypeInstance == null) requestDemandTypeInstance = Configuration.getFieldFromId("Field.requestDemandType"); return requestDemandTypeInstance; } public static Assignment getInstance(Task task, Resource resource, double units, int requestDemandType) { return new Assignment(task, resource, units, requestDemandType); } public static Assignment getInstance(Task task, Resource resource, double units, long delay) { return new Assignment(task, resource, units, delay); } /** * Construct an assignment. The arguments are those that are presented in the assign resource dialog * @param task * @param resource * @param units * @param requestDemandType -Normally empty */ private Assignment(Task task, Resource resource, double units, int requestDemandType) { detail = new AssignmentDetail(task, resource, units, requestDemandType, 0); } public Assignment(Assignment from) { detail = from.detail; } public Assignment(AssignmentDetail detail) { this.detail = detail; } public boolean isReadOnly() { return getTask().isReadOnly(); } public boolean isExternal() { return getTask().isExternal(); } public static Predicate instanceofPredicate() { return new Predicate() { public boolean evaluate(Object arg0) { return arg0 instanceof Assignment; } }; } /** * Copy the properies from another assignment. This also includes the contour. However, it does NOT * include the resource or the units. This is called in the context of replacing an assignment. * @param from Assignment to copy from */ public void usePropertiesOf(Assignment from) { boolean compatibleTypes = isLabor() == from.isLabor(); double units = getUnits(); Rate r = getRate(); Resource resource = getResource(); detail = (AssignmentDetail) from.detail.clone(); detail.replaceResourceAndUnits(units, resource); if (!compatibleTypes) // don't want to set units if not compatible detail.setRate(r); } public void setStart(long start) { detail.setStart(start); } public int getRequestDemandType() { return detail.getRequestDemandType(); } public void setRequestDemandType(int requestDemandType) { newDetail().setRequestDemandType(requestDemandType); } public AbstractContourBucket[] getContour(Object type) { return detail.getContour(type); } /** * Constructor adapted to mpx * @param task * @param resource * @param units * @param delay */ private Assignment(Task task, Resource resource, double units, long delay) { detail = new AssignmentDetail(task, resource, units, RequestDemandType.NONE, delay); } /** * Accessor for units (value of work) * @return units */ public final double getUnits() { return detail.getUnits(); } public final double getLaborUnits() { if (isLabor()) return getUnits(); return 0.0D; } public void setOvertimeWork(long overtimeWork) { newDetail().setOvertimeWork(overtimeWork); } /** * For use in sharing with external systems such as salesforce. Uniquely identifies object * @return */ public String toExternalId() { return getResourceId() + "." + getTaskId(); } public String toString() { return getTask() + "/" + getResource(); //super.toString(); // return "[start] " + new java.util.Date(getStart()) // + "\n[end] " + new java.util.Date(getEnd()) // +"\n[units] " + getUnits()// in hours // +"\n[work] " + getWork() / (1000*60*60); // in hours } /** * @return Returns the contour. */ public AbstractContour getWorkContour() { return detail.getWorkContour(); } /** * @param contour The contour to set. * TODO get rid of this */ public void debugSetWorkContour(AbstractContour contour) { newDetail().setWorkContour(contour); } /** * Accessor for the assignment's delay * @return delay */ public long getDelay() { return detail.getDelay(); } public void setDelay(long delay) { newDetail().setDelay(delay); } public long getLevelingDelay() { return detail.getLevelingDelay(); } public void setLevelingDelay(long levelingDelay) { newDetail().setLevelingDelay(levelingDelay); } /** * @return Returns the duration. */ public long getDurationMillis() { return detail.getDuration(); } private void setDurationMillis(long durationMillis) { newDetail().setDuration(durationMillis); } public void setDuration(long duration) { adjustRemainingDuration(duration - getActualDuration(), false); } /** * @param duration The duration to set. */ public void adjustRemainingDuration(long newRemainingDuration, boolean doChildren) { long old = getRemainingDuration(); newRemainingDuration = Duration.millis(newRemainingDuration); // don't use time unit if (getUnits() == 0) // take care of degenerate case newRemainingDuration = 0; newDetail().adjustRemainingDuration(newRemainingDuration); //TODO commented out may 8 2007 // if (getTaskSchedulingType() == SchedulingType.FIXED_WORK && newRemainingDuration != 0) { // double multiplier = ((double)old) / newRemainingDuration; // if (multiplier > 0) { // detail.setWorkContour(detail.getWorkContour().adjustUnits(multiplier, getActualDuration())); // detail.setUnits(getUnits() * multiplier); // } // } } public void adjustRemainingDurationIfWorkingAtTaskEnd(long newRemainingDuration) { if (getEnd() >= getTask().getEnd() || !isInitialized()) adjustRemainingDuration(newRemainingDuration, false); } public void adjustRemainingWork(double multiplier, boolean doChildren) { if (getPercentComplete() > 0.0D) // if actuals, then remaining may have different contour makeContourPersonal(); //fix? newDetail().adjustRemainingWork(multiplier); } /** * @param units The units to set. */ public void adjustRemainingUnits(double newRemainingUnits, double oldRemainingUnits, boolean doChildren, boolean conserveTotalUnits) { if (!isTemporal()) // for absolute quantities, don't change return; oldRemainingUnits = getRemainingUnits(); NormalTask task = (NormalTask) getTask(); // task.adjustUnitsDelta(newRemainingUnits - oldRemainingUnits); if (doChildren) { task.getSchedulingRule().adjustRemainingUnits(this, newRemainingUnits, oldRemainingUnits, false, false); } else { // just treat the assignment if (getPercentComplete() > 0.0D) // if actuals, then remaining may have different contour makeContourPersonal(); newDetail().adjustRemainingUnits(newRemainingUnits); } } public void setWork(long work, FieldContext context) { work = Duration.millis(work); if (isLabor() && work < 60000) { work *= Duration.timeUnitFactor(TimeUnit.HOURS); System.out.println("modifying invalid work to make it hours"); } long remainingWork = work - getActualWork(null); WorkCalendar cal = getEffectiveWorkCalendar(); if (!FieldContext.hasInterval(context)) { long currentRemainingWork = Duration.millis(getWork(context)) - Duration.millis(getActualWork(context)); if (currentRemainingWork == 0 && remainingWork == 0) adjustRemainingUnits(0, 0, true, false); //TODO is this ok? else { if (getTaskSchedulingType() == SchedulingType.FIXED_UNITS) adjustRemainingDuration(remainingWork, false); else if (getTaskSchedulingType() == SchedulingType.FIXED_DURATION && currentRemainingWork > 0) adjustRemainingWork(((double) remainingWork) / currentRemainingWork, true); // newDetail().setWorkContour(getWorkContour().adjustUnits((((double)remainingWork) / currentRemainingWork), getActualDuration())); else newDetail().adjustRemainingDuration(remainingWork); // just set duration } } else { long start = cal.adjustInsideCalendar(context.getStart(), false); long end = cal.adjustInsideCalendar(context.getEnd(), true); if (end > start) setWorkInterval(start, end, work); if (getRate().getValue() == 0.0D) {// special case if units was 0 double rate = ((double) work) / cal.compare(end, start, false); // use rate for the period as the assignment's rate this.forceUnits(rate); } } } private boolean addWorkingTimeIfRequired(long work, FieldContext context, boolean actual) { WorkCalendar cal = getEffectiveWorkCalendar(); // adjust start and end inside the calendar long start = cal.adjustInsideCalendar(context.getStart(), false); long end = cal.adjustInsideCalendar(context.getEnd(), true); if (work != 0 && !verifyBounds(start, end)) return false; // if adding during non calendar time if (end <= start && work != 0) { start = context.getStart(); end = context.getEnd(); // example 10 day task - MTWTFSSMTWTF // initial bar: ===== ===== // calendar time add ====== ==== here I make a saturday working, so the task finishes sooner // shift the saturday ===== ===== shifting the saturday puts the task back as it was // set the interval ====== ===== now I set the saturday value // System.out.println("before adding" + getWorkContour()); addCalendarTime(start, end); cal = getEffectiveWorkCalendar(); if (actual && getTask().getActualStart() == 0) { long taskStart = cal.adjustInsideCalendar(start, false); ((NormalTask) getTask()).setActualStartNoEvent(taskStart); } long addedDuration = cal.compare(end, start, false); // System.out.println("before shift" + getWorkContour()); shift(start, end, addedDuration); // shift the remaining contour to the right by the duration of the inserted time // System.out.println("after shift" + getWorkContour()); getTask().recalculateLater(this); // task needs to be recalculated // SwingUtilities.invokeLater(new Runnable()); } return true; } public void makeFlatIfPossible() { if (getWorkContour().isPersonal()) { detail.recalculateDuration(); // set duration from contour detail.setWorkContour(((PersonalContour) getWorkContour()).convertToFlatIfPossible()); } } public void setActualWork(long actualWork, FieldContext fieldContext) { long workValue = Duration.millis(actualWork); if (FieldContext.hasInterval(fieldContext)) { boolean isComplete = getPercentComplete() == 1.0D; long oldWork = work(); if (!addWorkingTimeIfRequired(actualWork, fieldContext, true)) return; //if the task isn't yet started and setting work, move to start date if (getTask().getActualStart() == 0 && actualWork != 0) { long s = getEffectiveWorkCalendar().adjustInsideCalendar(fieldContext.getStart(), false); getTask().setActualStart(s); //TODO handle if setting non calendar time } long stop = getStop(); setWork(actualWork, fieldContext); //when entering time phased actuals, first thing is adjust the work contour // if (!isComplete) // ((NormalTask)getTask()).getSchedulingRule().adjustRemainingWork(this, newRemainingWork, remainingWork, false); // need to 0 out an time between stop and the intervals start, if any if (fieldContext.getStart() > stop) { FieldContext empty = new FieldContext(); empty.setInterval(new ImmutableInterval(stop == 0 ? getStart() : stop, fieldContext.getStart())); setWork(0L, empty); } if (workValue > 0) { if (fieldContext.getEnd() > stop) // if will set stop later because new work is after stop setStop(fieldContext.getEnd()); else setStop(stop); // use current stop - for case when setting actuals before current stop } else { if (fieldContext.getStart() < stop && fieldContext.getEnd() >= stop) {//if overlapping current stop setStop(fieldContext.getStart()); } else { if (stop != 0) setStop(stop); // make sure stop stays where it is } } // if (!isComplete) // ((NormalTask)getTask()).getSchedulingRule().adjustRemainingWork(this, newRemainingWork, remainingWork, false); // adjust remaining work long remainingWork = oldWork - getActualWork(null); // adjustRemainingWork( ((double)remainingWork) / currentRemainingWork, true); if (!isComplete) { ((NormalTask) getTask()).getSchedulingRule().adjustRemainingWork(this, remainingWork, false); } getTask().recalculateLater(this); // task needs to be recalculated } else { if (workValue == 0) { setPercentComplete(0); return; } long date = ReverseQuery.getDateAtValue(WORK, this, workValue, false); setStop(date); } } public boolean isInitialized() { return getProject().isInitialized(); } /** * Allow setting of working duration. MSProject displays working duration (excludes non-work intervals) except when * task type is fixed duration, in which case it shows duration with non-work intervals * @param newWorkingDuration */ public void adjustWorkingDuration(long newWorkingDuration) { newDetail().adjustWorkingDuration(newWorkingDuration); } public WorkCalendar getEffectiveWorkCalendar() { return detail.getEffectiveWorkCalendar(); } /** * @return Returns the task. */ public Task getTask() { return detail.getTask(); } public String getTaskName() { return getTask().getName(); } public String getTaskId() { return "" + getTask().getId(); } public String getResourceName() { return getResource().getName(); } public String getResourceId() { return "" + getResource().getId(); } public long getStart() { return detail.getStart(); } public long getFinish() { return detail.getFinish(); } /** * Offset a date by its duration or remaining duration * @param date * @param ahead - true if we want to add duraiton, false otherwise * @param remainingOnly - true if use remaining duration, otherwise all duration * @param useSooner - Used for end/beginning of day issues * @return new date */ private long computeStart(long startDate, long dependencyDate) { long delay = this.calcTotalDelay(); long s = startDate; if (getPercentComplete() == 0) { // if no completion, use task dependency date if needed if (dependencyDate > s) s = dependencyDate; } if (delay > 0) s = getEffectiveWorkCalendar().add(s, delay, true); //TODO check if above should use task calendar or assignment calendar return s; } public long calcOffsetFrom(long startDate, long dependencyDate, boolean ahead, boolean remainingOnly, boolean useSooner) { long start; if (ahead) start = computeStart(startDate, dependencyDate); else start = startDate; if (getPercentComplete() > 0) start = getEffectiveWorkCalendar().add(start, getActualDuration(), useSooner); long duration = remainingOnly ? detail.getRemainingDuration() : detail.getDuration();// + this.detail.getSplitDuration(); //TODO integrate split - still needed? long amount = (ahead ? duration : -duration); return getEffectiveWorkCalendar().add(start, amount, useSooner); } boolean isInRange(long start, long finish) { long s = getStart(); return (finish > s && start < getEffectiveWorkCalendar().add(s, detail.getDuration(), true)); } /** * @return Returns the resource. */ public Resource getResource() { return detail.getResource(); } public Closure forResource(Closure visitor) { return new ObjectVisitor(visitor) { protected final Object getObject(Object caller) { return ((Assignment) caller).getResource(); } }; } public Closure forTask(Closure visitor) { return new ObjectVisitor(visitor) { protected final Object getObject(Object caller) { return ((Assignment) caller).getTask(); } }; } /** * @return */ public long calcWork() { if (!isLabor()) return 0; return detail.calcWork(); } /** * @return */ public long calcTotalDelay() { return detail.calcTotalDelay(); } /** * @return Returns the detail. */ public AssignmentDetail getDetail() { return detail; } /** * Gets an instance of a generator that acts on the cost contour * @return instance of generator */ public ContourBucketIntervalGenerator contourGeneratorInstance(Object type) { return contourGeneratorInstance(type, getStart()); } /** * Gets an instance of a generator that acts on the cost contour * @return instance of generator */ public ContourBucketIntervalGenerator contourGeneratorInstance(Object type, long start) { return ContourBucketIntervalGenerator.getInstance(this, type);//getEffectiveWorkCalendar(), detail.getContour(type), detail.getDurationMillis(), getStart()); //TODO actual cost treatment if entered manually } /** * Fills in a SelectFrom clause with "select work from contour" * @param clause to fill in * @return work field functor */ AssignmentFieldFunctor work(SelectFrom clause) { ContourBucketIntervalGenerator contour = contourGeneratorInstance(WORK); WorkFunctor workF = WorkFunctor.getInstance(this, contour.getWorkCalendar(), contour, detail.calcOvertimeUnits()); clause.select(workF).from(contour); return workF; } // public AssignmentFieldFunctor work(SelectFrom clause, AssignmentFieldFunctor using) { // ContourBucketIntervalGenerator contour = using.getContourBucketIntervalGenerator(); // WorkFunctor workF = WorkFunctor.getInstance(this, contour.getWorkCalendar(), contour, detail.calcOvertimeUnits()); // clause.select(workF); // return workF; // } private AssignmentFieldFunctor percentAlloc(SelectFrom clause, boolean threshold) { ContourBucketIntervalGenerator contour = contourGeneratorInstance(WORK); PercentAllocFunctor functor = PercentAllocFunctor.getInstance(this, contour.getWorkCalendar(), contour, threshold); clause.select(functor).from(contour); return functor; } private AssignmentFieldFunctor fixedCost(SelectFrom clause) { ContourBucketIntervalGenerator contour = contourGeneratorInstance(COST); FixedCostFunctor functor = FixedCostFunctor.getInstance(this); clause.select(functor).from(contour); return functor; } private AssignmentFieldFunctor availability(SelectFrom clause) { //TODO this is untested, as histogram is currently broken 8/12/04 hk ResourceAvailabilityFunctor functor = ResourceAvailabilityFunctor.getInstance(this); CollectionIntervalGenerator availability = CollectionIntervalGenerator .getInstance(((ResourceImpl) detail.getResource()).getAvailabilityTable().getList()); clause.select(functor).from(availability); //use range? return functor; } /** This version does not depend on the assignment * * @param clause * @param resource * @return */ private static AssignmentFieldFunctor resourceAvailability(SelectFrom clause, Resource resource) { //TODO this is untested, as histogram is currently broken 8/12/04 hk ResourceAvailabilityFunctor functor = ResourceAvailabilityFunctor.getInstance(resource); CollectionIntervalGenerator availability = CollectionIntervalGenerator .getInstance(resource.getAvailabilityTable().getList()); clause.select(functor).from(availability); //use range? return functor; } // PercentAllocFunctor(Assignment assignment, WorkCalendar workCalendar, ContourBucketIntervalGenerator contourBucketIntervalGenerator) { /** * Convenience function to fill in the SelectFrom clause and return the cost functor. * One particularity of this function is that if the cost has been saved in the cost contour, then the cost contour is used. * This is the usual case in baselines. * If the cost contour is not personal, then the cost is calculated from costRate and work; however, the resource accrual settings * determine how the data is grouped: If accrual is not PRORATED, then the entire cost is calculated, and the result is then put * in a special ConstantCost functor which will return the value if and only if the current group by range encloses the value. * @param clause: SelectFrom clause to populate * @return The functor to use to calculate cost */ private AssignmentFieldFunctor cost(SelectFrom clause, boolean all) { if (detail.getCostContour().isPersonal()) { // in the case where a cost contour has already been saved, use it ContourBucketIntervalGenerator costContour = contourGeneratorInstance(COST); WorkFunctor workF = WorkFunctor.getInstance(this, getEffectiveWorkCalendar(), costContour, detail.calcOvertimeUnits()); // note that is is a work contour clause.select(workF).from(costContour); return workF; } else { boolean prorated = isProratedCost(); // if prorated, or if calculating a total, then treat as prorated if (all || prorated) { ContourBucketIntervalGenerator workContour = contourGeneratorInstance(WORK); CollectionIntervalGenerator costRate = CollectionIntervalGenerator .getInstance(detail.getResource().getCostRateTable(detail.getCostRateIndex()).getList()); clause.from(costRate).from(workContour); // Note that the getStart() parameter implies cost per use is applied at start CostFunctor costF = CostFunctor.getInstance(this, getEffectiveWorkCalendar(), workContour, detail.calcOvertimeUnits(), costRate, getStart(), prorated); clause.select(costF); return costF; } else { // accrue start or end long triggerDate = (detail.getResource().getAccrueAt() == Accrual.START) ? getStart() : getFinish();// use start or end AssignmentFieldFunctor constantCost = ValueAtInstant.getInstance(triggerDate, calcAll(COST)); clause.select(constantCost).from(InstantIntervalGenerator.getInstance(triggerDate)); // just one instant return constantCost; } } } public boolean isProratedCost() { return detail.getResource().getAccrueAt() == Accrual.PRORATED; } public AssignmentFieldFunctor getDataSelect(Object type, SelectFrom clause, boolean all) { if (type == PERCENT_ALLOC) { return percentAlloc(clause, false); } else if (type == AVAILABILITY) { return availability(clause); } else if (type == COST) { return cost(clause, all); } else if (type == OVERALLOCATED) { return work(clause); } else if (type == WORK || type == THIS_PROJECT) { return work(clause); } else if (type == ACTUAL_WORK) { clause.whereInRange(detail.getStart(), getStop()); return work(clause); } else if (type == REMAINING_WORK) { clause.whereInRange(getResume(), detail.getFinish()); return work(clause); } else if (type == ACTUAL_COST) { clause.whereInRange(detail.getStart(), getStop()); return cost(clause, all); } else if (type == FIXED_COST) { clause.whereInRange(detail.getStart(), getEnd()); return fixedCost(clause); } else if (type == ACTUAL_FIXED_COST) { clause.whereInRange(detail.getStart(), getStop()); return fixedCost(clause); } else if (type == REMAINING_COST) { clause.whereInRange(getResume(), detail.getFinish()); return cost(clause, all); } else if (type == BASELINE_COST) { return baselineData(COST, clause); } else if (type == BASELINE_WORK) { return baselineData(WORK, clause); } else if (type == ACWP) { clause.whereInRange(detail.effectiveBaselineStart(), getCompletedOrStatusDate()); return cost(clause, all); } else if (type == BCWP) { clause.whereInRange(detail.getStart(), getStatusDate()); AssignmentFieldFunctor costF = cost(clause, all); costF.setMultiplier(efficiency()); return costF; } else if (type == BCWS) { clause.whereInRange(detail.effectiveBaselineStart(), getStatusDate()); return baselineData(COST, clause); } else if (type instanceof Field) { // treat all baselines Field field = (Field) type; if (field.isIndexed()) { Integer index = new Integer(field.getIndex()); if (field.isWork()) return baselineData(WORK, clause, index); else return baselineData(COST, clause, index); } } return null; } public void calcDataBetween(Object type, long start, long end) { SelectFrom clause = SelectFrom.getInstance().whereInRange(start, end); // automatically also adds a generator to limit range AssignmentFieldFunctor dataFunctor = getDataSelect(type, clause, false); RangeIntervalGenerator dailyInRange = RangeIntervalGenerator.getInstance(start, end, 1000 * 60 * 60 * 24); PrintValueFunctor print = PrintValueFunctor.getInstance(dataFunctor); Query.getInstance().selectFrom(clause).groupBy(dailyInRange).action(print).execute(); } /** * Calculate the total cost * @return */ public double calcAll(Object type) { SelectFrom clause = SelectFrom.getInstance(); AssignmentFieldFunctor dataFunctor = getDataSelect(type, clause, true); Query.getInstance().selectFrom(clause).execute(); return dataFunctor.getValue(); } // public void forEach(Object type, Closure actionVisitor) { // SelectFrom clause = SelectFrom.getInstance(); // AssignmentFieldFunctor dataFunctor = getDataSelect(type,clause,false); // Query.getInstance().selectFrom(clause) // .action(actionVisitor) // .execute(); // } public void buildReverseQuery(ReverseQuery reverseQuery) { SelectFrom clause = SelectFrom.getInstance(); reverseQuery.addField(getDataSelect(reverseQuery.getType(), clause, false)); reverseQuery.addGroupBy(IntervalGeneratorSet.extractUnshared(clause.getFromIntervalGenerators())); reverseQuery.addSelectFrom(clause); } /** * calls back on for all "gantt bar" intervals having matching rates. Matching is determined by a comparator. * @param visitor : callback * @param mergeWorking : if true, then matching occurs if the periods hava non-zero work, otherwise the work * must be an exact match. */ public void forEachWorkingInterval(Closure visitor, boolean mergeWorking, WorkCalendar workCalendar) { Comparator comparator = (mergeWorking ? null : WorkComparator.getInstance()); // if a value of null is used , then the bars will be grouped based on time only Merge merge = Merge.getInstance(visitor, comparator); Query.getInstance().groupBy(contourGeneratorInstance(WORK)).action(merge).execute(); } private transient static BarClosure barClosureInstance = new BarClosure(); public void consumeIntervals(IntervalConsumer consumer) { barClosureInstance.initialize(consumer, this); boolean inProgress = getPercentComplete() > 0.0D; MutableInterval bounds = null; if (inProgress) { bounds = new MutableInterval(getStart(), getStop()); barClosureInstance.setBounds(bounds); } forEachWorkingInterval(barClosureInstance, true, getEffectiveWorkCalendar()); if (inProgress) { // barClosureInstance.initCount(); bounds.setStart(bounds.getEnd()); // shift for second half bounds.setEnd(getEnd()); forEachWorkingInterval(barClosureInstance, true, getEffectiveWorkCalendar()); } barClosureInstance.setBounds(null); } public void moveInterval(Object eventSource, long start, long end, ScheduleInterval oldInterval, boolean isChild) { long startShiftDuration = getEffectiveWorkCalendar().compare(start, oldInterval.getStart(), false); long endShiftDuration = getEffectiveWorkCalendar().compare(end, oldInterval.getEnd(), false); boolean shifting = startShiftDuration != 0L && endShiftDuration != 0L; long stop = getStop(); // Store old completion if (shifting) { shift(oldInterval.getStart(), oldInterval.getEnd(), startShiftDuration); } else { if (endShiftDuration != 0) extend(oldInterval.getStart(), oldInterval.getEnd(), endShiftDuration); else extendBefore(oldInterval.getStart(), oldInterval.getEnd(), startShiftDuration); } setStop(stop); // put back old completion //Need to update schedule if the assignment bar was moved if (!isChild) { getTask().updateCachedDuration(); getTask().recalculate(eventSource); } // //Undo // UndoableEditSupport undoableEditSupport=getProject().getUndoController().getEditSupport(); // if (undoableEditSupport!=null&&!(eventSource instanceof UndoableEdit)){ // undoableEditSupport.postEdit(new ScheduleEdit(this,new ScheduleInterval(start,end),oldInterval,isChild,eventSource)); // } } /** * This function will calculate the exact date/time when the value is achieved * @param type * @param value * @return */ public long getDateAtValue(Object type, double value) { SelectFrom clause = SelectFrom.getInstance(); AssignmentFieldFunctor dataFunctor = (type == COST) ? cost(clause, true) : work(clause); DateAtValueFunctor dateAtValue = DateAtValueFunctor.getInstance(value, AssignmentFieldClosureCollection.getInstance(dataFunctor)); clause.select(dateAtValue); // override existing select Query.getInstance().selectFrom(clause).execute(); return dateAtValue.getDate(); } public long getDateAtWorkFraction(double workFraction) { // System.out.println("all work is " + calcAll(WORK) / (1000*60*60*8)); return getDateAtValue(WORK, calcAll(WORK) * workFraction); } private AssignmentFieldFunctor baselineData(Object type, SelectFrom baselineSelectFrom) { Assignment baselineAssignment = detail.getBaselineAssignment(); AssignmentFieldFunctor baselineFunctor; if (baselineAssignment == null) { baselineFunctor = ZeroFunctor.getInstance(); baselineSelectFrom.select(baselineFunctor).from(RangeIntervalGenerator.empty()); } else { baselineFunctor = baselineAssignment.getDataSelect(type, baselineSelectFrom, false); } return baselineFunctor; } public Assignment getBaselineAssignment(Object baseline, boolean createIfDoesntExist) { return detail.getBaselineAssignment(baseline, createIfDoesntExist); } private AssignmentFieldFunctor baselineData(Object type, SelectFrom baselineSelectFrom, Object baseline) { Assignment baselineAssignment = detail.getBaselineAssignment(baseline, false); AssignmentFieldFunctor baselineFunctor; if (baselineAssignment == null) { baselineFunctor = ZeroFunctor.getInstance(); baselineSelectFrom.select(baselineFunctor).from(RangeIntervalGenerator.empty()); } else { baselineFunctor = baselineAssignment.getDataSelect(type, baselineSelectFrom, false); } return baselineFunctor; } private long getStatusDate() { return getProject().getStatusDate(); } private long getCompletedOrStatusDate() { return Math.min(getStatusDate(), detail.getStop()); } public double getCost() { return calcAll(COST); } /** * Set the total delay for the assignment. Priority is given to changing the assignment delay over the * leveling delay. * @param newDelay */ void setTotalDelay(long newDelay) { /* * DDDDDDDLLLLLL * NNNNNNNNNN */ // long delay = getDelay(); // long levelingDelay = getLevelingDelay(); // long oldTotalDelay = calcTotalDelay(); // if (newDelay == oldTotalDelay) // return; // // if (newDelay <= delay) { // delay = newDelay; // levelingDelay = 0; // } // else { // delay = 0; // levelingDelay = // } // if (newDelay < oldTotalDelay) { // delay -= newDelay; // if (delay < 0) { // levelingDelay += delay; // delay = 0; // } // } else { // delay += (newDelay - oldTotalDelay); // } // setDelay(delay); // setLevelingDelay(levelingDelay); setDelay(newDelay); setLevelingDelay(0); } /** * This treats just a single interval to merge in * @param type - WORK or COST. can also be a time distributed field * @param start - start of interval * @param end - end of interval * @param value - value of interval */ public void setInterval(Object type, long start, long end, double value) { //TODO treat cost values - they are currently ignored if (type == ACTUAL_WORK || type == WORK || type == REMAINING_WORK) { if (value != 0 && !verifyBounds(start, end)) return; if (Environment.isImporting()) { WorkCalendar cal = getEffectiveWorkCalendar(); start = cal.adjustInsideCalendar(start, false); end = cal.adjustInsideCalendar(end, true); } setWorkInterval(start, end, value); if (type == ACTUAL_WORK && end > getStop() && value > 0.0D) // bug fix - actuals were lost setStop(end); } else { if (TimeDistributedHelper.isWork(type)) { Object baseline = TimeDistributedHelper.baselineForData(type); //System.out.println("baseline " + baseline + " " + new Date(start) + " " + new Date(end) + " " + value); Assignment baselineAssignment = getBaselineAssignment(baseline, true); // get or create baseline assignment // update the task schedule too TaskSchedule schedule = baselineAssignment.getTaskScheduleOfAssignment(); long baselineStart = schedule.getStart(); long baselineFinish = schedule.getFinish(); if (baselineStart == 0 || baselineStart > start) schedule.setStart(start); if (baselineFinish == 0 || baselineFinish < end) schedule.setEnd(end); baselineAssignment.setWorkInterval(start, end, value); } } } TaskSchedule getTaskScheduleOfAssignment() { return detail.getTaskSchedule(); } public boolean verifyBounds(long start, long end) { if (Environment.isImporting()) // always accept time distributed edits when importing return true; if (getProject().getStart() > start) // if setting before project start return Alert.okCancel(Messages.getString("Message.allowDistrbutedStartBeforeProjectStart")); else if (start < getTask().getStart()) return Alert.okCancel(Messages.getString("Message.allowDistrbutedStartBeforeTaskStart")); else return true; } /** * This treats just a single interval to merge in * @param type - WORK or COST * @param start - start of interval * @param end - end of interval * @param value - value of interval (an wmount of work (duration), not units) */ private void setWorkInterval(long start, long end, double value) { moveDelayToContour(); long assignmentStart = getStart(); // the start including any delay WorkCalendar cal = getEffectiveWorkCalendar(); if (end > getFinish()) { // add end if necessary if (value == 0) { this.setEnd(start); return; // don't extend if value is 0 } makeContourPersonal(); long extraDuration = cal.compare(end, getFinish(), false); setDurationMillis(getDurationMillis() + extraDuration); AbstractContour contour = PersonalContour.addEmptyBucket(getWorkContour(), extraDuration, true); newDetail().setWorkContour(contour); // adjust task end too if (end > getTask().getEnd()) getTask().setEnd(end); } else if (start < assignmentStart) { // if before assignment start // if (value == 0) // return; // don't extend if value is 0 long taskStart = getTask().getStart(); if (start < taskStart) { long shiftAmount = cal.compare(taskStart, start, false); setDurationMillis(getDurationMillis() + shiftAmount); if (!getWorkContour().isPersonal()) makeContourPersonal(); newDetail().setWorkContour(PersonalContour.addEmptyBucket(getWorkContour(), shiftAmount, false)); // add empty space before getTask().setScheduleConstraintAndUpdate(ConstraintType.SNLT, start); // this can set start before project duration. taskStart = getTask().getStart(); } assignmentStart = taskStart; } long startDuration = cal.compare(start, assignmentStart, false); long endDuration = cal.compare(end, assignmentStart, false); if (startDuration == endDuration) return; if (!getWorkContour().isPersonal()) makeContourPersonal(); value /= (endDuration - startDuration); PersonalContour newContour = ((PersonalContour) getWorkContour()).setInterval(startDuration, endDuration, value); extractDelayFromContour(newContour); // move delay back into delay field from contour newDetail().setWorkContour(newContour); newDetail().recalculateDuration(); getTask().updateCachedDuration(); } /** * Move remaining work to the date given. It will either be moved later or sooner. Also, if at the date, there * is a gap in the work, the gap is reduced so that the work begins on the date * @param date */ public void moveRemainingToDate(long date) { long resume = getResume(); long end = getEnd(); long shiftDuration = getEffectiveWorkCalendar().compare(date, resume, false); // get shift time shift(resume, end, shiftDuration); long duration = getEffectiveWorkCalendar().compare(date, getStart(), false); // get offset from start if (duration > 0) newDetail().removeEmptyBucketAtDuration(duration); } public void shift(long start, long end, long shiftDuration) { //get bounds. WorkCalendar cal = getEffectiveWorkCalendar(); if (getTask().inProgress() && cal.compare(getStop(), start, false) > 0) { // if stop greater than start, can't change it // System.out.println("Not shifting - stop = " + new Date(getStop()) + "start " + new Date(start)); return; } long taskStart = getTask().getStart(); start = Math.max(start, getStop()); //only shift remaining start = Math.max(start, taskStart); // dont shift before task start of course long startOffset = cal.compare(start, taskStart, false); long endOffset = cal.compare(end, taskStart, false); if (getResume() != 0 && start >= getResume()) { long splitDuration = detail.getSplitDuration(); startOffset -= splitDuration; endOffset -= splitDuration; } if (startOffset >= endOffset) // this prevents moving a completed interval return; boolean firstBar = (cal.compare(getStart(), start, false) == 0); MutableInterval range = getRangeThatIntervalCanBeMoved(start, startOffset, endOffset); if (firstBar) range.setStart(range.getStart() - calcTotalDelay()); if (shiftDuration > 0) shiftDuration = Math.min(shiftDuration, range.getEnd() - endOffset); // don't allow to shift more than possible else { shiftDuration = Math.max(shiftDuration, range.getStart() /*+ (firstBar ? -calcTotalDelay() : 0)*/ - startOffset); // don't allow to shift more than possible } if (firstBar) { setTotalDelay(calcTotalDelay() + shiftDuration); } else { newDetail().shift(startOffset, endOffset, shiftDuration); } } private MutableInterval getRangeThatIntervalCanBeMoved(long start, long startOffset, long endOffset) { MutableInterval range = getRangeThatIntervalCanBeMoved(startOffset, endOffset); if (getEffectiveWorkCalendar().compare(getStart(), start, false) == 0) range.setStart(range.getStart() - calcTotalDelay()); return range; } public MutableInterval getRangeThatIntervalCanBeMoved(long startOffset, long endOffset) { return detail.getRangeThatIntervalCanBeMoved(startOffset, endOffset); } public void extend(long start, long end, long extendDuration) { if (end < getStop()) return; WorkCalendar cal = getEffectiveWorkCalendar(); long startOffset = cal.compare(start, getStart(), false); long endOffset = cal.compare(end, getStart(), false); // if (start >= getResume()) { // long splitDuration = detail.getSplitDuration(); // startOffset -= splitDuration; // endOffset -= splitDuration; // } Interval range = getRangeThatIntervalCanBeMoved(start, startOffset, endOffset); if (extendDuration > 0) extendDuration = Math.min(extendDuration, range.getEnd() - endOffset); // don't allow to shift more than possible else extendDuration = Math.max(extendDuration, startOffset - endOffset); newDetail().extend(endOffset, extendDuration); } /* (non-Javadoc) * @see com.projity.pm.scheduling.Schedule#split(java.lang.Object, long, long) */ public void split(Object eventSource, long from, long to) { from = Math.max(from, getResume()); if (from >= to) return; long duration = getEffectiveWorkCalendar().compare(to, from, false); // calculate shift duration shift(from, getEnd(), duration); // shift the remaining contour to the right by the duration } public void extendBefore(long start, long end, long extendDuration) { if (start < getStop()) return; WorkCalendar cal = getEffectiveWorkCalendar(); boolean firstBar = (cal.compare(getStart(), start, false) == 0); long startOffset = cal.compare(start, getStart(), false); long endOffset = cal.compare(end, getStart(), false); Interval range = getRangeThatIntervalCanBeMoved(start, startOffset, startOffset); if (extendDuration > 0) extendDuration = Math.min(extendDuration, endOffset - startOffset); else extendDuration = Math.max(extendDuration, range.getStart() - startOffset); // don't allow to shift more than possible if (firstBar) setTotalDelay(calcTotalDelay() + extendDuration); newDetail().extendBefore(startOffset, extendDuration); } public void addCalendarTime(long start, long end) { newDetail().addCalendarTime(start, end); } /* (non-Javadoc) * @see com.projity.pm.assignment.AssignmentSpecificFields#getWorkContourId() */ public int getWorkContourType() { return getWorkContour().getType(); } /* (non-Javadoc) * @see com.projity.pm.assignment.AssignmentSpecificFields#setWorkContourId(int) */ public void setWorkContourType(int workContourType) { newDetail().setWorkContour(ContourFactory.getInstance(workContourType)); // TODO need to actually transform contour correctly when changing } public final double getRemainingUnits() { if (!isLabor()) return 1.0D; long duration = getRemainingDuration(); if (duration == 0.0) return getWorkContour().getLastBucketUnits(); // return 1.0D; // degeneratate case long work = getRemainingWork(); if (work == 0) // degenerate case with no work yet return 1.0; return ((double) work) / duration; } public final double getRemainingLaborUnits() { if (isLabor()) return getRemainingUnits(); return 0.0D; } /* (non-Javadoc) * @see com.projity.util.Association#getLeft() */ public Object getLeft() { return getTask(); } /* (non-Javadoc) * @see com.projity.util.Association#getRight() */ public Object getRight() { return getResource(); } /* (non-Javadoc) * @see com.projity.util.Association#testValid() */ public void testValid(boolean allowDuplicate) throws InvalidAssociationException { } /* (non-Javadoc) * @see com.projity.util.Association#copyPrincipalFieldsFrom(com.projity.util.Association) */ public void copyPrincipalFieldsFrom(Association from) { Assignment fromAssignment = (Assignment) from; double units = fromAssignment.getUnits(); if (fromAssignment.isLabor()) { adjustRemainingUnits(fromAssignment.getUnits(), 0, true, false); detail.setUnits(units); } else { detail.rate = fromAssignment.detail.getRate(); detail.setDuration(getDuration()); // reset duration } getTask().updateCachedDuration(); // needed for checking if milestone } public void forceUnits(double units) { newDetail().setUnits(units); } public void doAddService(Object eventSource) { AssignmentService.getInstance().connect(this, eventSource); } public void doRemoveService(Object eventSource) { AssignmentService.getInstance().remove(this, eventSource, true); } /* (non-Javadoc) * @see com.projity.association.Association#doUpdateService(java.lang.Object) */ public void doUpdateService(Object eventSource) { getUnitsField().fireEvent(this, this, null); // need to update } public boolean isDefault() { return getTask() == NormalTask.getUnassignedInstance() || getResource() == ResourceImpl.getUnassignedInstance(); } public boolean isReadOnlyUnits(FieldContext fieldContext) { return false; } //Costs and earned value public double acwp(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_DOUBLE; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(Math.max(start, detail.effectiveBaselineStart()), Math.min(end, getCompletedOrStatusDate())); query.selectFrom(clause).action(cost(clause, false)).execute(); return ((DoubleValue) query.getActionVisitor()).getValue(); } public double bcws(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_DOUBLE; if (AdvancedOption.getInstance().isEarnedValueFieldsCumulative()) start = getStart(); // start from the beginning of the task and ignore the range start Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(Math.max(start, detail.effectiveBaselineStart()), Math.min(end, getStatusDate())); query.selectFrom(clause).action(baselineData(COST, clause)).execute(); return ((DoubleValue) query.getActionVisitor()).getValue(); } public double efficiency() { Assignment baselineAssignment = detail.getBaselineAssignment(); if (baselineAssignment == null) return 0.0D; long baselineWork = baselineAssignment.work(); if (baselineWork == 0) return 0.0; long work = work(); if (work == 0.0D) return 1.0D; return ((double) baselineWork) / work; } //[(Actual % of completion / Expected % of completion) of an activity for a given period] * Actual cost of activity public double bcwp(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_DOUBLE; end = Math.min(end, getStatusDate()); if (end == 0) return 0.0D; if (AdvancedOption.getInstance().isEarnedValueFieldsCumulative()) start = getStart(); // start from the beginning of the task and ignore the range start double cost = actualCost(start, end); if (cost == 0) return 0; return efficiency() * cost; // // Query query = Query.getInstance(); // long boundaryStart = detail.getStart(); // always use assignment start and never start // long boundaryEnd = Math.min(getStatusDate(),baselineAssignment.getEffectiveWorkCalendar().add(boundaryStart, (long) (baselineAssignment.getDuration() * getPercentComplete()),false)); // SelectFrom clause = SelectFrom.getInstance().whereInRange(boundaryStart,Math.min(end,boundaryEnd)); // query.selectFrom(clause) // .action(baselineData(COST,clause)) // .execute(); // return ((DoubleValue)query.getActionVisitor()).getValue(); } public double bac(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_DOUBLE; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(start, end); query.selectFrom(clause).action(baselineData(COST, clause)).execute(); return ((DoubleValue) query.getActionVisitor()).getValue(); } public double cost(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_DOUBLE; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(start, end); query.selectFrom(clause).action(cost(clause, false)).execute(); return ((DoubleValue) query.getActionVisitor()).getValue(); } public long work(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_LONG; // if (!isLabor()) // TODO this right? // return 0; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(start, end); query.selectFrom(clause).action(work(clause)).execute(); return (long) ((DoubleValue) query.getActionVisitor()).getValue(); } public double actualCost(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_DOUBLE; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(Math.max(start, detail.getStart()), Math.min(end, getStop())); query.selectFrom(clause).action(cost(clause, false)).execute(); return ((DoubleValue) query.getActionVisitor()).getValue(); } public long actualWork(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_LONG; if (!isLabor()) // TODO this right? return 0; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(Math.max(start, detail.getStart()), Math.min(end, getStop())); query.selectFrom(clause).action(work(clause)).execute(); return (long) ((DoubleValue) query.getActionVisitor()).getValue(); } public long remainingWork(long start, long end) { if (!isInRange(start, end)) return NO_VALUE_LONG; if (!isLabor()) // TODO this right? return 0; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(Math.max(start, detail.getStop()), Math.min(end, getEnd())); query.selectFrom(clause).action(work(clause)).execute(); return (long) ((DoubleValue) query.getActionVisitor()).getValue(); } public double baselineCost(long start, long end) { // if (!isInRange(start,end)) // return NO_VALUE_DOUBLE; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(start, end); query.selectFrom(clause).action(baselineData(COST, clause)).execute(); return ((DoubleValue) query.getActionVisitor()).getValue(); } public long baselineWork(long start, long end) { // if (!isInRange(start,end)) // return NO_VALUE_LONG; if (!isLabor()) // TODO this right? return 0; Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance().whereInRange(start, end); query.selectFrom(clause).action(baselineData(WORK, clause)).execute(); return (long) ((DoubleValue) query.getActionVisitor()).getValue(); } private boolean isFieldHidden(FieldContext fieldContext) { return fieldContext != null && !isInRange(fieldContext.getStart(), fieldContext.getEnd()); } private boolean isEarnedValueFieldHidden(FieldContext fieldContext) { if (isFieldHidden(fieldContext)) return true; return getStatusDate() < fieldContext.getStart(); } private boolean isBaselineFieldHidden(int numBaseline, FieldContext fieldContext) { Assignment baselineAssignment = getBaselineAssignment(new Integer(numBaseline), false); if (baselineAssignment == null) return true; if (fieldContext == null) // the baseline exists, but no time range return false; return (fieldContext.getStart() >= baselineAssignment.getFinish() || fieldContext.getEnd() <= baselineAssignment.getStart()); } /*************************************************************************************** * Time Distributed Fields **************************************************************************************/ public boolean fieldHideCost(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideWork(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideActualCost(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideActualWork(FieldContext fieldContext) { return fieldHideWork(fieldContext); } public boolean fieldHideBaselineCost(int numBaseline, FieldContext fieldContext) { return isBaselineFieldHidden(numBaseline, fieldContext); } public boolean fieldHideBaselineWork(int numBaseline, FieldContext fieldContext) { return isBaselineFieldHidden(numBaseline, fieldContext); } public boolean fieldHideAcwp(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideBac(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideBcwp(FieldContext fieldContext) { return isEarnedValueFieldHidden(fieldContext); } public boolean fieldHideBcws(FieldContext fieldContext) { return isEarnedValueFieldHidden(fieldContext); } public boolean fieldHideCv(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideSv(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideEac(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideVac(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideCpi(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideSpi(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideCvPercent(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideSvPercent(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public boolean fieldHideTcpi(FieldContext fieldContext) { return isFieldHidden(fieldContext); } public double getCost(FieldContext fieldContext) { return cost(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public long work() { return work(FieldContext.defaultStart, FieldContext.defaultEnd); } public long getWork(FieldContext fieldContext) { long w = work(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); if (!isLabor()) { // System.out.println("work before setting non temporal" + DurationFormat.format(w)); w = Duration.setAsNonTemporal(w); } return w; } public double getActualCost(FieldContext fieldContext) { return actualCost(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public long getActualWork(FieldContext fieldContext) { return actualWork(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public long getRemainingWork(FieldContext fieldContext) { return remainingWork(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public long getRemainingWork() { return getRemainingWork(null); } /* (non-Javadoc) * @see com.projity.pm.assignment.TimeDistributedFields#getBaselineCost(int, com.projity.field.FieldContext) */ public double getBaselineCost(int numBaseline, FieldContext fieldContext) { return baselineCost(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } /* (non-Javadoc) * @see com.projity.pm.assignment.TimeDistributedFields#getBaselineWork(int, com.projity.field.FieldContext) */ public long getBaselineWork(int numBaseline, FieldContext fieldContext) { return baselineWork(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } /*************************************************************************************** * Earned Value Fields **************************************************************************************/ public double getAcwp(FieldContext fieldContext) { return acwp(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getBac(FieldContext fieldContext) { return bac(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getBcwp(FieldContext fieldContext) { return bcwp(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getBcws(FieldContext fieldContext) { return bcws(FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getCv(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().cv(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getSv(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().sv(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getEac(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().eac(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getVac(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().vac(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getCpi(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().cpi(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getSpi(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().spi(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getCsi(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().csi(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getCvPercent(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().cvPercent(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getSvPercent(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().svPercent(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } public double getTcpi(FieldContext fieldContext) { return EarnedValueCalculator.getInstance().tcpi(this, FieldContext.start(fieldContext), FieldContext.end(fieldContext)); } /** * @return */ public Date getCreated() { return hasKey.getCreated(); } /** * @return */ public long getId() { return hasKey.getId(); } /** * @return */ public String getName() { return "" + getLeft() + " " + getRight(); } /** * @param context * @return */ public String getName(FieldContext context) { if (context == null) return "???"; //fix if (context.isLeftAssociation()) return getRight().toString(); else return getLeft().toString(); } /** * @return */ public long getUniqueId() { return hasKey.getUniqueId(); } // public void setNew(boolean isNew) { // hasKey.setNew(isNew); // } /** * @param created */ public void setCreated(Date created) { hasKey.setCreated(created); } /** * @param id */ public void setId(long id) { hasKey.setId(id); } /** * @param name */ public void setName(String name) { hasKey.setName(name); } /** * @param id */ public void setUniqueId(long id) { hasKey.setUniqueId(id); } public Document getDocument() { return getProject(); } public Document getDocument(boolean leftObject) { return (leftObject) ? getTask().getDocument() : getResource().getDocument(); } public Query workQuery() { Query query = Query.getInstance(); SelectFrom clause = SelectFrom.getInstance(); query.selectFrom(clause).action(work(clause)); return query; } public void calcDataBetween(Object type, HasStartAndEnd generator, CalculatedValues values) { SelectFrom clause = SelectFrom.getInstance(); AssignmentFieldFunctor dataFunctor = getDataSelect(type, clause, false); calcDataBetween(dataFunctor, clause, generator, values); } public static void calcResourceAvailabilityBetween(Resource resource, HasStartAndEnd generator, CalculatedValues values) { SelectFrom clause = SelectFrom.getInstance(); AssignmentFieldFunctor dataFunctor = resourceAvailability(clause, resource); calcDataBetween(dataFunctor, clause, generator, values); } public static void calcDataBetween(AssignmentFieldFunctor dataFunctor, SelectFrom clause, HasStartAndEnd generator, CalculatedValues values) { if (generator != null) clause.whereInRange(generator.getStart(), generator.getEnd()); // automatically also adds a generator to limit range CalculatedValuesFunctor visitor = CalculatedValuesFunctor.getInstance(dataFunctor, values, (TimeIteratorGenerator) generator); Query query = Query.getInstance(); query.selectFrom(clause); if (generator != null && generator instanceof TimeIteratorGenerator) { query.groupBy((TimeIteratorGenerator) generator).action(visitor); } else { clause.select(visitor); // replaces other one } query.execute(); } public long getResourceAvailability() { return detail.getResourceAvailability(); } public Collection childrenToRollup() { return null; } /* (non-Javadoc) * @see com.projity.pm.assignment.Allocation#getMostLoadedAssignmentUnits() */ public double getMostLoadedAssignmentUnits() { return getUnits(); } /** * @return */ public void makeContourPersonal() { // if (getWorkContour().isPersonal()) // return; Object type = WORK; ContourBucketIntervalGenerator contourGenerator = contourGeneratorInstance(type); //contour PersonalContourMaker contourBuilder = PersonalContourMaker.getInstance(this, contourGenerator); Query.getInstance().selectFrom(SelectFrom.getInstance().select(contourBuilder).from(contourGenerator).all()) .execute(); newDetail().setContour(type, contourBuilder.getList()); detail.recalculateDuration(); } /** * Clone the detail and set it * @return cloned assignment detail */ private AssignmentDetail newDetail() { //TODO store off detail for undo //System.out.println("before clone " + new Date(detail.getStop())); detail = (AssignmentDetail) detail.clone(); if (getTask() != null) getTask().setDirty(true); setDirty(true); //System.out.println("after clone " + new Date(detail.getStop())); return detail; } public long getElapsedDuration() { return detail.getElapsedDuration(); } public long getDuration() { return detail.getDuration(); } public double getPercentComplete() { return detail.getPercentComplete(); } public void setPercentComplete(double percentComplete) { newDetail().setPercentComplete(percentComplete); } public long getEnd() { return detail.getEnd(); } public void setEnd(long end) { detail.setEnd(end); } public long getActualStart() { return detail.getActualStart(); } public void setActualStart(long actualStart) { newDetail().setActualStart(actualStart); } public void setRemainingDuration(long remainingDuration) { newDetail().setRemainingDuration(remainingDuration); } public long getActualFinish() { return detail.getActualFinish(); } public void setActualFinish(long actualFinish) { newDetail().setActualFinish(actualFinish); } public long getResume() { return detail.getResume(); } public long getActualDuration() { return detail.getActualDuration(); } public void setActualDuration(long actualDuration) { newDetail().setActualDuration(actualDuration); } public long getRemainingDuration() { return detail.getRemainingDuration(); } public void setResume(long resume) { newDetail().setResume(resume); } public long getStop() { return detail.getStop(); } public void setStop(long stop) { if (stop < getStart()) // make sure in assignment's range stop = getStart(); else if (stop > getEnd()) stop = getEnd(); long currentStop = getStop(); if (currentStop == stop) return; if (stop < currentStop) // if uncompleting newDetail().removeFillerAfter(stop); if (currentStop > 0 && getDependencyStart() > currentStop && getDependencyStart() < stop) {// if setting stop incorporates split due to dependency makeContourPersonal(); } newDetail().setStop(stop); } public void clearDuration() { newDetail().clearDuration(); } public long getDependencyStart() { return detail.getDependencyStart(); } public void setDependencyStart(long dependencyStart) { detail.setDependencyStart(dependencyStart); //TODO is it ok to modify schedule directly? Should be if it is transient } //for gantt bar formula //probably to add in a common interface with task public boolean isNormal() { return false; } public boolean isCritical() { return false; } public boolean isSummary() { return false; } public boolean isMilestone() { return false; } public boolean isAssignment() { return true; } public void setTaskSchedule(TaskSchedule taskSchedule) { newDetail().setTaskSchedule(taskSchedule); } public boolean inProgress() { double percentComplete = getPercentComplete(); return (percentComplete > 0.0D && percentComplete < 1.0D); } public boolean isComplete() { return getPercentComplete() == 1.0D; } public boolean isUnstarted() { return getPercentComplete() == 0.0D; } public boolean isMine() { return getResource().isMe(); } private void writeObject(ObjectOutputStream s) throws IOException { s.defaultWriteObject(); hasKey.serialize(s); } private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { s.defaultReadObject(); hasKey = HasKeyImpl.deserialize(s, this); // barClosureInstance = new BarClosure(); } public Object clone() { try { Assignment a = (Assignment) super.clone(); a.hasKey = new HasKeyImpl(true, a); a.setName(getName()); // barClosureInstance = new BarClosure(); a.detail = (AssignmentDetail) detail.clone(); return a; } catch (CloneNotSupportedException e) { throw new InternalError(); } } public Object cloneWithTask(Task task) { Assignment a = (Assignment) clone(); a.detail.setTask(task); return a; } public Object cloneWithResource(Resource resource) { Assignment a = (Assignment) clone(); a.detail.setResource(resource); return a; } public Object cloneWithResourceAndTask(Resource resource, Task task) { Assignment a = (Assignment) clone(); a.detail.setResource(resource); a.detail.setTask(task); return a; } public void convertToBaselineAssignment(boolean useDefaultCalendar) { detail.convertToBaselineAssignment(useDefaultCalendar); } /** * See if assignment duration is empty * @return */ public boolean hasDuration() { return detail.hasDuration(); } public void setRemainingWork(long remainingWork, FieldContext fieldContext) { setActualWork(getWork(fieldContext) - Duration.millis(remainingWork), fieldContext); } public boolean isReadOnlyWork(FieldContext fieldContext) { if (fieldContext == null) { return isMaterial(); //// material resource assignments cannot have their total work modified } // see if there is some calendar time return !isActiveBetween(fieldContext.getStart(), fieldContext.getEnd()); } public boolean isActiveBetween(long start, long end) { return getEffectiveWorkCalendar().compare(end, start, false) > 0; } public boolean isReadOnlyActualWork(FieldContext fieldContext) { return false; } public boolean isReadOnlyRemainingWork(FieldContext fieldContext) { return isReadOnlyWork(fieldContext); } public double getFixedCost(FieldContext fieldContext) { return 0; } public double getActualFixedCost(FieldContext fieldContext) { return 0; } public boolean fieldHideActualFixedCost(FieldContext fieldContext) { return true; } public double fixedCost(long start, long end) { return ((Task) getTask()).fixedCost(start, end); } public double actualFixedCost(long start, long end) { return ((Task) getTask()).actualFixedCost(start, end); } /* (non-Javadoc) * @see com.projity.pm.assignment.TimeDistributedFields#setFixedCost(double, com.projity.field.FieldContext) */ public void setFixedCost(double fixedCost, FieldContext fieldContext) { } public boolean isReadOnlyFixedCost(FieldContext fieldContext) { return true; } public boolean isLabor() { return getResource().isLabor(); } public boolean isTemporal() { return detail.isTemporal(); } /** * @param timeUnit */ public void setRateUnit(int timeUnit) { detail.setRateUnit(timeUnit); getTask().updateCachedDuration(); // needed for checking if milestone - happens when changing units in dialog } public final Rate getRate() { return detail.getRate(); } private int getTaskSchedulingType() { return ((NormalTask) getTask()).getSchedulingType(); } public String valuesString() { return "Duration=" + DurationFormat.format(getDuration()) + " Work=" + DurationFormat.format(getWork(null)) + " Units=" + getUnits() + " contour=" + getWorkContour().toString(getDuration()); } public final void setRate(Rate rate) { if (rate.isNonTemporal() == getRate().isNonTemporal()) { // normal case. If a material resource is modified from temporal to non (or vice versa), just set the rate double old = getRate().getValue(); if (rate.getValue() == old) // if no change return; long oldRemaining = getRemainingDuration(); newDetail(); double multiplier = rate.getValue() / old; if (getPercentComplete() > 0) makeContourPersonal(); detail.adjustRemainingUnits(rate.getValue()); if (getTaskSchedulingType() != SchedulingType.FIXED_DURATION) detail.adjustRemainingDuration((long) (oldRemaining / multiplier)); } detail.setRate(rate); getTask().updateCachedDuration(); // needed for checking if milestone } // public boolean isNew() { // return hasKey.isNew(); // } public double getRemainingCost(FieldContext fieldContext) { return getCost(fieldContext) - getActualCost(fieldContext); } public void invalidateAssignmentCalendar() { detail.invalidateAssignmentCalendar(); } public boolean isSubproject() { return false; } public boolean isJustModified() { Task task = getTask(); if (task == null) return false; else return task.isJustModified(); } public boolean isInvalidIntersectionCalendar() { return detail.isInvalidIntersectionCalendar(); } private void moveDelayToContour() { // Remove delay and add at beginning of contour long oldDelay = calcTotalDelay(); if (oldDelay == 0) return; makeContourPersonal(); setTotalDelay(0); setDurationMillis(getDurationMillis() + oldDelay); AbstractContour contour = PersonalContour.addEmptyBucket(getWorkContour(), oldDelay, false); // add empty space before newDetail().setWorkContour(contour); } private void extractDelayFromContour(PersonalContour newContour) { long delay = newContour.extractDelay(); // the case when adding 0 units at start if (delay > 0) { newDetail(); detail.setDelay(delay); // detail.recalculateDuration(); } } public void setComplete(boolean complete) { ScheduleUtil.setComplete(this, complete); } public String getProjectName() { return getOwningProject().getName(); } public Project getProject() { return getTask().getProject(); } public Project getOwningProject() { Project p = getTask().getOwningProject(); if (p == null) p = getProject(); return p; } public final int getTimesheetStatus() { Assignment ts = getTimesheetAssignment(); if (ts != null) return ts.timesheetStatus; return timesheetStatus; } public final void setTimesheetStatus(int timesheetStatus) { this.timesheetStatus = timesheetStatus; } public final long getLastTimesheetUpdate() { return lastTimesheetUpdate; } public final void setLastTimesheetUpdate(long lastTimesheetUpdate) { this.lastTimesheetUpdate = lastTimesheetUpdate; ; } public boolean isPendingTimesheetUpdate() { return (getTimesheetStatus() == TimesheetStatus.VALIDATED); } public String getTimesheetStatusName() { return TimesheetHelper.getTimesheetStatusName(getTimesheetStatus()); } public final boolean isTimesheetAssignment() { return timesheetAssignment; } public final void setTimesheetAssignment(boolean timesheetAssignment) { this.timesheetAssignment = timesheetAssignment; } public Assignment getTimesheetAssignment() { if (isTimesheetAssignment()) return this; return detail.getBaselineAssignment(Snapshottable.TIMESHEET, false); } public long getTimesheetStart() { return getCachedStart().getTime(); } public long getTimesheetFinish() { return getCachedEnd().getTime(); } public boolean isTimesheetEditable() { return getTimesheetStatus() != TimesheetStatus.INTEGRATED; } public boolean isTimesheetEntered() { return getTimesheetStatus() != TimesheetStatus.ENTERED; } public boolean isTimesheetValidated() { return getTimesheetStatus() != TimesheetStatus.VALIDATED; } public boolean isTimesheetRejected() { return getTimesheetStatus() != TimesheetStatus.REJECTED; } public boolean copyFieldsFromTimesheet(Collection fieldArray) { Assignment ts = getTimesheetAssignment(); if (ts == null) return false; if (ts.getTimesheetStatus() != TimesheetStatus.VALIDATED) // only incorporate validated data return false; Field.copyData(fieldArray, this, ts); return true; } public boolean applyTimesheet(Collection fieldArray, long timesheetUpdateDate) { boolean updated = copyFieldsFromTimesheet(fieldArray); if (updated) { setTimesheetStatus(TimesheetStatus.INTEGRATED); this.lastTimesheetUpdate = timesheetUpdateDate; Assignment ts = getTimesheetAssignment(); ts.setTimesheetStatus(TimesheetStatus.INTEGRATED); ts.lastTimesheetUpdate = timesheetUpdateDate; } return updated; } public String getTimesheetStatusStyle() { // used for display style in web return TimesheetHelper.getTimesheetStatusStyle(getTimesheetStatus()); } private transient boolean dirty = true; public boolean isDirty() { return dirty; } public void setDirty(boolean dirty) { //System.out.println("Assignment _setDirty("+dirty+"): "+getName()); this.dirty = dirty; if (dirty) { Task task = getTask(); if (task != null) task.setDirty(true); } } public final Date getCachedEnd() { return cachedEnd; } public final void setCachedEnd(Date savedEnd) { this.cachedEnd = savedEnd; } public final Date getCachedStart() { return cachedStart; } public final void setCachedStart(Date savedStart) { this.cachedStart = savedStart; } public final int getWorkflowState() { return workflowState; } public final void setWorkflowState(int workflowState) { this.workflowState = workflowState; } public void setTaskAndResource(Task task, Resource resource) { detail.setTask(task); detail.setResource(resource); } public long getDeadline() { // needed for indicators return 0; } public final long getEarliestStop() { return detail.getEarliestStop(); } public final long getCompletedThrough() { return detail.getCompletedThrough(); } public void setCompletedThrough(long completedThrough) { setStop(completedThrough); } public void replace(Object newOne, boolean leftObject) { if (leftObject) newDetail().setTask((Task) newOne); else newDetail().setResource((Resource) newOne); } public long getFinishOffset() { return EarnedValueCalculator.getInstance().getFinishOffset(this); } public long getStartOffset() { return EarnedValueCalculator.getInstance().getStartOffset(this); } public String getTimeUnitLabel() { return getResource().getTimeUnitLabel(); } public boolean isMaterial() { return getResource().isMaterial(); } public RateFormat getRateFormat() { return getResource().getRateFormat(); } public ImageLink getBudgetStatusIndicator() { return EarnedValueCalculator.getInstance().getBudgetStatusIndicator(getCpi(null)); } public ImageLink getScheduleStatusIndicator() { return EarnedValueCalculator.getInstance().getBudgetStatusIndicator(getSpi(null)); } public Object backupDetail() { return detail.backupDetail(); } //use when updating only this assignment public void restoreDetail(Object source, Object detail, boolean isChild) { restoreDetail(detail); getTask().recalculate(source); getTask().updateCachedDuration(); } public void restoreDetail(Object detail) { this.detail = (AssignmentDetail) detail; } public String getDelegatedToName() { return getTask().getDelegatedToName(); } public boolean isLocal() { return true; } public void setLocal(boolean local) { } public boolean renumber(boolean localOnly) { return hasKey.renumber(localOnly); } public int getCostRateIndex() { return detail.getCostRateIndex(); } public void setCostRateIndex(int val) { newDetail().setCostRateIndex(val); } public String getUniqueIdString() { return getTask().getUniqueId() + "." + getResource().getUniqueId(); } }