internal static Sprint GetCommittedToSprint(Task task)
{
HPMUniqueID uid = Session.TaskGetLinkedToSprint(task.UniqueTaskID);
if (uid.m_ID != -1)
{
return((Sprint)Task.GetTask(uid));
}
else
{
return(null);
}
}
internal List <Task> Find(string findString, EHPMReportViewType viewType)
{
List <Task> found = new List <Task>();
HPMFindContext findContext = new HPMFindContext();
HPMFindContextData data = SessionManager.Session.UtilPrepareFindContext(findString, UniqueID, viewType, findContext);
HPMTaskEnum items = SessionManager.Session.TaskFind(data, EHPMTaskFindFlag.None);
foreach (HPMUniqueID taskID in items.m_Tasks)
{
found.Add(Task.GetTask(taskID, viewType));
}
return(found);
}
internal static List <HansoftItem> GetChildren(HPMUniqueID uniqueID, bool deep)
{
List <HansoftItem> children = new List <HansoftItem>();
if (HasChildren(uniqueID))
{
HPMTaskEnum tasks = Session.TaskRefUtilEnumChildren(uniqueID, deep);
foreach (HPMUniqueID id in tasks.m_Tasks)
{
children.Add(Task.GetTask(id));
}
}
return(children);
}
/// <summary>
/// Sort a list of ProdutcBacklogItems in the same order as they are displayed in the GUI in the priority vuew
/// </summary>
/// <param name="project">The Project that the ProductBacklogItems belong to.</param>
/// <param name="unsorted">The ProductBacklogItems that should be sorted.</param>
/// <returns></returns>
public static List <ProductBacklogItem> SortByPriority(Project project, List <ProductBacklogItem> unsorted)
{
List <ProductBacklogItem> sorted = new List <ProductBacklogItem>();
foreach (ProductBacklogItem anItem in unsorted)
{
if (anItem is ProductBacklogItemInSprint || anItem is ProductBacklogItemInSchedule)
{
sorted.Add((ProductBacklogItem)Task.GetTask(anItem.Session.TaskGetMainReference(anItem.UniqueTaskID)));
}
else
{
sorted.Add(anItem);
}
}
List <HansoftItem> sortedBacklog = new List <HansoftItem>();
List <HansoftItem> allLeaves = project.ProductBacklog.DeepLeaves;
ProductBacklogItem item = (ProductBacklogItem)allLeaves.Find(leaf => !allLeaves.Exists(prevLeaf => prevLeaf.Session.TaskRefGetPreviousWorkPriorityID(prevLeaf.UniqueID).m_ID == leaf.UniqueID.m_ID));
sortedBacklog.Add(item);
HPMUniqueID nextId = item.Session.TaskRefGetPreviousWorkPriorityID(item.UniqueID);
while (nextId != -2)
{
item = (ProductBacklogItem)Task.GetTask(nextId);
sortedBacklog.Add(item);
nextId = item.Session.TaskRefGetPreviousWorkPriorityID(item.UniqueID);
}
foreach (ProductBacklogItem aItem in sorted)
{
aItem.AbsolutePriority = sortedBacklog.FindIndex(ii => ii.UniqueID.m_ID == aItem.UniqueID.m_ID);
}
PriorityComparer comparer = new PriorityComparer();
sorted.Sort(comparer);
sorted.Reverse();
return(sorted);
}
private void CloneChildTasks(HansoftItem sourceParent, HansoftItem targetParent, ProjectView targetProject, HPMProjectCustomColumns customColumns)
{
Task newTask = null;
foreach (Task task in sourceParent.Children)
{
HPMTaskCreateUnifiedReference prevRefID = new HPMTaskCreateUnifiedReference();
if (newTask == null)
{
prevRefID.m_RefID = -1;
}
else
{
prevRefID.m_RefID = newTask.UniqueTaskID;
}
prevRefID.m_bLocalID = false;
HPMTaskCreateUnifiedReference prevWorkPrioRefID = new HPMTaskCreateUnifiedReference();
prevWorkPrioRefID.m_RefID = -2;
prevWorkPrioRefID.m_bLocalID = false;
HPMTaskCreateUnifiedReference[] parentRefIds = new HPMTaskCreateUnifiedReference[1];
parentRefIds[0] = new HPMTaskCreateUnifiedReference();
parentRefIds[0].m_RefID = targetParent.Id; // This should be a taskref, which it should be
parentRefIds[0].m_bLocalID = false;
HPMTaskCreateUnified createTaskData = new HPMTaskCreateUnified();
createTaskData.m_Tasks = new HPMTaskCreateUnifiedEntry[1];
createTaskData.m_Tasks[0] = new HPMTaskCreateUnifiedEntry();
createTaskData.m_Tasks[0].m_bIsProxy = false;
createTaskData.m_Tasks[0].m_LocalID = -1;
createTaskData.m_Tasks[0].m_ParentRefIDs = parentRefIds;
createTaskData.m_Tasks[0].m_PreviousRefID = prevRefID;
createTaskData.m_Tasks[0].m_PreviousWorkPrioRefID = prevWorkPrioRefID;
createTaskData.m_Tasks[0].m_NonProxy_ReuseID = 0;
createTaskData.m_Tasks[0].m_TaskLockedType = Session.TaskGetLockedType(task.UniqueTaskID);
createTaskData.m_Tasks[0].m_TaskType = Session.TaskGetType(task.UniqueTaskID);
HPMChangeCallbackData_TaskCreateUnified createdData = Session.TaskCreateUnifiedBlock(targetProject.UniqueID, createTaskData);
if (createdData.m_Tasks.Length == 1)
{
newTask = Task.GetTask(createdData.m_Tasks[0].m_TaskRefID);
newTask.Category = task.Category;
newTask.Confidence = task.Confidence;
newTask.DetailedDescription = task.DetailedDescription;
newTask.EstimatedDays = task.EstimatedDays;
newTask.Hyperlink = task.Hyperlink;
newTask.Name = task.Name;
newTask.Points = task.Points;
newTask.Priority = task.Priority;
newTask.Risk = task.Risk;
newTask.Severity = task.Severity;
newTask.Status = task.Status;
newTask.WorkRemaining = task.WorkRemaining;
Session.TaskSetFullyCreated(newTask.UniqueTaskID);
foreach (HPMProjectCustomColumnsColumn column in customColumns.m_ShowingColumns)
{
newTask.SetCustomColumnValue(column.m_Name, task.GetCustomColumnValue(column.m_Name));
}
CloneChildTasks(task, newTask, targetProject, customColumns);
}
}
}
internal override CustomColumnValue GetAggregatedCustomColumnValue(HPMProjectCustomColumnsColumn customColumn)
{
HPMUniqueID proxyID = Session.TaskGetProxy(UniqueTaskID);
if (proxyID.m_ID == this.UniqueID.m_ID) // This is an item in the schedule and we will use the base implementation
{
return(base.GetAggregatedCustomColumnValue(customColumn));
}
else if (proxyID.m_ID != -1) // If it is an item in the product backlog with a proxy we use the proxies summary, hence ignoring breakdown of committed items in the PBL
{
return(Task.GetTask(proxyID).GetAggregatedCustomColumnValue(customColumn));
}
else if (!HasChildren) // It is a leaf
{
return(base.GetAggregatedCustomColumnValue(customColumn));
}
else // It is a parent item which is not committed and hence we will iterate over the children.
{
if (customColumn.m_Type == EHPMProjectCustomColumnsColumnType.IntegerNumber)
{
long aggregatedInt = 0;
foreach (ProductBacklogItem item in DeepLeaves)
{
proxyID = Session.TaskGetProxy(item.UniqueTaskID);
if (proxyID.m_ID != -1)
{
aggregatedInt += Task.GetTask(proxyID).GetAggregatedCustomColumnValue(customColumn).ToInt();
}
else
{
aggregatedInt += item.GetCustomColumnValue(customColumn).ToInt();
}
}
return(IntegerNumberValue.FromInteger(this, customColumn, aggregatedInt));
}
else if (customColumn.m_Type == EHPMProjectCustomColumnsColumnType.FloatNumber)
{
double aggregatedFloat = 0;
foreach (ProductBacklogItem item in DeepLeaves)
{
proxyID = Session.TaskGetProxy(item.UniqueTaskID);
if (proxyID.m_ID != -1)
{
aggregatedFloat += Task.GetTask(proxyID).GetAggregatedCustomColumnValue(customColumn).ToDouble();
}
else
{
aggregatedFloat += item.GetCustomColumnValue(customColumn).ToDouble();
}
}
return(FloatNumberValue.FromFloat(this, customColumn, aggregatedFloat));
}
else
{
double aggregatedTime = 0;
foreach (ProductBacklogItem item in DeepLeaves)
{
proxyID = Session.TaskGetProxy(item.UniqueTaskID);
if (proxyID.m_ID != -1)
{
aggregatedTime += Task.GetTask(proxyID).GetAggregatedCustomColumnValue(customColumn).ToDouble();
}
else
{
aggregatedTime += item.GetCustomColumnValue(customColumn).ToDouble();
}
}
return(AccumulatedTimeValue.FromFloat(this, customColumn, aggregatedTime));
}
}
}
