/// <summary>
/// Create a replica of this project including tasks, reports, workflows/kanbans, and view presets. The intent is to
/// use one project as a template and instantiate new projects from this template.
/// </summary>
/// <param name="newName"></param>
/// <returns></returns>
public Project Clone(String newName)
{
HPMProjectProperties templateProperties = Session.ProjectGetProperties(UniqueID);
templateProperties.m_Name = newName;
HPMUniqueID newProjectID = Session.ProjectCreate(templateProperties);
Project newProject = Project.GetProject(newProjectID);
CloneColumns(this.Schedule.UniqueID, newProject.Schedule.UniqueID);
CloneColumns(this.ProductBacklog.UniqueID, newProject.ProductBacklog.UniqueID);
CloneColumns(this.BugTracker.UniqueID, newProject.BugTracker.UniqueID);
CloneReports(this.Schedule.UniqueID, newProject.Schedule.UniqueID);
CloneReports(this.ProductBacklog.UniqueID, newProject.ProductBacklog.UniqueID);
CloneReports(this.BugTracker.UniqueID, newProject.BugTracker.UniqueID);
ClonePresets(this.Schedule.UniqueID, newProject.Schedule.UniqueID);
ClonePresets(this.ProductBacklog.UniqueID, newProject.ProductBacklog.UniqueID);
ClonePresets(this.BugTracker.UniqueID, newProject.BugTracker.UniqueID);
CloneWorkflows(this.UniqueID, newProject.UniqueID);
CloneChildTasks(this.Schedule, newProject.Schedule, newProject.Schedule, Session.ProjectCustomColumnsGet(this.Schedule.UniqueID));
CloneChildTasks(this.ProductBacklog, newProject.ProductBacklog, newProject.ProductBacklog, Session.ProjectCustomColumnsGet(this.ProductBacklog.UniqueID));
CloneBugWorkflow(this.BugTracker.UniqueID, newProject.BugTracker.UniqueID);
// TODO; Modify the workflow in the Bugtracker
// Optionally: Set the start/finish dates for any sprints/scheduled tasks so that they are offseted based on the current date
// Optonally: replicate tasks in the QA view
// Optionally: Loop over again to recreate any links / committed items / release tags / delegation / applied or default pipelines and workflows
return(newProject);
}
private void ClonePresets(HPMUniqueID sourceProjectID, HPMUniqueID targetProjectID)
{
foreach (HPMProjectViewPreset preset in Session.ProjectGetViewPresets(sourceProjectID).m_Presets)
{
Session.ProjectCreateViewPreset(targetProjectID, preset);
}
}
private void CloneReports(HPMUniqueID sourceProjectID, HPMUniqueID targetProjectID)
{
foreach (HPMUniqueID resourceID in Session.ProjectEnumReportResources(sourceProjectID).m_Resources)
{
Session.ProjectSetReports(targetProjectID, resourceID, Session.ProjectGetReports(sourceProjectID, resourceID));
}
}
/// <summary>
/// Factory method for creating a Task (subclass of).
/// </summary>
/// <param name="uniqueID">The Task ID or TaskRef ID that a Task shuld be created for</param>
/// <param name="viewType">The view that the task appears in (primarily important for product backlog items which can appear in mutiple views).</param>
/// <returns>A concrete task acting as a wrapper to access the Hansoft API for the task in question.</returns>
internal static Task GetTask(HPMUniqueID uniqueID, EHPMReportViewType viewType)
{
if ((viewType == EHPMReportViewType.ScheduleMainProject || viewType == EHPMReportViewType.AgileMainProject) && SdkSession.UtilIsIDTask(uniqueID) && SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(uniqueID)))
return GetTask(SdkSession.TaskGetProxy(uniqueID));
else
return GetTask(uniqueID);
}
internal HansoftEnumValue(HPMUniqueID projectId, EHPMProjectDefaultColumn column, object value, int iValue)
{
this.projectId = projectId;
this.column = column;
this.value = value;
this.iValue = iValue;
}
public static void CreateProxyItem(SprintSearchCollection SprintRefID, HPMUniqueID ProjectID, HPMUniqueID masterRefID)
{
HPMTaskCreateUnifiedReference parent = new HPMTaskCreateUnifiedReference();
parent.m_bLocalID = false;
parent.m_RefID = SprintRefID.childID;
HPMTaskCreateUnifiedReference prevTaskID = new HPMTaskCreateUnifiedReference();
prevTaskID.m_bLocalID = false;
prevTaskID.m_RefID = SprintRefID.childID;
HPMTaskCreateUnified ProxyTaskCreate = new HPMTaskCreateUnified();
ProxyTaskCreate.m_Tasks = new HPMTaskCreateUnifiedEntry[1];
ProxyTaskCreate.m_Tasks[0] = new HPMTaskCreateUnifiedEntry();
ProxyTaskCreate.m_Tasks[0].m_bIsProxy = true;
ProxyTaskCreate.m_Tasks[0].m_LocalID = 0;
ProxyTaskCreate.m_Tasks[0].m_TaskType = EHPMTaskType.Planned;
ProxyTaskCreate.m_Tasks[0].m_TaskLockedType = EHPMTaskLockedType.BacklogItem;
ProxyTaskCreate.m_Tasks[0].m_ParentRefIDs = new HPMTaskCreateUnifiedReference[1];
ProxyTaskCreate.m_Tasks[0].m_ParentRefIDs[0] = parent;
ProxyTaskCreate.m_Tasks[0].m_PreviousWorkPrioRefID = new HPMTaskCreateUnifiedReference();
ProxyTaskCreate.m_Tasks[0].m_PreviousWorkPrioRefID.m_RefID = -2;
ProxyTaskCreate.m_Tasks[0].m_Proxy_ReferToRefTaskID = masterRefID;
prevTaskID.m_bLocalID = true;
prevTaskID.m_RefID = 0;
HPMChangeCallbackData_TaskCreateUnified proxyResult = SessionManager.Session.TaskCreateUnifiedBlock(ProjectID, ProxyTaskCreate);
}
internal HansoftEnumValue(HPMUniqueID projectId, EHPMProjectDefaultColumn column, object value, int iValue)
{
this.projectId = projectId;
this.column = column;
this.value = value;
this.iValue = iValue;
}
private static string GetTranslatedString(HPMUniqueID projectId, EHPMProjectDefaultColumn column, uint iValue)
{
HPMUntranslatedString unTranslated = SessionManager.Session.UtilGetColumnDataItemFormatted(projectId, column, iValue);
HPMLanguage language = SessionManager.Session.LocalizationGetDefaultLanguage();
String translated = SessionManager.Session.LocalizationTranslateString(language, unTranslated);
return(translated);
}
private static Task CreateTask(HPMUniqueID uniqueID)
{
HPMUniqueID uniqueTaskID = SdkSession.TaskRefGetTask(uniqueID);
EHPMTaskLockedType lockedType = SdkSession.TaskGetLockedType(uniqueTaskID);
switch (lockedType)
{
case EHPMTaskLockedType.BacklogItem:
if (SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(uniqueTaskID)))
{
if (SdkSession.TaskGetMainReference(uniqueTaskID).m_ID == uniqueID.m_ID)
{
return(ProductBacklogItem.GetProductBacklogItem(uniqueID, uniqueTaskID));
}
else
{
return(ProductBacklogItemInSprint.GetProductBacklogItemInSprint(uniqueID, uniqueTaskID));
}
}
else
{
return(SprintBacklogItem.GetSprintBacklogItem(uniqueID, uniqueTaskID));
}
case EHPMTaskLockedType.QABug:
return(Bug.GetBug(uniqueID, uniqueTaskID));
case EHPMTaskLockedType.SprintItem:
return(Sprint.GetSprint(uniqueID, uniqueTaskID));
case EHPMTaskLockedType.Normal:
default:
if (SdkSession.TaskGetForceSubProject(uniqueTaskID))
{
return(SubProject.GetSubProject(uniqueID, uniqueTaskID));
}
else
{
EHPMTaskType taskType = SdkSession.TaskGetType(uniqueTaskID);
switch (taskType)
{
case EHPMTaskType.Milestone:
return(Release.GetRelease(uniqueID, uniqueTaskID));
case EHPMTaskType.Planned:
default:
if (SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(uniqueTaskID)))
{
return(ProductBacklogItemInSchedule.GetProductBacklogItemInSchedule(uniqueID, uniqueTaskID));
}
else
{
return(ScheduledTask.GetScheduledTask(uniqueID, uniqueTaskID));
}
}
}
}
}
/// <summary>
/// Factory method for creating a Task (subclass of).
/// </summary>
/// <param name="uniqueID">The Task ID or TaskRef ID that a Task shuld be created for. If a Task ID is given then the MainRef of the task will be used to determine which view is applicable.</param>
/// <returns>A concrete task acting as a wrapper to access the Hansoft API for the task in question.</returns>
public static Task GetTask(HPMUniqueID uniqueID)
{
HPMUniqueID refID;
if (SdkSession.UtilIsIDTask(uniqueID))
refID = SdkSession.TaskGetMainReference(uniqueID);
else
refID = uniqueID;
return CreateTask(refID);
}
private void CloneWorkflows(HPMUniqueID sourceProjectID, HPMUniqueID targetProjectID)
{
foreach (uint iWorkflow in Session.ProjectWorkflowEnum(sourceProjectID, true).m_Workflows)
{
HPMProjectWorkflowSettings settings = Session.ProjectWorkflowGetSettings(sourceProjectID, iWorkflow);
Session.ProjectWorkflowCreate(targetProjectID, settings.m_Properties);
Session.ProjectWorkflowSetSettings(targetProjectID, settings.m_Identifier, settings);
}
}
public static HPMReport FindReport(HPMUniqueID projId, HPMUniqueID reportUserId, string reportName)
{
HPMReports reports = SessionManager.Instance.Session.ProjectGetReports(projId, reportUserId);
foreach (HPMReport report in reports.m_Reports)
{
if (report.m_Name == reportName)
return report;
}
return null;
}
/// <summary>
/// Returns the user with the incoming name if it exists, otherwise null
/// </summary>
/// <param name="userName">The name of the user to find</param>
/// <returns>the user with the incoming name if it exists, otherwise null</returns>
public static User FindUser(string userName)
{
HPMUniqueID userID = SessionManager.Session.ResourceGetResourceFromName(userName);
if (userID.IsValid())
{
return(User.GetUser(userID));
}
return(null);
}
private void UpdateProject(HPMUniqueID projectID)
{
var sessions = (List <HttpSessionState>)Application["sessions"];
foreach (var session in sessions)
{
HPMUpdateInfo updateinfo = session["updateinfo"] as HPMUpdateInfo;
updateinfo.UpdatedProjects.Add(projectID);
updateinfo.FullUpdate = true;
}
}
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;
}
private Release(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
: base(uniqueID, uniqueTaskID)
{
if (cachedData.ContainsKey(uniqueTaskID.m_ID))
cache = cachedData[uniqueTaskID.m_ID];
else
{
cache = new CachedData();
cachedData.Add(uniqueTaskID.m_ID, cache);
}
}
/// <summary>
/// Factory method for creating a Task (subclass of).
/// </summary>
/// <param name="uniqueID">The Task ID or TaskRef ID that a Task shuld be created for</param>
/// <param name="viewType">The view that the task appears in (primarily important for product backlog items which can appear in mutiple views).</param>
/// <returns>A concrete task acting as a wrapper to access the Hansoft API for the task in question.</returns>
internal static Task GetTask(HPMUniqueID uniqueID, EHPMReportViewType viewType)
{
if ((viewType == EHPMReportViewType.ScheduleMainProject || viewType == EHPMReportViewType.AgileMainProject) && SdkSession.UtilIsIDTask(uniqueID) && SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(uniqueID)))
{
return(GetTask(SdkSession.TaskGetProxy(uniqueID)));
}
else
{
return(GetTask(uniqueID));
}
}
private Release(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
: base(uniqueID, uniqueTaskID)
{
if (cachedData.ContainsKey(uniqueTaskID.m_ID))
{
cache = cachedData[uniqueTaskID.m_ID];
}
else
{
cache = new CachedData();
cachedData.Add(uniqueTaskID.m_ID, cache);
}
}
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);
}
}
public static HansoftEnumValue FromString(HPMUniqueID projectId, EHPMProjectDefaultColumn column, string sValue)
{
if (!maxColumnValuebyColumn.ContainsKey(column))
throw new ArgumentException("Unsupported default column in HansoftEnumValue.FromString/3: " + column);
for (uint i = 0; i <= maxColumnValuebyColumn[column]; i += 1)
{
string translated = GetTranslatedString(projectId, column, i);
if (translated == sValue)
return FromInt(projectId, column, (int)i);
}
return FromInt(projectId, column, 0);
}
internal static HansoftEnumValue FromObject(HPMUniqueID projectId, EHPMProjectDefaultColumn column, object value)
{
if (value is HansoftEnumValue)
return FromInt(projectId, column, ((HansoftEnumValue)value).iValue);
else
{
string sValue = value.ToString();
int iValue;
if (Int32.TryParse(sValue, out iValue))
return FromInt(projectId, column, iValue);
else
return FromString(projectId, column, sValue);
}
}
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>
/// Factory method for creating a Task (subclass of).
/// </summary>
/// <param name="uniqueID">The Task ID or TaskRef ID that a Task shuld be created for. If a Task ID is given then the MainRef of the task will be used to determine which view is applicable.</param>
/// <returns>A concrete task acting as a wrapper to access the Hansoft API for the task in question.</returns>
public static Task GetTask(HPMUniqueID uniqueID)
{
HPMUniqueID refID;
if (SdkSession.UtilIsIDTask(uniqueID))
{
refID = SdkSession.TaskGetMainReference(uniqueID);
}
else
{
refID = uniqueID;
}
return(CreateTask(refID));
}
public static HansoftEnumValue FromString(HPMUniqueID projectId, EHPMProjectDefaultColumn column, string sValue)
{
if (!maxColumnValuebyColumn.ContainsKey(column))
{
throw new ArgumentException("Unsupported default column in HansoftEnumValue.FromString/3: " + column);
}
for (uint i = 0; i <= maxColumnValuebyColumn[column]; i += 1)
{
string translated = GetTranslatedString(projectId, column, i);
if (translated == sValue)
{
return(FromInt(projectId, column, (int)i));
}
}
return(FromInt(projectId, column, 0));
}
private void UpdateTask(HPMUniqueID taskID)
{
var sessions = (List <HttpSessionState>)Application["sessions"];
foreach (var session in sessions)
{
HPMUpdateInfo updateinfo = session["updateinfo"] as HPMUpdateInfo;
try
{
updateinfo.UpdatedTasks.Add(taskID.m_ID, taskID);
}
catch (ArgumentException)
{
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
// The ID of the authenticated user
FormsIdentity ID = (FormsIdentity)HttpContext.Current.User.Identity;
m_ResourceID = new HPMUniqueID(Convert.ToInt32(ID.Name));
m_NoUserID = new HPMUniqueID(-1);
// Find context is empty but can be set by choosing a report or providing a search string
m_FindContexts = new Dictionary<string, HPMFindContextData>();
ErrorLabel.Visible = false;
try
{
InitHansoftVirtualSession();
m_UpdatedFromWeb = m_VirtSession.LocalizationCreateUntranslatedStringFromString("Updated from web integration sample");
AddProjectControls();
// update info contains info from callbacks about changed Hansoft elements
HPMUpdateInfo update = Session["updateinfo"] as HPMUpdateInfo;
if (!IsPostBack || update.FullUpdate)
{
AddData();
update.FullUpdate = false;
// retain selected tab between postbacks (doesn't work for the first tab - TabContainer bug?) Uncomment it if you want to experiment with it
//if (Session["ActiveTabIndex"] != null)
//{
// int storedIndex = (int)Session["ActiveTabIndex"];
// TabContainer projectTabs = Page.FindControl("ProjectTabs") as TabContainer;
// if (storedIndex <= projectTabs.Tabs.Count)
// projectTabs.ActiveTabIndex = storedIndex;
//}
BindDataSources();
}
}
catch (HPMSdkException error)
{
SetErrorMessage("An error occurred when communicating with the Hansoft server.", error.ErrorAsStr());
}
catch (HPMSdkManagedException error)
{
SetErrorMessage("An error occurred when communicating with the Hansoft server.", error.ErrorAsStr());
}
}
//public static Task CreateTask(Task parent, HPMUniqueID ProjectID, string status, HPMUniqueID sprintID)
public static Task CreateTask(Task parentTask, HPMUniqueID ProjectID, string newTaskName, SprintSearchCollection sprintSearchResult)
{
Task newTask = null;
try
{
HPMUniqueID backlogProjectID = SessionManager.Session.ProjectOpenBacklogProject(ProjectID);
HPMTaskCreateUnifiedReference parentRefId = new HPMTaskCreateUnifiedReference();
parentRefId.m_RefID = parentTask.UniqueID;
parentRefId.m_bLocalID = false;
HPMTaskCreateUnified createData = new HPMTaskCreateUnified();
createData.m_Tasks = new HPMTaskCreateUnifiedEntry[1];
createData.m_Tasks[0] = new HPMTaskCreateUnifiedEntry();
createData.m_Tasks[0].m_bIsProxy = false;
createData.m_Tasks[0].m_LocalID = 0;
createData.m_Tasks[0].m_ParentRefIDs = new HPMTaskCreateUnifiedReference[1];
createData.m_Tasks[0].m_ParentRefIDs[0] = parentRefId;
createData.m_Tasks[0].m_PreviousRefID = new HPMTaskCreateUnifiedReference();
createData.m_Tasks[0].m_PreviousRefID.m_RefID = -1;
createData.m_Tasks[0].m_PreviousWorkPrioRefID = new HPMTaskCreateUnifiedReference();
createData.m_Tasks[0].m_PreviousWorkPrioRefID.m_RefID = -2;
createData.m_Tasks[0].m_TaskLockedType = EHPMTaskLockedType.BacklogItem;
createData.m_Tasks[0].m_TaskType = EHPMTaskType.Planned;
HPMChangeCallbackData_TaskCreateUnified result = SessionManager.Session.TaskCreateUnifiedBlock(backlogProjectID, createData);
SessionManager.Session.TaskSetFullyCreated(SessionManager.Session.TaskRefGetTask(result.m_Tasks[0].m_TaskRefID));
newTask = Task.GetTask(result.m_Tasks[0].m_TaskRefID);
HPMUniqueID masterRefID = newTask.UniqueID;
newTask.Name = newTaskName;
if (sprintSearchResult.childID != null)
{
CreateProxyItem(sprintSearchResult, ProjectID, masterRefID);
}
}
catch (Exception)
{
if (newTask != null)
{
SessionManager.Session.TaskDelete(newTask.UniqueTaskID);
}
}
return(newTask);
}
protected void LoginButton_Click(object sender, EventArgs e)
{
errorwrapper.Visible = false;
HPMCredentialResolutionSessionIDsEnum sessionIDs = new HPMCredentialResolutionSessionIDsEnum();
Array.Resize(ref sessionIDs.m_SessionIDs, 1);
HPMString user = UserNameField.Text;
HPMString password = PasswordField.Text;
sessionIDs.m_SessionIDs[0] = Convert.ToUInt64(ChannelList.SelectedItem.Value);
HPMUniqueID userID = new HPMUniqueID(-1);
try
{
HPMChangeCallbackData_AuthenticationResolveCredentialsResponse response = m_VirtSession.AuthenticationResolveCredentialsBlock(user, password, sessionIDs);
userID = response.m_ResourceID;
if (userID.m_ID == -1)
{
SetErrorMessage("Could not authenticate user", "");
}
HPMSdkSession.SessionDestroy(ref m_VirtSession);
}
catch (HPMSdkException error)
{
SetErrorMessage("Could not authenticate user", error.ErrorAsStr());
}
catch (HPMSdkManagedException error)
{
SetErrorMessage("Could not authenticate user", error.ErrorAsStr());
}
if (userID != -1)
{
HttpCookie aCookie = new HttpCookie("hansoftuser");
aCookie.Value = user;
Response.Cookies.Add(aCookie);
FormsAuthentication.RedirectFromLoginPage(Convert.ToString(userID.m_ID), false);
}
}
private static Task CreateTask(HPMUniqueID uniqueID)
{
HPMUniqueID refTaskID = SdkSession.TaskRefGetTask(uniqueID);
EHPMTaskLockedType lockedType = SdkSession.TaskGetLockedType(refTaskID);
switch (lockedType)
{
case EHPMTaskLockedType.BacklogItem:
if (SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(refTaskID)))
{
if (SdkSession.TaskGetMainReference(refTaskID).m_ID == uniqueID.m_ID)
return ProductBacklogItem.GetProductBacklogItem(uniqueID, refTaskID);
else
return ProductBacklogItemInSprint.GetProductBacklogItemInSprint(uniqueID, refTaskID);
}
else
return SprintBacklogItem.GetSprintBacklogItem(uniqueID, refTaskID);
case EHPMTaskLockedType.QABug:
return Bug.GetBug(uniqueID, refTaskID);
case EHPMTaskLockedType.SprintItem:
return Sprint.GetSprint(uniqueID, refTaskID);
case EHPMTaskLockedType.Normal:
default:
if (SdkSession.TaskGetForceSubProject(refTaskID))
{
return SubProject.GetSubProject(uniqueID, refTaskID);
}
else
{
EHPMTaskType taskType = SdkSession.TaskGetType(refTaskID);
switch (taskType)
{
case EHPMTaskType.Milestone:
return Release.GetRelease(uniqueID, refTaskID);
case EHPMTaskType.Planned:
default:
if (SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(refTaskID)))
return ProductBacklogItemInSchedule.GetProductBacklogItemInSchedule(uniqueID, refTaskID);
else
return ScheduledTask.GetScheduledTask(uniqueID, refTaskID);
}
}
}
}
internal static HansoftEnumValue FromObject(HPMUniqueID projectId, EHPMProjectDefaultColumn column, object value)
{
if (value is HansoftEnumValue)
{
return(FromInt(projectId, column, ((HansoftEnumValue)value).iValue));
}
else
{
string sValue = value.ToString();
int iValue;
if (Int32.TryParse(sValue, out iValue))
{
return(FromInt(projectId, column, iValue));
}
else
{
return(FromString(projectId, column, sValue));
}
}
}
/// <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);
}
public static SprintSearchCollection findSprintTaskID(Task parentTask)
{
HPMFindContext FindContext = new HPMFindContext();
HPMFindContextData FindContextData = SessionManager.Session.UtilPrepareFindContext("Itemname: \"Program - PI\" AND ! Itemname: \":\"", parentTask.Project.UniqueID, EHPMReportViewType.AgileMainProject, FindContext);
HPMTaskEnum SprintIDEnum = SessionManager.Session.TaskFind(FindContextData, EHPMTaskFindFlag.None);
foreach (HPMUniqueID searchID in SprintIDEnum.m_Tasks)
{
HPMUniqueID SprintRefID = SessionManager.Session.TaskGetMainReference(searchID);
Task sprint = Task.GetTask(SprintRefID);
foreach (Task child in sprint.DeepChildren)
{
if (child.UniqueTaskID == parentTask.UniqueTaskID)
{
return(new SprintSearchCollection(child.UniqueID, SprintRefID));
}
}
}
return(new SprintSearchCollection(null, null));
}
internal static string AssignedAsString(Task task)
{
StringBuilder sb = new StringBuilder();
HPMTaskResourceAllocationResource[] allocations = SessionManager.Session.TaskGetResourceAllocation(task.UniqueTaskID).m_Resources;
for (int i = 0; i < allocations.Length; i += 1)
{
HPMUniqueID resourceId = allocations[i].m_ResourceID;
int percentage = allocations[i].m_PercentAllocated;
sb.Append(User.GetUser(resourceId).Name);
if (percentage != 100)
{
sb.Append('[');
sb.Append(percentage.ToString());
sb.Append("]");
}
if (i < allocations.Length - 1)
{
sb.Append(", ");
}
}
return(sb.ToString());
}
private void CloneColumns(HPMUniqueID sourceProjectID, HPMUniqueID targetProjectID)
{
HPMProjectCustomColumns columns = Session.ProjectCustomColumnsGet(sourceProjectID);
HPMProjectCustomColumnChanges newColumns = new HPMProjectCustomColumnChanges();
newColumns.m_ProjectID = sourceProjectID;
List <HPMProjectCustomColumnsColumn> added = new List <HPMProjectCustomColumnsColumn>();
foreach (HPMProjectCustomColumnsColumn column in columns.m_ShowingColumns)
{
added.Add(column);
}
foreach (HPMProjectCustomColumnsColumn column in columns.m_HiddenColumns)
{
added.Add(column);
}
newColumns.m_Added = added.ToArray();
Session.ProjectCustomColumnsSet(newColumns);
}
/// <summary>
/// Sets the resource assignments for this task. Assumes 100% allocation for each resource
/// </summary>
/// <param name="userNames">The list of user names as they are displayed in the Hansoft client. Assumes strings.</param>
public void SetResourceAssignmentsFromUserStrings(IList userNames)
{
Project project = Project.GetProject(MainProjectID);
List <Resource> resources = new List <Resource>();
foreach (string rs in userNames)
{
string trimmed = rs.Trim();
User user = project.Members.Find(u => u.Name == trimmed);
if (user != null)
{
resources.Add(user);
}
else
{
User groupMember = project.Members.Find(u => u.Groups.Find(g => g.Name == trimmed) != null);
if (groupMember != null)
{
Group group = groupMember.Groups.Find(g => g.Name == trimmed);
resources.Add(group);
}
}
}
HPMTaskResourceAllocation allocation = new HPMTaskResourceAllocation();
allocation.m_Resources = new HPMTaskResourceAllocationResource[resources.Count];
for (int i = 0; i < resources.Count; ++i)
{
allocation.m_Resources[i] = new HPMTaskResourceAllocationResource();
allocation.m_Resources[i].m_PercentAllocated = 100;
allocation.m_Resources[i].m_ResourceID = resources.ElementAt(i).UniqueID;
}
HPMUniqueID taskID = SdkSession.TaskRefGetTask(UniqueID);
Session.TaskSetResourceAllocation(taskID, allocation, true, EHPMTaskSetStatusFlag.None);
}
private void CloneWorkflows(HPMUniqueID sourceProjectID, HPMUniqueID targetProjectID)
{
foreach (uint iWorkflow in Session.ProjectWorkflowEnum(sourceProjectID, true).m_Workflows)
{
HPMProjectWorkflowSettings settings = Session.ProjectWorkflowGetSettings(sourceProjectID, iWorkflow);
Session.ProjectWorkflowCreate(targetProjectID, settings.m_Properties);
Session.ProjectWorkflowSetSettings(targetProjectID, settings.m_Identifier,settings);
}
}
private void CloneReports(HPMUniqueID sourceProjectID, HPMUniqueID targetProjectID)
{
foreach (HPMUniqueID resourceID in Session.ProjectEnumReportResources(sourceProjectID).m_Resources)
Session.ProjectSetReports(targetProjectID, resourceID, Session.ProjectGetReports(sourceProjectID, resourceID));
}
private static string GetTranslatedString(HPMUniqueID projectId, EHPMProjectDefaultColumn column, uint iValue)
{
HPMUntranslatedString unTranslated = SessionManager.Session.UtilGetColumnDataItemFormatted(projectId, column, iValue);
HPMLanguage language = SessionManager.Session.LocalizationGetDefaultLanguage();
String translated = SessionManager.Session.LocalizationTranslateString(language, unTranslated);
return translated;
}
internal static ProductBacklogItem GetProductBacklogItem(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
{
return new ProductBacklogItem(uniqueID, uniqueTaskID);
}
private ScheduledTask(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
: base(uniqueID, uniqueTaskID)
{
}
internal static ProductBacklogItemInSprint GetProductBacklogItemInSprint(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
{
return(new ProductBacklogItemInSprint(uniqueID, uniqueTaskID));
}
internal static Release GetRelease(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
{
return new Release(uniqueID, uniqueTaskID);
}
/// <summary>
/// Factory method for User.
/// </summary>
/// <param name="uniqueID">The ID of the user.</param>
/// <returns></returns>
static public User GetUser(HPMUniqueID uniqueID)
{
return(new User(uniqueID));
}
private ProductBacklogItemInSchedule(HPMUniqueID uniqueID, HPMUniqueID refTaskID)
: base(uniqueID, refTaskID)
{
}
internal static ProductBacklogItemInSchedule GetProductBacklogItemInSchedule(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
{
return new ProductBacklogItemInSchedule(uniqueID, uniqueTaskID);
}
/// <summary>
/// Factory method for User.
/// </summary>
/// <param name="uniqueID">The ID of the user.</param>
/// <returns></returns>
public static User GetUser(HPMUniqueID uniqueID)
{
return new User(uniqueID);
}
internal Resource(HPMUniqueID uniqueID)
: base(uniqueID)
{
}
private SprintBacklogItem(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
: base(uniqueID, uniqueTaskID)
{
}
internal static ScheduledTask GetScheduledTask(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
{
return new ScheduledTask(uniqueID, uniqueTaskID);
}
private Project(HPMUniqueID projID)
: base(projID)
{
}
private ProductBacklogItemInSprint(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
: base(uniqueID, uniqueTaskID)
{
}
internal static Project GetProject(HPMUniqueID uniqueID)
{
return new Project(uniqueID);
}
/// <summary>
/// General constructor
/// </summary>
/// <param name="uniqueID">The TaskRef ID of the item</param>
/// <param name="refTaskID">The Task ID of the item</param>
internal ProductBacklogItem(HPMUniqueID uniqueID, HPMUniqueID refTaskID)
: base(uniqueID, refTaskID)
{
}
private void CloneBugWorkflow(HPMUniqueID sourceQAProjectID, HPMUniqueID targetQAProjectID)
{
}
static HansoftEnumValue FromInt(HPMUniqueID projectId, EHPMProjectDefaultColumn column, int iValue)
{
return new HansoftEnumValue(projectId, column, iValue, iValue);
}
private void CloneColumns(HPMUniqueID sourceProjectID, HPMUniqueID targetProjectID)
{
Session.ProjectCustomColumnsSet(targetProjectID, Session.ProjectCustomColumnsGet(sourceProjectID));
}
internal static Sprint GetSprint(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
{
return new Sprint(uniqueID, uniqueTaskID);
}
private void ClonePresets(HPMUniqueID sourceProjectID, HPMUniqueID targetProjectID)
{
Session.ProjectSetViewPresets(targetProjectID, Session.ProjectGetViewPresets(sourceProjectID));
}
private User(HPMUniqueID uniqueID)
: base(uniqueID)
{
}
private Sprint(HPMUniqueID uniqueID, HPMUniqueID refTaskID)
: base(uniqueID, refTaskID)
{
}
