/// <summary>
/// Search all work items
/// </summary>
/// <param name="store"></param>
/// <param name="iterationPath"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
public WorkItemTimeCollection(WorkItemStore store, string iterationPath, DateTime startDate, DateTime endDate)
{
this.IterationPath = iterationPath;
this.Data = new ObservableCollection<WorkItemTime>();
// Sets a list of dates to compute
_trackDates.Add(startDate.Date);
for (DateTime date = startDate.Date; date <= endDate.Date; date = date.AddDays(1))
{
_trackDates.Add(date.AddHours(23).AddMinutes(59));
}
// Gets all work items for each dates
foreach (DateTime asOfDate in _trackDates)
{
// Execute the query
var wiCollection = store.Query(this.GetQueryString(asOfDate));
// Iterate through all work items
foreach (WorkItem wi in wiCollection)
{
WorkItemTime time = new WorkItemTime(asOfDate, wi);
this.Data.Add(time);
}
}
}
private static WorkItem GetWorkItem(WorkItemStore workItemStore, string workItemType, int workItemId)
{
var queryResults = workItemStore.Query(string.Format(@"
Select [State], [Title]
From WorkItems
Where [Work Item Type] = '{0}' And Id = {1}
Order By [State] Asc, [Changed Date] Desc", workItemType, workItemId));
return queryResults.Count == 0 ? null : queryResults[0];
}
public IEnumerable<FeatureEntity> Get(string project, string rootQuery, string query)
{
if (string.IsNullOrEmpty(project)) throw new NullReferenceException("project");
if (string.IsNullOrEmpty(rootQuery)) throw new NullReferenceException("rootQuery");
if (string.IsNullOrEmpty(query)) throw new NullReferenceException("query");
var tpc = new TfsTeamProjectCollection(new Uri(TfsUrl));
var workItemStore = new WorkItemStore(tpc);
var queryRoot = workItemStore.Projects[project].QueryHierarchy;
var folder = (QueryFolder)queryRoot[rootQuery];
QueryDefinition queryDef = null;
foreach (var q in query.Split('/'))
{
queryDef = (QueryDefinition)folder[q];
}
if (queryDef == null)
{
throw new Exception(string.Format("Query {0} was not found on the root {1}", query, rootQuery));
}
var queryResults = workItemStore.Query(queryDef.QueryText);
var result = new List<FeatureEntity>();
foreach (WorkItem wi in queryResults)
{
try
{
var targetDate = (DateTime)wi["Target Date"];
var targetEndDate = (DateTime)wi["Target End Date"];
result.Add(new FeatureEntity
{
Start = targetDate,
End = targetEndDate,
Group = wi["Group"].ToString(),
Title = wi.Title,
Url = string.Format("{0}/{1}/_workitems#_a=edit&id={2}", TfsUrl, project, wi.Id),
Risk = wi["Risk"] as string,
Tags = wi.Tags,
Priority = wi["Priority"].ToString(),
Requestor = wi["Requestor"].ToString(),
WIId = wi.Id,
ChildUSCount = GetAtivatedChildUsCount(workItemStore, wi),
Status = wi["Status"].ToString()
});
}
catch (Exception ex)
{
}
}
return result;
}
private void btnMicrosoftTeamFoundationWorkItemTrackingClientWorkItem_Click(object sender, EventArgs e)
{
var tfs = new TfsTeamProjectCollection(new Uri(string.Format("http://{0}:8080/tfs", Environment.MachineName)), new TfsClientCredentials(new WindowsCredential(true), true));
var store = new WorkItemStore(tfs);
var workItemList = new List<WorkItem>(store.Query("SELECT Id, Title, [Work Item Type] FROM WorkItems").Cast<WorkItem>());
if (workItemList.Count > 0)
{
workItemList[0].PartialOpen();
workItemList[0].Title = string.Format("changed the title to show the date - {0}", DateTime.Now.ToString("dd MMM yyyy"));
workItemList[0].Description = "bob is the description";
}
Debugger.Break();
}
static void Main(string[] args)
{
var tpc = new TfsTeamProjectCollection(new Uri("http://exptfs:8080/tfs/geneva"));
var workItemStore = new WorkItemStore(tpc);
var queryRoot = workItemStore.Projects["PSG Dashboard"].QueryHierarchy;
var folder = (QueryFolder)queryRoot["Shared Queries"];
var queryDef = (QueryDefinition)folder["All Active Features"];
var queryResults = workItemStore.Query(queryDef.QueryText);
foreach (WorkItem q in queryResults)
{
Console.WriteLine(q.Tags);
}
}
private static WorkItemCollection GetWorkItemsFromLinkQuery(WorkItemStore store, Query workItemQuery,
IEnumerable<FieldDefinition> fieldDefinitions)
{
var workItemInfo = workItemQuery.RunLinkQuery();
var allWorkItemIds = workItemInfo.Select(wi => wi.TargetId).Distinct().ToArray();
if (fieldDefinitions == null)
{
return store.Query(allWorkItemIds, "SELECT * FROM WorkItems");
}
else
{
IEnumerable<string> numericFieldDefinitionNames =
fieldDefinitions.Select(fd => "[" + fd.ReferenceName + "]");
string select = "SELECT " + string.Join(", ", numericFieldDefinitionNames) + " FROM WorkItems";
var actualWorkItemQuery = new Query(store, select, allWorkItemIds);
return actualWorkItemQuery.RunQuery();
}
}
private static Dictionary<int, List<WorkItem>> getFeatureProductBacklogMapping(WorkItemStore query, List<int> relatedLinkIds)
{
Dictionary<int, List<WorkItem>> featureProductBacklogMapping = new Dictionary<int, List<WorkItem>>();
var wiqlBacklogs =
"SELECT [System.Id], [System.Title] FROM WorkItems WHERE [System.Id] IN ({0}) AND [System.WorkItemType] = '產品待處理項目'";
var queryBacklogs = query.Query(String.Format(wiqlBacklogs, String.Join(",", relatedLinkIds.ToArray())));
var backlogList = queryBacklogs.Cast<WorkItem>().ToList();
foreach (var productBacklog in backlogList)
{
foreach (
var linkId in
productBacklog.Links.OfType<RelatedLink>().Select(relatedLink => relatedLink.RelatedWorkItemId))
{
if (!featureProductBacklogMapping.ContainsKey(linkId))
{
featureProductBacklogMapping.Add(linkId, new List<WorkItem>());
}
featureProductBacklogMapping[linkId].Add(productBacklog);
}
}
return featureProductBacklogMapping;
}
/// <summary>
/// Gets a work item collection.
/// </summary>
/// <param name="wiqlQueryFormat">The WIQL query format string</param>
/// <param name="args">The arguments for the format string</param>
private WorkItemCollection GetWorkItemCollection(WorkItemStore store, string wiqlQueryFormat, params object[] args)
{
var wiql = string.Format(wiqlQueryFormat, args);
return store.Query(wiql);
}
/// <summary>
/// Gets the work item by its ID.
/// </summary>
/// <param name="workItemID">The work item ID.</param>
private WorkItem GetWorkItemByID(WorkItemStore store, string workItemID)
{
var wiql = String.Format(@"SELECT [System.ID],
[System.Title],
[System.Description],
[System.State]
{0}
FROM WorkItems
WHERE [System.ID] = '{1}'",
String.IsNullOrEmpty(this.CustomReleaseNumberFieldName)
? ""
: ", [" + this.CustomReleaseNumberFieldName + "]",
workItemID);
var workItemCollection = store.Query(wiql);
if (workItemCollection.Count == 0) throw new Exception("There is no work item with the ID: " + workItemID);
if (workItemCollection.Count > 1) throw new Exception("There are multiple issues with the same ID: " + workItemID);
return workItemCollection[0];
}
private WorkItemCollection Query4BBI(WorkItemStore _wis, string _teamProject, string _buildNumber)
{
StringBuilder _wiql = new StringBuilder();
_wiql.AppendLine("SELECT [System.ID], [System.Title]")
.AppendLine("FROM WORKITEMS")
.AppendLine("WHERE ([HIC.Build.Number] == '" + _buildNumber + "'")
.AppendLine("OR")
.AppendLine("[System.Title] == '" + _buildNumber + "')")
.AppendLine("AND")
.AppendLine("[System.TeamProject] == '" + _teamProject + "'")
.AppendLine("AND")
.AppendLine("[System.WorkItemType] == 'Build Backlog Item'");
return (_wis.Query(_wiql.ToString()));
}
private Dictionary<int, List<WorkItem>> getProductBacklogTaskMapping(WorkItemStore query)
{
var productBacklogTaskMapping = new Dictionary<int, List<WorkItem>>();
var wiqlTasks =
"SELECT [System.Id], [System.Title] FROM WorkItems WHERE [System.WorkItemType] = '工作' AND [System.State] = '完成' AND [Microsoft.VSTS.Common.StateChangeDate] >= @today - 30";
var queryTasks = query.Query(String.Format(wiqlTasks, howManyDays));
var taskList = queryTasks.Cast<WorkItem>().ToList();
convertTaskListIntoBacklogTaskMapping(taskList, productBacklogTaskMapping);
return productBacklogTaskMapping;
}
private static List<WorkItem> getFeatures(WorkItemStore query, Dictionary<int, List<WorkItem>> featureProductBacklogMapping)
{
List<WorkItem> features = new List<WorkItem>();
var wiqlFeatures =
"SELECT [System.Id], [System.Title] FROM WorkItems WHERE [System.Id] IN ({0}) AND [System.WorkItemType] = '特殊功能'";
var queryFeatures =
query.Query(String.Format(wiqlFeatures, String.Join(",", featureProductBacklogMapping.Keys.ToArray())));
features = queryFeatures.Cast<WorkItem>().ToList();
return features;
}
public static List<WorkItem> GetWorkItemListById(string idList)
{
_workItemStore = GetWorkItemStore;
WorkItemCollection workItemCollection = _workItemStore.Query(
"SELECT * FROM WorkItems WHERE [System.TeamProject] = 'LEAP'");
var _workItemList = new List<WorkItem>();
foreach(WorkItem wi in workItemCollection)
{
_workItemList.Add(wi);
}
return _workItemList;
}
static void Main(string[] args)
{
var options = new Options();
if (!CommandLine.Parser.Default.ParseArguments(args, options))
{
Console.WriteLine(options.GetUsage());
return;
}
// Connect to the desired Team Foundation Server
TfsTeamProjectCollection tfsServer = new TfsTeamProjectCollection(new Uri(options.ServerNameUrl));
// Authenticate with the Team Foundation Server
tfsServer.Authenticate();
// Get a reference to a Work Item Store
var workItemStore = new WorkItemStore(tfsServer);
var project = GetProjectByName(workItemStore, options.ProjectName);
if (project == null)
{
Console.WriteLine($"Could not find project '{options.ProjectName}'");
return;
}
var query = GetWorkItemQueryByName(workItemStore, project, options.QueryPath);
if (query == null)
{
Console.WriteLine($"Could not find query '{options.QueryPath}' in project '{options.ProjectName}'");
return;
}
var queryText = query.QueryText.Replace("@project", $"'{project.Name}'");
Console.WriteLine($"Executing query '{options.QueryPath}' with text '{queryText}'");
var count = workItemStore.QueryCount(queryText);
Console.WriteLine($"Exporting {count} work items");
var workItems = workItemStore.Query(queryText);
foreach (WorkItem workItem in workItems)
{
StoreAttachments(workItem, options.OutputPath);
}
}
private string GetIDClause(WorkItemStore store)
{
if (!string.IsNullOrEmpty(RequirementsQuery))
{
var query = FindQueryRecursive(store.Projects[ProjectName].QueryHierarchy);
if (query == null)
{
throw new ApplicationException(string.Format("Could not find query [{0}]", RequirementsQuery));
}
if (query.QueryType != QueryType.List)
{
throw new ApplicationException(string.Format("Query [{0}] is not a flat-list query - only flat-list queries are supported", RequirementsQuery));
}
var reqs = store.Query(query.QueryText, new Dictionary<string, object> { { "project", ProjectName } } );
var ids = reqs.Cast<WorkItem>().Select(w => w.Id.ToString()).Aggregate("", (w, s) => s + "," + w);
ids = ids.Substring(0, ids.Length - 1);
return string.Format("Source.[System.ID] IN ({0}) AND", ids);
}
return "";
}
private int GetAtivatedChildUsCount(WorkItemStore workItemStore, WorkItem wi)
{
var ids = new List<int>();
foreach (WorkItemLink item in wi.WorkItemLinks)
{
if (item.LinkTypeEnd.Name == "Child")
{
ids.Add(item.TargetId);
}
}
var query = string.Format("SELECT [System.Id],[System.WorkItemType],[System.Title] FROM WorkItems WHERE [System.TeamProject] = 'PSG Dashboard' AND [System.WorkItemType] = 'User Story' AND [System.State] = 'Active' AND [System.Id] In ({0})", GetFormatedIds(ids));
var workItems = workItemStore.Query(query);
var count = 0;
foreach (WorkItem tWi in workItems)
{
if (tWi.Type.Name == "User Story")
{
count++;
}
}
return count;
}
