internal void Apply(Task task)
{
if (isCustomColumn)
task.SetCustomColumnValue(customColumn, defaultValue);
else
{
task.SetDefaultColumnValue(defaultColumnType, defaultValue);
}
}
public static string FeatureSummary(Task feature)
{
IEnumerable<Task> allTasks;
try
{
allTasks = LinkedTasks(feature);
}
catch (UnlinkedException)
{
if (feature.GetCustomColumnValue("Planned sprint").ToString() != string.Empty)
feature.SetCustomColumnValue("Planned sprint", string.Empty);
return string.Empty;
}
var projects = allTasks.Select(t => t.Project.Name).Distinct();
var allPlannedSprints = new SortedSet<string>();
var plannedIPSprint = false;
var summary_builder = new StringBuilder();
summary_builder.Append(string.Format(FEATURE_SUMMARY_LINE_FORMAT, FEATURE_SUMMARY_HEADINGS));
summary_builder.Append(FEATURE_SUMMARY_HEADER_SEPARATOR);
foreach (var project in projects)
{
var team = project.Substring(TEAM_PROJECT_PREFIX.Length);
var teamShort = team.Substring(0, (team.Length > 14) ? 13 : team.Length) + ((team.Length > 14) ? "…" : "");
var tasks = allTasks.Where(t => t.Project.Name == project);
var status = CalcAggregatedStatus(tasks);
var completedPoints = tasks.Where(t => LeafCompleted(t)).Sum(t => t.Points);
var totalPoints = tasks.Sum(t => t.Points);
var completedStories = tasks.Where(t => LeafCompleted(t)).Count();
var totalStories = tasks.Count();
var plannedSprints = tasks
.Where(t => !LeafCompleted(t))
.Select(t => t.GetCustomColumnValue("Planned sprint"))
.Where(sprintColumn => sprintColumn != null)
.Select(sprintColumn => sprintColumn.ToString())
.Where(sprint => sprint.Length != 0)
.Distinct()
.OrderBy(sprint => sprint);
var plannedSprintsString = plannedSprints.Aggregate(
new StringBuilder(),
(sb, sprint) => sb.Append(sprint).Append(", "),
sb => sb.Length > 0 ? sb.ToString(0, sb.Length-2) : "");
var productOwner = ProductOwnerConfig.GetProductOwner(team, "unknown");
var productOwnerShort = productOwner.Substring(0, (productOwner.Length > 14) ? 13 : productOwner.Length) + ((productOwner.Length > 14) ? "…" : "");
summary_builder.AppendFormat(FEATURE_SUMMARY_LINE_FORMAT,
teamShort, status, completedPoints + "/" + totalPoints, completedStories + "/" + totalStories, productOwnerShort, plannedSprintsString);
if (plannedSprintsString.Length > 0)
{
if (!plannedIPSprint && plannedSprints.Where(t => t == "IP").Any())
plannedIPSprint = true;
var maxPlannedSprint = plannedSprints.Where(t => t.StartsWith("S")).Max();
allPlannedSprints.Add(maxPlannedSprint);
}
}
if (plannedIPSprint)
feature.SetCustomColumnValue("Planned sprint", "IP");
else if (allPlannedSprints.Count() > 0)
feature.SetCustomColumnValue("Planned sprint", allPlannedSprints.Max());
return summary_builder.ToString();
}
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);
}
}
}
private void DoUpdateFromHistory(Task task, HPMDataHistory history)
{
// Ensure that we get the custom column of the right project
HPMProjectCustomColumnsColumn actualCustomColumn = task.ProjectView.GetCustomColumn(trackingColumn.m_Name);
DateTimeValue storedValue = (DateTimeValue)task.GetCustomColumnValue(actualCustomColumn);
// ToInt64 will return the value as microseconds since 1970 Jan 1
ulong storedHpmTime = storedValue.ToHpmDateTime();
if (history.m_Latests.m_Time > storedHpmTime)
{
foreach (HPMDataHistoryEntry entry in history.m_HistoryEntries)
{
// Check if it is the status field
if (entry.m_FieldID == 15)
{
if (entry.m_Time > storedHpmTime)
{
storedHpmTime = entry.m_Time;
task.SetCustomColumnValue(trackingColumn, DateTimeValue.FromHpmDateTime(task, actualCustomColumn, storedHpmTime));
}
}
}
}
}
internal void DoUpdate(Task task)
{
try
{
Debug.Print("DeriveBehaviour - {0} - {1} - processing task \"{2}\"",
isCustomColumn ? customColumnName : defaultColumnType.ToString(),
expression,
task.Name);
var expressionValue = mInfo.Invoke(null, new object[] { task });
if (isCustomColumn)
{
// Ensure that we get the custom column of the right project
var customColumn = task.ProjectView.GetCustomColumn(customColumnName);
var oldValue = task.GetCustomColumnValue(customColumnName);
if (customColumn != null && oldValue != null && !oldValue.Equals(expressionValue))
task.SetCustomColumnValue(customColumn, expressionValue);
}
else
{
var oldValue = task.GetDefaultColumnValue(defaultColumnType);
if (oldValue != null && !oldValue.Equals(expressionValue))
task.SetDefaultColumnValue(defaultColumnType, expressionValue);
}
}
catch (TargetInvocationException e)
{
// Hack to let column handlers bail out when they don't have any new value to set.
if (!(e.InnerException is NoNewValueException))
throw;
}
}
private static void ProcessInternalDependencies(Task feature)
{
var program = feature.Project.Name;
var linkedMilestones = feature.LinkedTasks.Where(t => t is Release && IsTeamProject(t) && ProgramTeamsConfig.IsTeamInProgram(program, TeamName(t))).Cast<Release>();
var value = linkedMilestones.Count() > 1 ? InternalDependencies(feature, linkedMilestones) : "";
feature.SetCustomColumnValue(INTERNAL_DEPENDENCIES, value);
}
/// <summary>
/// Creates the ProgramFeatureSummary and updates the points value based on the linked values.
/// </summary>
/// <param name="current_task"></param>
/// <param name="updateTaskStatus">If set to true the points for the master item will be update with the aggregated points from the linked items.</param>
/// <returns>A ASCI art table with containing a summary of what needs to be done.</returns>
public static string ProgramFeatureSummary(Task current_task, bool updateTaskStatus)
{
Dictionary<string, TeamCollection> teamCollection = new Dictionary<string, TeamCollection>();
Dictionary<string, TaskCollection> taskGroup = new Dictionary<string, TaskCollection>();
taskGroup.Add("In progress", new TaskCollection("In progress", 0, 0));
taskGroup.Add("Completed", new TaskCollection("Completed", 0, 0));
taskGroup.Add("Blocked", new TaskCollection("Blocked", 0, 0));
taskGroup.Add("Not done", new TaskCollection("Not done", 0, 0));
taskGroup.Add("To be deleted", new TaskCollection("To be deleted", 0, 0));
StringBuilder sb = new StringBuilder();
foreach (Task task in current_task.LinkedTasks)
{
string team = task.Project.Name;
if (team.ToLower().StartsWith("team - "))
{
if (!teamCollection.ContainsKey(team))
{
TeamCollection collection = new TeamCollection(taskGroup);
collection.team = team;
teamCollection.Add(team, collection);
}
teamCollection[team].addTask(task);
}
}
if (teamCollection.Count > 0)
{
string format = "<CODE>{0,-20} │ {1,-11} │ {2, -6} │ {3, -8}│ {4, -15}</CODE>";
sb.Append(string.Format(format, new object[] { "Name", "Status", "Points", "Stories", "Planned sprint" }));
sb.Append("\n<CODE>─────────────────────┼─────────────┼────────┼─────────┼───────────────────</CODE>\n");
foreach (KeyValuePair<string, TeamCollection> pair in teamCollection)
{
sb.Append(pair.Value.FormatString(format) + "\n");
}
if (hasParentHeader(current_task.Parent, "Development"))
{
foreach (KeyValuePair<string, TaskCollection> taskPair in taskGroup)
{
createNewTask(current_task, taskPair.Value);
}
}
try
{
CustomColumnValue v = current_task.GetCustomColumnValue("Team");
// Intead of creating the list I jut simply get the existing list and clear it
IList selectedTeams = v.ToStringList();
selectedTeams.Clear();
foreach (KeyValuePair<string, TeamCollection> pair in teamCollection)
{
string name = pair.Key.Substring(7);
if (!selectedTeams.Contains(name))
{
selectedTeams.Add(name);
}
}
CustomColumnValue.FromStringList(current_task, current_task.ProjectView.GetCustomColumn("Team"), selectedTeams);
CustomColumnValue newValue = CustomColumnValue.FromStringList(current_task, current_task.ProjectView.GetCustomColumn("Team"), selectedTeams);
current_task.SetCustomColumnValue("Team", newValue);
}
catch (Exception)
{
}
}
return sb.ToString();
}
internal void DoUpdate(Task task)
{
object expressionValue = mInfo.Invoke(null, new object[] { task });
if (isCustomColumn)
{
// Ensure that we get the custom column of the right project
HPMProjectCustomColumnsColumn actualCustomColumn = task.ProjectView.GetCustomColumn(customColumnName);
if (actualCustomColumn != null)
task.SetCustomColumnValue(actualCustomColumn, expressionValue);
}
else
task.SetDefaultColumnValue(defaultColumnType, expressionValue);
}
