public WhatIfResult OnComplete(ProjectItem projectItem, DateTime completedDate, bool addNewPeriodics)
{
Assertion.Require(projectItem, "projectItem");
this.whatIfResult = new WhatIfResult(projectItem, ProjectItemOperation.Complete);
// Add root state change
var stateChange = new ProjectItemStateChange(projectItem, ProjectItemOperation.Complete)
{
ActualEndDate = completedDate
};
whatIfResult.AddStateChange(stateChange);
// Update related
UpdateRelatedProjectItemsDeadlines(projectItem, completedDate);
if (addNewPeriodics)
{
var newPeriodicResult = ModelingServices.TryGetNextPeriodic(projectItem, completedDate);
if (newPeriodicResult != null)
{
this.whatIfResult.AddStateChanges(newPeriodicResult.StateChanges);
}
}
return(this.whatIfResult);
}
public WhatIfResult OnUpdateDeadlines()
{
WhatIfResult current = GetWhatIfResultWithRootProjectItemBranch();
foreach (var item in current.StateChanges)
{
item.ProcessMatchResult = ProjectItemProcessMatchResult.MatchedEqual;
if (!item.ProjectItem.HasTemplate)
{
continue;
}
ActivityModel template = item.ProjectItem.GetTemplate().Template;
if (template.IsPeriodic)
{
item.ProcessMatchResult = ProjectItemProcessMatchResult.NoProgrammingRule;
}
}
UpdateDeadlinesForUncompletedActivities(current);
UpdateDeadlinesForCurrentCompletedActivities(current);
return(current);
}
static private void StoreChanges(WhatIfResult result)
{
foreach (var stateChange in result.StateChanges)
{
switch (stateChange.Operation)
{
case ProjectItemOperation.Complete:
stateChange.ProjectItem.Complete(stateChange.ActualEndDate);
break;
case ProjectItemOperation.UpdateDeadline:
stateChange.ProjectItem.SetDeadline(stateChange.Deadline);
stateChange.ProjectItem.Save();
break;
case ProjectItemOperation.CreateFromTemplate:
stateChange.ProjectItem = CreateFromTemplate(stateChange);
break;
case ProjectItemOperation.Reactivate:
stateChange.ProjectItem.Reactivate();
break;
default:
throw Assertion.EnsureNoReachThisCode($"Unrecognized WhatIfResult operation {stateChange.Operation}");
} // switch
} // foreach
}
private void AddNewModelActivitiesToCurrentResult(WhatIfResult current,
WhatIfResult newModelResult)
{
return;
//try {
// var notIncludedList = newModelResult.StateChanges.FindAll(x => !current.StateChanges.Contains(y => y.Template == x.Template));
// foreach (var notIncluded in notIncludedList) {
// notIncluded.ProcessMatchResult = ProjectItemProcessMatchResult.OnlyInProcess;
// notIncluded.ProcessID = this.RootProjectItem.ProcessID;
// notIncluded.SubprocessID = this.RootProjectItem.SubprocessID;
// int index = SetNewActivityInsertionRule(notIncluded, current, newModelResult);
// if (index >= 0) {
// current.InsertStateChange(index, notIncluded);
// } else {
// current.AddStateChange(notIncluded);
// }
// }
//} catch (Exception e) {
// EmpiriaLog.Error(e);
// throw e;
//}
}
static public FixedList <ProjectItem> Complete(ProjectItem projectItem, DateTime completedDate)
{
Assertion.Require(projectItem, "projectItem");
WhatIfResult result = ModelingServices.WhatIfCompleted(projectItem, completedDate, false);
if (result.HasErrors)
{
throw result.GetException();
}
if (!String.IsNullOrWhiteSpace(projectItem.ProcessID))
{
ProjectItemData.ResetSubprocessID(projectItem.ProcessID);
}
StoreChanges(result);
CreateNextPeriodicIfNecessary(projectItem, completedDate);
ProjectItemData.ClearProcessID();
projectItem.Project.Refresh();
return(projectItem.Project.GetItems());
}
static private void StoreChanges(WhatIfResult result)
{
foreach (var stateChange in result.StateChanges)
{
ProjectItem projectItem = stateChange.ProjectItem;
switch (stateChange.ProcessMatchResult)
{
case ProjectItemProcessMatchResult.MatchedWithDataChanges:
// projectItem.SetData(stateChange);
projectItem.Save();
break;
case ProjectItemProcessMatchResult.MatchedWithDeadlineAndDataChanges:
// projectItem.SetData(stateChange);
projectItem.SetDeadline(stateChange.Deadline);
projectItem.Save();
break;
case ProjectItemProcessMatchResult.MatchedWithDeadlineChanges:
projectItem.SetDeadline(stateChange.Deadline);
projectItem.Save();
break;
////case ProjectItemProcessMatchResult.OnlyInProcess:
//// stateChange.ProjectItem = ProjectUpdater.CreateFromTemplate(stateChange,
//// stateChange.InsertionPosition);
//// break;
default:
break;
} // switch
} // foreach
}
public WhatIfResult CreateFromEvent(Activity activityModel, DateTime eventDate)
{
Assertion.Require(activityModel, "activityModel");
// Create root
this.whatIfResult = new WhatIfResult(activityModel, ProjectItemOperation.CreateFromTemplate);
this.CreateBranchFromTemplate(activityModel);
// Set root dates;
var stateChange = this.whatIfResult.StateChanges[0];
stateChange.Deadline = eventDate;
stateChange.Project = this.targetProject;
//// Append any other external dependencies of the activity model tree
// var dependencies = this.whatIfResult.GetUncontainedModelDependencies(activityModel);
// foreach (var dependency in dependencies) {
// this.CreateBranchFromTemplate(dependency);
// }
// ToDo: Change this by a recursive strategy
for (int i = 0; i < 10; i++)
{
this.RecalculateDates();
}
this.CalculatePeriodicDates(eventDate);
return(this.whatIfResult);
}
static private void UpdateDeadlinesForCurrentCompletedActivities(WhatIfResult current)
{
var currentCompletedActivities =
current.StateChanges.FindAll(x => x.ProjectItem.HasTemplate && x.ProjectItem.ActualEndDate != ExecutionServer.DateMaxValue &&
x.ProjectItem.Status == StateEnums.ActivityStatus.Completed);
foreach (var completedActivityStateChange in currentCompletedActivities)
{
UpdateRelatedProjectItemsDeadlines(current, completedActivityStateChange,
completedActivityStateChange.ProjectItem.ActualEndDate);
} // foreach
}
static public WhatIfResult WhatIfReactivated(ProjectItem projectItem)
{
Assertion.Require(projectItem, "projectItem");
var whatIfResult = new WhatIfResult(projectItem, ProjectItemOperation.Reactivate);
var stateChange = new ProjectItemStateChange(projectItem, ProjectItemOperation.Reactivate);
whatIfResult.AddStateChange(stateChange);
return(whatIfResult);
}
static public void Reactivate(ProjectItem projectItem)
{
Assertion.Require(projectItem, "projectItem");
WhatIfResult result = ModelingServices.WhatIfReactivated(projectItem);
if (result.HasErrors)
{
throw result.GetException();
}
StoreChanges(result);
}
private void MoveProjectItemsAccordingToInsertionRules(WhatIfResult result)
{
foreach (var item in result.StateChanges)
{
if (item.HasInsertionRule)
{
if (item.ParentStateChange != null && item.InsertionPoint.IsEmptyInstance)
{
item.InsertionPoint = item.ProjectItem;
}
this.Project.MoveTo(item.ProjectItem, item.InsertionRule, item.InsertionPoint, item.InsertionPosition);
}
}
}
public FixedList <ProjectItem> UpdateDeadlines()
{
WhatIfResult result = OnUpdateDeadlines();
if (result.HasErrors)
{
throw result.GetException();
}
StoreChanges(result);
return(result.StateChanges.ConvertAll(x => x.ProjectItem)
.ToFixedList());
}
private WhatIfResult GetWhatIfResultWithRootProjectItemBranch()
{
WhatIfResult result = new WhatIfResult(this.RootProjectItem, ProjectItemOperation.UpdateProcessChanges);
FixedList <ProjectItem> currentActivities = this.RootProjectItem.GetBranch();
foreach (var projectItem in currentActivities)
{
var stateChange = new ProjectItemStateChange(projectItem, ProjectItemOperation.UpdateProcessChanges);
result.AddStateChange(stateChange);
}
return(result);
}
public FixedList <ProjectItem> UpdateWithLastProcessChanges()
{
WhatIfResult result = this.OnUpdateWithLastProcessChanges();
if (result.HasErrors)
{
throw result.GetException();
}
StoreChanges(result);
MoveProjectItemsAccordingToInsertionRules(result);
return(result.StateChanges.ConvertAll(x => x.ProjectItem)
.ToFixedList());
}
public WhatIfResult OnUpdateWithLastProcessChanges()
{
WhatIfResult current = GetWhatIfResultWithRootProjectItemBranch();
WhatIfResult newModelResult = GetNewModelResult();
WhatIfResult merged = GetMergeWhatIfResult(current.StateChanges, newModelResult.StateChanges);
AddNewModelActivitiesToCurrentResult(merged, newModelResult);
UpdateDeadlinesForCurrentCompletedActivities(merged);
UpdateDeadlinesForUncompletedActivities(merged);
return(merged);
}
private WhatIfResult GetMergeWhatIfResult(FixedList <ProjectItemStateChange> current,
FixedList <ProjectItemStateChange> newModel)
{
WhatIfResult merge = new WhatIfResult(this.RootProjectItem, ProjectItemOperation.UpdateProcessChanges);
merge.AddStateChanges(current);
foreach (var item in merge.StateChanges)
{
if (item.ProjectItem.HasTemplate)
{
TryMatch(item, newModel);
}
else
{
item.ProcessMatchResult = ProjectItemProcessMatchResult.OnlyInProject;
}
}
return(merge);
}
static private void UpdateRelatedProjectItemsDeadlines(WhatIfResult current,
ProjectItemStateChange stateChange,
DateTime completedDate)
{
var projectItem = stateChange.ProjectItem;
FixedList <ProjectItemStateChange> relatedStateChangesList = current.GetRelatedStateChanges(stateChange);
foreach (var relatedStateChange in relatedStateChangesList)
{
var model = ((Activity)relatedStateChange.Template).Template;
DateTime?updatedDeadline = UtilityMethods.CalculateNewDeadline(model, completedDate);
if (!updatedDeadline.HasValue)
{
continue;
}
if (relatedStateChange == null)
{
continue;
}
if (updatedDeadline.Value != relatedStateChange.ProjectItem.Deadline)
{
relatedStateChange.Deadline = updatedDeadline.Value;
relatedStateChange.ProcessMatchResult = AddDeadlineChangeToMatchResult(relatedStateChange.ProcessMatchResult);
}
else
{
relatedStateChange.Deadline = ExecutionServer.DateMaxValue;
relatedStateChange.ProcessMatchResult = RemoveDeadlineChangeFromMatchResult(relatedStateChange.ProcessMatchResult);
}
// Recursive call
UpdateRelatedProjectItemsDeadlines(current, relatedStateChange, updatedDeadline.Value);
}
}
static public FixedList <ProjectItem> CreateActivitiesFromModel(Activity activityModel,
Project project,
DateTime eventDate,
ProjectItem insertionPoint,
TreeItemInsertionRule insertionRule)
{
Assertion.Require(activityModel, "activityModel");
Assertion.Require(project, "project");
Assertion.Require(insertionPoint, "insertionPoint");
WhatIfResult result = ModelingServices.WhatIfCreatedFromEvent(activityModel, project, eventDate);
if (result.HasErrors)
{
throw result.GetException();
}
ProjectItemData.ResetProcessID();
StoreChanges(result);
ProjectItemData.ClearProcessID();
if (result.StateChanges.Count > 0)
{
if (!insertionPoint.IsEmptyInstance && insertionRule != TreeItemInsertionRule.AsTreeRootAtEnd)
{
project.MoveTo(result.StateChanges[0].ProjectItem, insertionRule, insertionPoint);
}
else if (insertionPoint.IsEmptyInstance && (insertionRule == TreeItemInsertionRule.AsTreeRootAtStart ||
insertionRule == TreeItemInsertionRule.AsTreeRootAtEnd))
{
project.MoveTo(result.StateChanges[0].ProjectItem, insertionRule, insertionPoint);
}
}
return(project.GetItems());
}
static private int SetNewActivityInsertionRule(ProjectItemStateChange toInsertActivity,
WhatIfResult current, WhatIfResult newModelResult)
{
int position = -1;
var parent = current.StateChanges.Find(x => !x.ProjectItem.IsEmptyInstance &&
x.Template.UID == toInsertActivity.Template.Parent.UID);
if (parent != null)
{
var newSiblings = current.StateChanges.FindAll(x => x.ProjectItem.IsEmptyInstance &&
x.ParentStateChange.UID == parent.UID);
var parentIndex = current.StateChanges.IndexOf(parent);
var currentSiblings = current.StateChanges.FindAll(x => !x.ProjectItem.IsEmptyInstance &&
x.ProjectItem.Parent.UID == parent.ProjectItem.UID);
if (currentSiblings.Count != 0)
{
toInsertActivity.InsertionPoint = parent.ProjectItem;
toInsertActivity.InsertionRule = TreeItemInsertionRule.AsChildAsLastNode;
position = parentIndex + currentSiblings.Count + newSiblings.Count + 1;
EmpiriaLog.Trace($"Rule 0: {toInsertActivity.Template.Name} at position {position}.");
}
else
{
toInsertActivity.ParentStateChange = parent;
toInsertActivity.InsertionPoint = parent.ProjectItem;
toInsertActivity.InsertionRule = TreeItemInsertionRule.AsChildAsLastNode;
position = parentIndex + newSiblings.Count + 1;
EmpiriaLog.Trace($"Rule 1: {toInsertActivity.Template.Name} at position {position}.");
}
}
else
{
Assertion.Require(toInsertActivity.ParentStateChange, nameof(toInsertActivity.ParentStateChange));
var newParent = current.StateChanges.Find(x => x.UID == toInsertActivity.ParentStateChange.UID);
var newParentIdx = current.StateChanges.IndexOf(newParent);
var currentSiblings = current.StateChanges.FindAll(x => x.ParentStateChange != null &&
x.ParentStateChange.UID == toInsertActivity.ParentStateChange.UID);
toInsertActivity.ParentStateChange = newParent;
toInsertActivity.InsertionPoint = ProjectItem.Empty;
toInsertActivity.InsertionRule = TreeItemInsertionRule.AsChildAsLastNode;
position = newParentIdx + currentSiblings.Count + 1;
EmpiriaLog.Trace($"Rule 2: {toInsertActivity.Template.Name} at position {position}.");
}
return(position);
}