/*********************************************
* Creates a new bug.
* Params:
* name - the name of the new bug
* projectUID - project to create the bug in
* Returns:
* the ref id of the new bug
*********************************************/
HPMUniqueID HansoftUtils::createBug(HPMString name, HPMUniqueID projectUID)
{
HPMSdkSession *session = SessionManager::getInstance().Session();
HPMUniqueID projectQAUID = session->ProjectUtilGetQA(projectUID);
// Create a new one
HPMTaskCreateUnified createData;
createData.m_Tasks.resize(1);
// Set previous to -1 to make it the top task.
HPMTaskCreateUnifiedReference prevRefID;
prevRefID.m_RefID = -1;
HPMTaskCreateUnifiedReference prevWorkPrioRefID;
prevWorkPrioRefID.m_RefID = -2;
createData.m_Tasks[0].m_LocalID = 1;
createData.m_Tasks[0].m_PreviousRefID = prevRefID;
createData.m_Tasks[0].m_PreviousWorkPrioRefID = prevWorkPrioRefID;
HPMChangeCallbackData_TaskCreateUnified TaskCreateReturn = session->TaskCreateUnifiedBlock(projectQAUID, createData);
if (TaskCreateReturn.m_Tasks.size() == 1)
{
// The returned is a bug ref in the project container. We need the task id not the reference id.
HPMUniqueID bugRefID = TaskCreateReturn.m_Tasks[0].m_TaskRefID;
HPMUniqueID bugUID = session->TaskRefGetTask(bugRefID);
session->TaskSetDescription(bugUID, name);
// When we set fully created the task becomes visible to users.
session->TaskSetFullyCreated(bugUID);
return bugRefID;
}
return -1;
}
/*********************************************
* Creates a backlog item in the project with the specified name, under the parent object (if not empty string).
* The items will be called the item name.
* Params:
* projectName - name of the project to create the item in the backlog
* parentName - name of the parent item to put the item under
* itemName - name for the newly created item
* Returns:
* the ref ID of the newly created item. -1 if not successful.
**********************************************/
HPMUniqueID HansoftUtils::createBacklogItem(HPMString projectName, HPMString parentName, HPMString itemName)
{
HPMSdkSession *session = SessionManager::getInstance().Session();
HPMUniqueID projectID = HansoftUtils::findProject(projectName);
if (!projectID.IsValid())
return -1;
HPMProjectProperties projectProp = session->ProjectGetProperties(projectID);
HPMUniqueID productBacklogUID = session->ProjectUtilGetBacklog(projectID);
HPMTaskEnum Tasks = session->TaskEnum(productBacklogUID);
for (HPMUInt32 j = 0; j < Tasks.m_Tasks.size(); ++j)
{
HPMUniqueID parentBacklogID = Tasks.m_Tasks[j];
// TODO: Handle if no parent is specified
if (session->TaskGetDescription(parentBacklogID).compare(parentName) == 0)
{
HPMTaskCreateUnified newBacklogItem;
newBacklogItem.m_Tasks.resize(1);
newBacklogItem.m_Tasks[0].m_bIsProxy = false;
newBacklogItem.m_Tasks[0].m_LocalID = -1;
newBacklogItem.m_Tasks[0].m_TaskLockedType = EHPMTaskLockedType_BacklogItem;
HPMTaskCreateUnifiedReference prevRefID;
prevRefID.m_bLocalID = false;
prevRefID.m_RefID = -1;
newBacklogItem.m_Tasks[0].m_PreviousRefID = prevRefID;
HPMTaskCreateUnifiedReference prevWorkPrioRefID;
prevWorkPrioRefID.m_bLocalID = false;
prevWorkPrioRefID.m_RefID = -2;
newBacklogItem.m_Tasks[0].m_PreviousWorkPrioRefID = prevWorkPrioRefID;
HPMTaskCreateUnifiedReference parentBacklogTaskRefID;
parentBacklogTaskRefID.m_bLocalID = false;
parentBacklogTaskRefID.m_RefID = session->TaskGetMainReference(parentBacklogID);
newBacklogItem.m_Tasks[0].m_ParentRefIDs.push_back(parentBacklogTaskRefID);
newBacklogItem.m_Tasks[0].m_NonProxy_ReuseID = 0;
newBacklogItem.m_Tasks[0].m_NonProxy_WorkflowID = 0xffffffff;
HPMChangeCallbackData_TaskCreateUnified TaskCreateReturn = session->TaskCreateUnifiedBlock(productBacklogUID, newBacklogItem);
if (newBacklogItem.m_Tasks.size() == 1)
{
// The returned is a task ref in the project container. We need the task id not the reference id.
HPMUniqueID newTestSuiteTaskRefID = TaskCreateReturn.m_Tasks[0].m_TaskRefID;
HPMUniqueID newTestSuiteTaskID = session->TaskRefGetTask(newTestSuiteTaskRefID);
// Set the name and the status of the test suite
session->TaskSetDescription(newTestSuiteTaskID, itemName);
session->TaskSetStatus(newTestSuiteTaskID, EHPMTaskStatus_NotDone, true, EHPMTaskSetStatusFlag_All);
session->TaskSetFullyCreated(newTestSuiteTaskID);
return newTestSuiteTaskRefID;
}
else
return -1;
}
}
return -1;
}
/*********************************************
* Creates a new test cycle to commit selected test cases to
* Params:
* name - the name of the new test cycle
* duration - the number of days the cycle should last
* projectUID - the id of the project to add the cycle in
* Returns:
* The reference ID of the created sprint.
*********************************************/
HPMUniqueID HansoftUtils::createSprint(HPMString name, int duration, HPMUniqueID projectUID)
{
HPMSdkSession *session = SessionManager::getInstance().Session();
//Create a sprint to commit items to
HPMTaskCreateUnified NewTestCycle;
NewTestCycle.m_Tasks.resize(1);
NewTestCycle.m_Tasks[0].m_bIsProxy = false;
NewTestCycle.m_Tasks[0].m_LocalID = -1;
NewTestCycle.m_Tasks[0].m_TaskLockedType = EHPMTaskLockedType_SprintItem;
//The new test cycle will end up at the top of the schedule.
HPMTaskCreateUnifiedReference PrevRefID;
PrevRefID.m_bLocalID = false;
PrevRefID.m_RefID = -1;
NewTestCycle.m_Tasks[0].m_PreviousRefID = PrevRefID;
HPMTaskCreateUnifiedReference PrevWorkPrioRefID;
PrevWorkPrioRefID.m_bLocalID = false;
PrevWorkPrioRefID.m_RefID = -2;
NewTestCycle.m_Tasks[0].m_PreviousWorkPrioRefID = PrevWorkPrioRefID;
HPMChangeCallbackData_TaskCreateUnified TaskCreateReturn = session->TaskCreateUnifiedBlock(projectUID, NewTestCycle);
// We know that we are only creating one item, so we'll get the identifier for that one.
HPMUniqueID sprintRefID = TaskCreateReturn.m_Tasks[0].m_TaskRefID;
HPMUniqueID sprintTaskID = session->TaskRefGetTask(sprintRefID);
session->TaskSetFullyCreated(sprintTaskID);
session->TaskSetDescription(sprintTaskID, name);
session->TaskSetDuration(sprintTaskID, duration);
return sprintRefID;
}
/*********************************************
* Posts a comment at the top of the list of comments for the incoming task.
* Params:
* taskRefID - the task to comment at
* commentStr - the comment to post
*********************************************/
void HansoftUtils::postComment(HPMUniqueID taskRefID, HPMString commentStr)
{
HPMSdkSession *session = SessionManager::getInstance().Session();
HPMUniqueID taskUID = session->TaskRefGetTask(taskRefID);
HPMInt32 greatestComment = findGreatestCommentPostID(taskUID);
HPMTaskComment comment;
comment.m_ParentID = greatestComment;
comment.m_Flags = EHPMTaskCommentFlag_IsPosted;
comment.m_MessageText = commentStr;
comment.m_PostedByResourceID = session->ResourceGetLoggedIn();
HPMInt32 NewCommentID = session->TaskCreateCommentBlock(taskUID, comment);
session->TaskNotifyCommentPosted(taskUID, NewCommentID, false);
}
void PriorityCopy()
{
auto project_id = FindProjectByName(project_);
if (!project_id.IsValid())
return;
auto program_backlog_id = GetProductBacklog(project_id);
if (!program_backlog_id.IsValid())
return;
auto destination_column = FindColumn(program_backlog_id, destination_);
if (destination_column.m_Name == "")
return;
int count = 0;
HPMUniqueID first;
map<HPMUniqueID, HPMUniqueID> dictionary;
for (auto task : session_->TaskRefUtilEnumChildren(program_backlog_id, true).m_Tasks)
{
auto previous = session_->TaskRefGetPreviousWorkPriorityID(task);
dictionary[previous] = task;
if (previous.m_ID == -2)
first = task;
count++;
}
if (dictionary.size() == 0)
{
wcout << "No items in backlog, nothing to do.\r\n";
return;
}
vector<HPMUniqueID> sorted;
auto item = first;
while (dictionary.find(item) != dictionary.end())
{
sorted.push_back(item);
item = dictionary[item];
}
if (dictionary.size() > 1)
sorted.push_back(item);
int index = 1;
for (auto task_ref : sorted)
{
HPMUniqueID task = session_->TaskRefGetTask(task_ref);
session_->TaskSetCustomColumnData(task, destination_column.m_Hash, to_string(index++), false);
}
wcout << "Copied: " << count << " tasks.\r\n";
}
/*********************************************
* Creates a link between the two incoming items.
* Params:
* fromRef - starting point
* toRef - end point
*********************************************/
void HansoftUtils::createLink(HPMUniqueID fromRef, HPMUniqueID toRef)
{
HPMSdkSession *session = SessionManager::getInstance().Session();
// Add a link from the Epic to the created feature
HPMUniqueID fromID = session->TaskRefGetTask(fromRef);
/*if (m_pSession->UtilIsIDTaskRef(selectedRequirementUID))
{
LinkedTo.m_LinkedTo[0].m_LinkedTo = selectedRequirementUID;
}
else
{
LinkedTo.m_LinkedTo[0].m_LinkedTo = m_pSession->TaskGetMainReference(selectedRequirementUID);
}*/
HPMTaskLinkedTo linkedItems = session->TaskGetLinkedTo(fromID);
HPMUInt32 newSize = linkedItems.m_LinkedTo.size() + 1;
linkedItems.m_LinkedTo.resize(newSize);
linkedItems.m_LinkedTo[newSize - 1].m_LinkedTo = toRef;
linkedItems.m_LinkedTo[newSize - 1].m_LinkedToType = EHPMTaskLinkedToLinkType_TaskItemOrBug;
session->TaskSetLinkedTo(fromID, linkedItems);
}
/*********************************************
* Resets the workflow status and returns the item to the backlog.
* Params:
* taskRefID - the ref id delete and reset.
*********************************************/
void HansoftUtils::resetAndDeleteTask(HPMUniqueID taskRefID)
{
HPMSdkSession *session = SessionManager::getInstance().Session();
HPMTaskEnum childrenEnum = session->TaskRefUtilEnumChildren(taskRefID, false);
for (unsigned int i = 0; i < childrenEnum.m_Tasks.size(); ++i)
{
resetAndDeleteTask(childrenEnum.m_Tasks[i]);
}
HPMUniqueID taskID = session->TaskRefGetTask(taskRefID);
int workFlowID = session->TaskGetWorkflow(taskID);
if (workFlowID != -1)
{
//TODO: Actually reset the workflow to a state name.
session->TaskSetWorkflowStatus(taskID, 1, EHPMTaskSetStatusFlag_None);
}
HPMUniqueID proxyID = session->TaskGetProxy(taskID);
if (proxyID.IsValid())
session->TaskDelete(proxyID);
}
