public ReportableObjectRollUp(SummarizableObject summaryObject, WORKPACK workpack, SummarizableObject projectSummary)
{
summaryObject.ReportableObjects = projectSummary.ReportableObjects.Where(x => x.BASELINE_ITEMJoinRATE.BASELINE_ITEM.GUID_WORKPACK == workpack.GUID).ToArray().ToList();
var nonCumulativeBurnedList = projectSummary.NonCumulative_BurnedDataPoints.Where(x => x.WorkpackName == workpack.INTERNAL_NAME1).OrderByDescending(x => x.ProgressDate).ToArray().ToList();
var nonCumulativeActualList = projectSummary.NonCumulative_ActualDataPoints.Where(x => x.WorkpackName == workpack.INTERNAL_NAME1).OrderByDescending(x => x.ProgressDate).ToArray().ToList();
summaryObject.NonCumulative_BurnedDataPoints = new ObservableCollection <ProgressInfo>(nonCumulativeBurnedList);
summaryObject.NonCumulative_ActualDataPoints = new ObservableCollection <ProgressInfo>(nonCumulativeActualList);
summaryObject.FirstAlignedDataDate = projectSummary.FirstAlignedDataDate;
summaryObject.LivePROGRESS = projectSummary.LivePROGRESS;
summaryObject.LiveBASELINE = projectSummary.LiveBASELINE;
summaryObject.ReportingDataDate = projectSummary.LivePROGRESS.DATA_DATE;
summaryObject.IntervalPeriod = projectSummary.IntervalPeriod;
this.SummaryObject = summaryObject;
}
/// <summary>
/// Influence column(s) when changes happens in other column
/// </summary>
public void CellValueChanging(CellValueChangedEventArgs e)
{
if (e.RowHandle != GridControl.NewItemRowHandle)
{
return;
}
BASELINE_ITEMProjection activeBASELINE_ITEM = (BASELINE_ITEMProjection)e.Row;
if (e.Column.FieldName == BindableBase.GetPropertyName(() => new BASELINE_ITEMProjection().BASELINE_ITEM) + "." + BindableBase.GetPropertyName(() => new BASELINE_ITEM().GUID_WORKPACK))
{
WORKPACK chosenWORKPACK = WORKPACKCollection.FirstOrDefault(entity => entity.GUID == (Guid)e.Value);
if (chosenWORKPACK != null)
{
activeBASELINE_ITEM.BASELINE_ITEM.GUID_AREA = chosenWORKPACK.GUID_DAREA;
activeBASELINE_ITEM.BASELINE_ITEM.GUID_DOCTYPE = chosenWORKPACK.GUID_DDOCTYPE;
activeBASELINE_ITEM.BASELINE_ITEM.GUID_DEPARTMENT = chosenWORKPACK.GUID_DDEPARTMENT;
activeBASELINE_ITEM.BASELINE_ITEM.GUID_DISCIPLINE = chosenWORKPACK.GUID_DDISCIPLINE;
activeBASELINE_ITEM.BASELINE_ITEM.GUID_PHASE = chosenWORKPACK.PHASE != null ? chosenWORKPACK.GUID_DPHASE : null;
var SelectedAREA = AREACollection.FirstOrDefault(x => x.GUID == chosenWORKPACK.GUID_DAREA);
var SelectedDOCTYPE = DOCTYPECollection.FirstOrDefault(x => x.GUID == chosenWORKPACK.GUID_DDOCTYPE);
var SelectedDISCIPLINE = DISCIPLINECollection.FirstOrDefault(x => x.GUID == chosenWORKPACK.GUID_DDISCIPLINE);
activeBASELINE_ITEM.BASELINE_ITEM.INTERNAL_NUM = BluePrintDataUtils.BASELINEITEM_Generate_InternalNumber(loadPROJECT, MainViewModel.Entities, SelectedAREA, SelectedDISCIPLINE, SelectedDOCTYPE);
MainViewModel.UpdateSelectedEntity();
}
}
else if (e.Column.FieldName == BindableBase.GetPropertyName(() => new BASELINE_ITEMProjection().BASELINE_ITEM) + "." + BindableBase.GetPropertyName(() => new BASELINE_ITEM().GUID_DOCTYPE))
{
DOCTYPE chosenDOCTYPE = DOCTYPECollection.FirstOrDefault(entity => entity.GUID == (Guid)e.Value);
if (chosenDOCTYPE != null && chosenDOCTYPE.GUID_DDEPARTMENT != null)
{
activeBASELINE_ITEM.BASELINE_ITEM.GUID_DEPARTMENT = chosenDOCTYPE.DEPARTMENT.GUID;
MainViewModel.UpdateSelectedEntity();
}
}
}
/// <summary>
/// Generate internal number2 when all required fields are populated
/// </summary>
public static string WORKPACK_Generate_InternalNumber2(PROJECT fromPROJECT, WORKPACK fromWORKPACK, IEnumerable <WORKPACK> WORKPACKEntities, IEntitiesViewModel <AREA> lookUpAREA, IEntitiesViewModel <DISCIPLINE> lookUpDISCIPLINE, IEntitiesViewModel <PHASE> lookUpPHASE)
{
AREA findAREA;
DISCIPLINE findDISCIPLINE;
PHASE findPHASE;
if (fromWORKPACK.AREA == null || fromWORKPACK.DISCIPLINE == null || fromWORKPACK.AREA == null)
{
findAREA = lookUpAREA.Entities.FirstOrDefault(area => area.GUID == fromWORKPACK.GUID_DAREA);
findPHASE = lookUpPHASE.Entities.FirstOrDefault(phase => phase.GUID == fromWORKPACK.GUID_DPHASE);
findDISCIPLINE = lookUpDISCIPLINE.Entities.FirstOrDefault(discipline => discipline.GUID == fromWORKPACK.GUID_DDISCIPLINE);
}
else
{
findAREA = fromWORKPACK.AREA;
findPHASE = fromWORKPACK.PHASE;
findDISCIPLINE = fromWORKPACK.DISCIPLINE;
}
if (findAREA != null && findDISCIPLINE != null && findPHASE != null)
{
string InternalName = fromPROJECT.NUMBER;
InternalName += "-" + findPHASE.INTERNAL_NUM;
InternalName += findAREA.INTERNAL_NUM;
InternalName += findDISCIPLINE.CODE;
int InternalNameCount = WORKPACKEntities.Count(obj => obj.INTERNAL_NAME2 != null && obj.INTERNAL_NAME2.Contains(InternalName)) + 1;
InternalName += InternalNameCount.ToString();
return(InternalName);
}
else
{
return(string.Empty);
}
}
public void AutoPopulate(object button)
{
MainViewModel.EntitiesUndoRedoManager.PauseActionId();
var info = GridPopupMenuBase.GetGridMenuInfo((DependencyObject)button) as GridMenuInfo;
string departmentFieldName = BindableBase.GetPropertyName(() => new BASELINE_ITEMProjection().BASELINE_ITEM) + "." + BindableBase.GetPropertyName(() => new BASELINE_ITEM().GUID_DEPARTMENT);
string disciplineFieldName = BindableBase.GetPropertyName(() => new BASELINE_ITEMProjection().BASELINE_ITEM) + "." + BindableBase.GetPropertyName(() => new BASELINE_ITEM().GUID_DISCIPLINE);
string docTypeFieldName = BindableBase.GetPropertyName(() => new BASELINE_ITEMProjection().BASELINE_ITEM) + "." + BindableBase.GetPropertyName(() => new BASELINE_ITEM().GUID_DOCTYPE);
string areaFieldName = BindableBase.GetPropertyName(() => new BASELINE_ITEMProjection().BASELINE_ITEM) + "." + BindableBase.GetPropertyName(() => new BASELINE_ITEM().GUID_AREA);
string workpackFieldName = BindableBase.GetPropertyName(() => new BASELINE_ITEMProjection().BASELINE_ITEM) + "." + BindableBase.GetPropertyName(() => new BASELINE_ITEM().GUID_WORKPACK);
string internalNumberFieldName = BindableBase.GetPropertyName(() => new BASELINE_ITEMProjection().BASELINE_ITEM) + "." + BindableBase.GetPropertyName(() => new BASELINE_ITEM().INTERNAL_NUM);
List <BASELINE_ITEMProjection> entitiesToSave = new List <BASELINE_ITEMProjection>();
if (info.Column.FieldName == internalNumberFieldName)
{
foreach (BASELINE_ITEMProjection entity in MainViewModel.SelectedEntities)
{
entity.BASELINE_ITEM.INTERNAL_NUM = string.Empty;
}
}
foreach (BASELINE_ITEMProjection entity in MainViewModel.SelectedEntities)
{
WORKPACK entityWORKPACK = WORKPACKCollection.FirstOrDefault(x => x.GUID == entity.BASELINE_ITEM.GUID_WORKPACK);
if (info.Column.FieldName == internalNumberFieldName)
{
string internalNum = BluePrintDataUtils.BASELINEITEM_Generate_InternalNumber(loadPROJECT, MainViewModel.Entities, entity.BASELINE_ITEM.AREA, entity.BASELINE_ITEM.DISCIPLINE, entity.BASELINE_ITEM.DOCTYPE, entity.GUID);
MainViewModel.SetNestedValueWithUndo(entity, info.Column.FieldName, internalNum);
entitiesToSave.Add(entity);
}
else if (info.Column.FieldName == departmentFieldName || info.Column.FieldName == disciplineFieldName || info.Column.FieldName == docTypeFieldName || info.Column.FieldName == areaFieldName)
{
if (entityWORKPACK == null)
{
continue;
}
if (info.Column.FieldName == departmentFieldName)
{
MainViewModel.SetNestedValueWithUndo(entity, info.Column.FieldName, entityWORKPACK.GUID_DDEPARTMENT);
}
else if (info.Column.FieldName == disciplineFieldName)
{
MainViewModel.SetNestedValueWithUndo(entity, info.Column.FieldName, entityWORKPACK.GUID_DDISCIPLINE);
}
else if (info.Column.FieldName == docTypeFieldName)
{
MainViewModel.SetNestedValueWithUndo(entity, info.Column.FieldName, entityWORKPACK.GUID_DDOCTYPE);
}
else if (info.Column.FieldName == areaFieldName)
{
MainViewModel.SetNestedValueWithUndo(entity, info.Column.FieldName, entityWORKPACK.GUID_DAREA);
}
entitiesToSave.Add(entity);
}
else if (info.Column.FieldName == workpackFieldName)
{
if (entity.BASELINE_ITEM.GUID_DISCIPLINE == Guid.Empty || entity.BASELINE_ITEM.GUID_DEPARTMENT == Guid.Empty ||
entity.BASELINE_ITEM.GUID_DOCTYPE == Guid.Empty || entity.BASELINE_ITEM.GUID_AREA == Guid.Empty)
{
continue;
}
WORKPACK findWORKPACK = WORKPACKCollection.FirstOrDefault(x => x.GUID_DDEPARTMENT == entity.BASELINE_ITEM.GUID_DEPARTMENT && x.GUID_DDISCIPLINE == entity.BASELINE_ITEM.GUID_DISCIPLINE);
if (findWORKPACK == null)
{
WORKPACK newWORKPACK = new WORKPACK();
newWORKPACK.GUID_PROJECT = loadPROJECT.GUID;
newWORKPACK.GUID_DAREA = (Guid)entity.BASELINE_ITEM.GUID_AREA;
if (entity.BASELINE_ITEM.GUID_PHASE != null)
{
newWORKPACK.GUID_DPHASE = entity.BASELINE_ITEM.GUID_PHASE;
}
newWORKPACK.GUID_DDISCIPLINE = (Guid)entity.BASELINE_ITEM.GUID_DISCIPLINE;
newWORKPACK.GUID_DDEPARTMENT = (Guid)entity.BASELINE_ITEM.GUID_DEPARTMENT;
newWORKPACK.GUID_DDOCTYPE = (Guid)entity.BASELINE_ITEM.GUID_DOCTYPE;
newWORKPACK.INTERNAL_NAME1 = BluePrintDataUtils.WORKPACK_Generate_InternalNumber1(loadPROJECT, newWORKPACK, WORKPACKCollection, loaderCollection.GetViewModel <AREA>(), loaderCollection.GetViewModel <DISCIPLINE>(), loaderCollection.GetViewModel <DOCTYPE>());
newWORKPACK.INTERNAL_NAME2 = BluePrintDataUtils.WORKPACK_Generate_InternalNumber2(loadPROJECT, newWORKPACK, WORKPACKCollection, loaderCollection.GetViewModel <AREA>(), loaderCollection.GetViewModel <DISCIPLINE>(), loaderCollection.GetViewModel <PHASE>());
newWORKPACK.STARTDATE = DateTime.Now;
newWORKPACK.ENDDATE = BluePrintDataUtils.WORKPACK_Calculate_EndDate(newWORKPACK.STARTDATE, loadPROJECT);
DateTime reviewStartDate = newWORKPACK.STARTDATE;
DateTime reviewEndDate = newWORKPACK.ENDDATE;
BluePrintDataUtils.WORKPACK_Calculate_ReviewPeriod(ref reviewStartDate, ref reviewEndDate, loadPROJECT, false);
newWORKPACK.REVIEWSTARTDATE = reviewStartDate;
newWORKPACK.REVIEWENDDATE = reviewEndDate;
newWORKPACK.AUTOGENERATED = true;
((CollectionViewModel <WORKPACK, WORKPACK, Guid, IBluePrintsEntitiesUnitOfWork>)loaderCollection.GetViewModel <WORKPACK>()).Save(newWORKPACK);
MainViewModel.SetNestedValueWithUndo(entity, info.Column.FieldName, newWORKPACK.GUID);
}
else
{
MainViewModel.SetNestedValueWithUndo(entity, info.Column.FieldName, findWORKPACK.GUID);
}
entitiesToSave.Add(entity);
}
}
MainViewModel.BulkSave(entitiesToSave);
MainViewModel.EntitiesUndoRedoManager.UnpauseActionId();
}
private void BuildReportableObjectProductivity(ReportableObject reportableObject, List <Period> exceptionPeriods)
{
decimal remainingUnitsAfterDataDate = reportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.TOTAL_HOURS - reportableObject.TOTAL_EARNED_UNITS;
//When productivity is below this threshold, escalate to workpack or project
decimal minimumProductivityBeforeEscalating = 0.001M;
//establish dates for productivity assessment
DateTime workpackStart = reportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.WORKPACK.STARTDATE;
DateTime workpackEnd = reportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.WORKPACK.ENDDATE;
DateTime?workpackForecastStart = reportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.WORKPACK.FORECASTSTARTDATE;
DateTime?workpackForecastEnd = reportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.WORKPACK.FORECASTENDDATE;
DateTime assessmentStartDate;
DateTime assessmentEndDate;
if (workpackForecastStart != null)
{
assessmentStartDate = (DateTime)workpackForecastStart;
}
else
{
assessmentStartDate = workpackStart;
}
if (workpackForecastEnd != null)
{
assessmentEndDate = (DateTime)workpackForecastEnd;
}
else
{
assessmentEndDate = workpackEnd;
}
if (reportableObject.ReportingDataDate > assessmentStartDate)
{
assessmentStartDate = reportableObject.ReportingDataDate;
}
if (reportableObject.ReportingDataDate > assessmentEndDate)
{
assessmentEndDate = reportableObject.ReportingDataDate;
}
Period assessmentPeriod = new Period(assessmentStartDate.Date, assessmentEndDate.Date);
//establish workpack productivity to be used when deliverable productivity is too low
WORKPACK currentWORKPACK = reportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.WORKPACK;
//calculate deliverable productivity
reportableObject.VariationProductivity = ISupportProgressReportingExtensions.CalculatePlannedProductivity(assessmentPeriod, exceptionPeriods, reportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.TOTAL_HOURS);
//progressItem.ProgressItem_CurrentProductivity = UnifiedCalculationMethods.CalculateProductivity(assessmentPeriod)
decimal workpackVarProductivity = 0;
if (reportableObject.VariationProductivity < minimumProductivityBeforeEscalating)
{
IEnumerable <BASELINE_ITEMProjection> WorkpackBASELINE_ITEMJoinRATES = SummaryObject.ReportableObjects.Where(x => x.BASELINE_ITEMJoinRATE.BASELINE_ITEM.GUID_WORKPACK == currentWORKPACK.GUID).Select(x => x.BASELINE_ITEMJoinRATE);
//not checking for progressItemWorkpack null because all progress item should have workpacks assigned if the user
decimal totalWorkpackUnits = WorkpackBASELINE_ITEMJoinRATES.Sum(x => x.BASELINE_ITEM.TOTAL_HOURS);
workpackVarProductivity = ISupportProgressReportingExtensions.CalculatePlannedProductivity(assessmentPeriod, exceptionPeriods, totalWorkpackUnits);
if (workpackVarProductivity > 0)
{
reportableObject.VariationProductivity = workpackVarProductivity;
}
}
decimal workpackBaseProductivity = 0;
//not checking for progressItemWorkpack null because all progress item should have workpacks assigned if the user
decimal totalWorkpackBudgetedUnits = (currentWORKPACK == null || currentWORKPACK.BASELINE_ITEM == null) ? 0 : currentWORKPACK.BASELINE_ITEM.Sum(pItem => pItem.ESTIMATED_HOURS);
workpackBaseProductivity = ISupportProgressReportingExtensions.CalculatePlannedProductivity(assessmentPeriod, exceptionPeriods, remainingUnitsAfterDataDate);
if (reportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.ESTIMATED_HOURS == 0)
{
reportableObject.BaselineProductivity = workpackBaseProductivity;
}
else
{
reportableObject.BaselineProductivity = ISupportProgressReportingExtensions.CalculatePlannedProductivity(assessmentPeriod, exceptionPeriods, remainingUnitsAfterDataDate);
//apply normalized productivity for unusually low calculated productivity
if (reportableObject.BaselineProductivity < minimumProductivityBeforeEscalating)
{
if (workpackBaseProductivity > 0)
{
reportableObject.BaselineProductivity = workpackBaseProductivity;
}
}
}
List <ProgressInfo> deliverablePlannedDataPointsOnOrBeforeDataDate = reportableObject.NonCumulative_PlannedDataPoints.Where(dataPoint => dataPoint.ProgressDate <= SummaryObject.LivePROGRESS.DATA_DATE).ToList();
decimal currentEfficiency = 0;
if (reportableObject.TOTAL_EARNED_UNITS != 0 && deliverablePlannedDataPointsOnOrBeforeDataDate.Count() > 0)
{
decimal deliverablePlannedUnitsOnOrBeforeDataDate = deliverablePlannedDataPointsOnOrBeforeDataDate.Sum(dataPoint => dataPoint.Units);
if (deliverablePlannedUnitsOnOrBeforeDataDate > 0)
{
currentEfficiency = reportableObject.TOTAL_EARNED_UNITS / deliverablePlannedUnitsOnOrBeforeDataDate;
}
reportableObject.ActualProductivity = reportableObject.BaselineProductivity * currentEfficiency;
}
else
{
reportableObject.ActualProductivity = reportableObject.BaselineProductivity; //assume productivity of 1 because there are no units to measure against
}
if (reportableObject.ActualProductivity < minimumProductivityBeforeEscalating)
{
reportableObject.ActualProductivity = reportableObject.BaselineProductivity;
}
}
private void PlannedDataPointsBuilder(bool fromOriginalBaseline)
{
foreach (ReportableObject ReportableObject in SummaryObject.ReportableObjects)
{
//Populate the progressItem variation adjustments
ReportableObject.NonCumulative_VariationAdjustments = new ObservableCollection <VariationAdjustment>(SummaryObject.NonCumulative_VariationAdjustments.Where(adjustment => adjustment.BaselineItemGuid == ReportableObject.BASELINE_ITEMJoinRATE.BASELINE_ITEM.GUID_ORIGINAL).ToList());
ReportableObject.Cumulative_VariationAdjustments = ISupportProgressReportingExtensions.PopulateCumulativeVariationAdjustments(ReportableObject.NonCumulative_VariationAdjustments, SummaryObject.FirstAlignedDataDate, SummaryObject.IntervalPeriod);
//Assign the report date for stats display
ReportableObject.ReportingDataDate = SummaryObject.ReportingDataDate;
BASELINE_ITEMProjection currentBASELINE_ITEM = ReportableObject.BASELINE_ITEMJoinRATE;
WORKPACK currentWORKPACK = currentBASELINE_ITEM.BASELINE_ITEM.WORKPACK;
if (currentWORKPACK == null)
{
continue;
}
List <ProgressInfo> progressItemP6DataPoints;
WorkpackAssignmentLoadType assignmentLoadType = WorkpackAssignmentLoadType.Original;
if (!fromOriginalBaseline)
{
assignmentLoadType = WorkpackAssignmentLoadType.Modified;
}
IEnumerable <TASK> BASELINE_TASKS = null;
P6Data.PROJECT BASELINE_P6PROJECT = null;
if (fromOriginalBaseline)
{
if (this.SummaryObject.LiveBASELINE.P6BASELINE_NAME != null && this.SummaryObject.LiveBASELINE.P6BASELINE_NAME != string.Empty)
{
BASELINE_TASKS = GetP6ScheduleTasks(SummaryObject.LiveBASELINE.P6BASELINE_NAME, out BASELINE_P6PROJECT);
}
}
else
{
if (this.SummaryObject.LiveBASELINE.P6MODBASELINE_NAME != null && this.SummaryObject.LiveBASELINE.P6MODBASELINE_NAME != string.Empty)
{
BASELINE_TASKS = GetP6ScheduleTasks(SummaryObject.LiveBASELINE.P6MODBASELINE_NAME, out BASELINE_P6PROJECT);
}
}
if (SummaryObject.LivePROGRESS.P6PROGRESS_NAME != null && TryBuildP6DataPoints(BASELINE_P6PROJECT, BASELINE_TASKS, ReportableObject, DataPointsType.Planned, assignmentLoadType, out progressItemP6DataPoints))
{
if (fromOriginalBaseline)
{
ReportableObject.NonCumulative_OriginalDataPoints = new ObservableCollection <ProgressInfo>(progressItemP6DataPoints);
}
else
{
ReportableObject.NonCumulative_PlannedDataPoints = new ObservableCollection <ProgressInfo>(progressItemP6DataPoints);
}
}
else
{
List <Period> workpackSuspensionPeriod = new List <Period>();
workpackSuspensionPeriod.Add(new Period(currentWORKPACK.REVIEWSTARTDATE, currentWORKPACK.REVIEWENDDATE));
decimal BaselineItemBaseUnits = currentBASELINE_ITEM.BASELINE_ITEM.ESTIMATED_HOURS;
decimal BaselineItemBaseCosts = currentBASELINE_ITEM.ESTIMATED_COSTS;
decimal BaselineItemTotalUnits = currentBASELINE_ITEM.BASELINE_ITEM.TOTAL_HOURS;
decimal BaselineItemTotalCosts = currentBASELINE_ITEM.TOTAL_COSTS;
List <ProgressInfo> plannedDataPoints;
if (fromOriginalBaseline) //if it's generating from original baseline ignore variation
{
TimeSpan workingBaseTimeSpan = currentWORKPACK.ENDDATE - currentWORKPACK.STARTDATE;
plannedDataPoints = ISupportProgressReportingExtensions.DataPointsGenerator(SummaryObject, workingBaseTimeSpan, BaselineItemBaseUnits, BaselineItemBaseCosts, currentWORKPACK.STARTDATE, currentBASELINE_ITEM.BASELINE_ITEM.GUID_ORIGINAL, this.CurrencyConversion, workpackSuspensionPeriod, BaselineItemTotalUnits, BaselineItemTotalCosts);
ReportableObject.NonCumulative_OriginalDataPoints = new ObservableCollection <ProgressInfo>(plannedDataPoints);
}
else
{
DateTime modifiedEndDateToUse = currentWORKPACK.ENDDATE;
if (currentWORKPACK.FORECASTENDDATE != null)
{
modifiedEndDateToUse = (DateTime)currentWORKPACK.FORECASTENDDATE;
}
TimeSpan workingModifiedTimeSpan = modifiedEndDateToUse - currentWORKPACK.STARTDATE;
if (currentWORKPACK.FORECASTSTARTDATE != null && ((DateTime)currentWORKPACK.FORECASTSTARTDATE) > currentWORKPACK.ENDDATE)
{
workpackSuspensionPeriod.Add(new Period(currentWORKPACK.ENDDATE.AddDays(1), (DateTime)currentWORKPACK.FORECASTSTARTDATE));
}
//Used to show sharktooth on variation
plannedDataPoints = ISupportProgressReportingExtensions.DataPointsGenerator(SummaryObject, workingModifiedTimeSpan, BaselineItemBaseUnits, BaselineItemBaseCosts, currentWORKPACK.STARTDATE, currentBASELINE_ITEM.BASELINE_ITEM.GUID_ORIGINAL, this.CurrencyConversion, workpackSuspensionPeriod, null, null, ReportableObject.Cumulative_VariationAdjustments);
//Used to show normalized variation
//plannedDataPoints = DataPointsGenerator(WorkingPeriod, progressInterval, BaselineItemTotalUnits, BaselineItemTotalCosts, this.CurrencyConversion, baselineItem.WORKPACK.STARTDATE, firstAlignedDataDate, baselineItem.GUID_ORIGINAL);
ReportableObject.NonCumulative_PlannedDataPoints = new ObservableCollection <ProgressInfo>(plannedDataPoints);
}
}
}
if (fromOriginalBaseline)
{
SummaryObject.NonCumulative_OriginalDataPoints = new ObservableCollection <ProgressInfo>(SummaryObject.ReportableObjects.SelectMany(x => x.NonCumulative_OriginalDataPoints));
}
else
{
SummaryObject.NonCumulative_PlannedDataPoints = new ObservableCollection <ProgressInfo>(SummaryObject.ReportableObjects.SelectMany(x => x.NonCumulative_PlannedDataPoints));
}
}
