public QueryHierarchyItem GetFolderByName()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
string folderName = _folder;
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
QueryHierarchyItem query = workItemTrackingClient.GetQueryAsync(projectId, folderName).Result;
//save the ID of the query we are getting
this.Context.SetValue <Guid>("$sampleQueryFolderId", query.Id);
Console.WriteLine("Id: {0}", query.Id);
Console.WriteLine("Name: {0}", query.Name);
Console.WriteLine("Path: {0}", query.Path);
return(query);
}
catch (AggregateException ex)
{
Console.WriteLine("Error getting query: " + ex.InnerException.Message);
return(null);
}
}
public QueryHierarchyItem CreateFolder()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
string queryPath = "Shared Queries";
QueryHierarchyItem postedQuery = new QueryHierarchyItem()
{
Name = "Sample Folder",
IsFolder = true
};
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
QueryHierarchyItem query = workItemTrackingClient.CreateQueryAsync(postedQuery, projectId, queryPath).Result;
Console.WriteLine("Folder Successfully Created");
Console.WriteLine("Id: {0}", query.Id);
Console.WriteLine("Name: {0}", query.Name);
Console.WriteLine("Path: {0}", query.Path);
return(query);
}
catch (AggregateException ex)
{
Console.WriteLine("Error creating folder: " + ex.InnerException.Message);
return(null);
}
}
public QueryHierarchyItem GetQueryOrFolderByName()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
string queryName = "Shared Queries/Current Iteration/Active Bugs";
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
QueryHierarchyItem query = workItemTrackingClient.GetQueryAsync(projectId, queryName).Result;
Console.WriteLine("Id: {0}", query.Id);
Console.WriteLine("Name: {0}", query.Name);
Console.WriteLine("Path: {0}", query.Path);
return(query);
}
catch (AggregateException ex)
{
Console.WriteLine("Error getting query: " + ex.InnerException.Message);
return(null);
}
}
static void Main(string[] args)
{
const String c_collectionUri = "https://dev.azure.com/microsoft";
const String c_projectName = "Edge";
const String c_repoName = "chromium.src";
// Interactively ask the user for credentials, caching them so the user isn't constantly prompted
VssCredentials creds = new VssClientCredentials();
creds.Storage = new VssClientCredentialStorage();
// Connect to Azure DevOps Services
VssConnection connection = new VssConnection(new Uri(c_collectionUri), creds);
// Get a GitHttpClient to talk to the Git endpoints
GitHttpClient gitClient = connection.GetClient <GitHttpClient>();
// Get data about a specific repository
var repo = gitClient.GetRepositoryAsync(c_projectName, c_repoName).Result;
// Create instance of WorkItemTrackingHttpClient using VssConnection
WorkItemTrackingHttpClient witClient = connection.GetClient <WorkItemTrackingHttpClient>();
// Get 2 levels of query hierarchy items
List <QueryHierarchyItem> queryHierarchyItems = witClient.GetQueriesAsync(c_projectName, depth: 2).Result;
// Search for 'My Queries' folder
QueryHierarchyItem myQueriesFolder = queryHierarchyItems.FirstOrDefault(qhi => qhi.Name.Equals("My Queries"));
if (myQueriesFolder != null)
{
var foo = "Skippy";
}
}
public QueryHierarchyItem GetDeletedQueryOrFolderById()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
string queryId = "2614c4de-be48-4735-9fdc-9656f55c495f";
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
QueryHierarchyItem query = workItemTrackingClient.GetQueryAsync(projectId, queryId, null, 1, true).Result;
Console.WriteLine("Id: {0}", query.Id);
Console.WriteLine("Name: {0}", query.Name);
Console.WriteLine("Path: {0}", query.Path);
return(query);
}
catch (AggregateException ex)
{
Console.WriteLine("Error getting query: " + ex.InnerException.Message);
return(null);
}
}
public QueryHierarchyItem RenameQueryOrFolder()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
Guid queryId = this.Context.GetValue <Guid>("$sampleQueryId");
QueryHierarchyItem queryUpdate = new QueryHierarchyItem()
{
Name = "Renamed Sample Query"
};
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
QueryHierarchyItem query = workItemTrackingClient.UpdateQueryAsync(queryUpdate, projectId, queryId.ToString()).Result;
Console.WriteLine("Query renamed successfully");
Console.WriteLine("Id: {0}", query.Id);
Console.WriteLine("Name: {0}", query.Name);
Console.WriteLine("Path: {0}", query.Path);
return(query);
}
catch (AggregateException ex)
{
Console.WriteLine("Error updating query: " + ex.InnerException.Message);
return(null);
}
}
public QueryHierarchyItem GetQueryOrFolderById()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
string queryId = "a2108d31-086c-4fb0-afda-097e4cc46df4"; //assigned to me query
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
QueryHierarchyItem query = workItemTrackingClient.GetQueryAsync(projectId, queryId).Result;
Console.WriteLine("Id: {0}", query.Id);
Console.WriteLine("Name: {0}", query.Name);
Console.WriteLine("Path: {0}", query.Path);
return(query);
}
catch (AggregateException ex)
{
Console.WriteLine("Error getting query: " + ex.InnerException.Message);
return(null);
}
}
public static async Task <QueryHierarchyItem> AddQueryAsync(this WorkItemTrackingHttpClient source, TeamProject project, QueryHierarchyItem query, CancellationToken cancellationToken)
{
//Have to build up the path to the query
var queryPath = new QueryPath(query.Path);
if (queryPath.Parent != null && !queryPath.Parent.IsRoot)
{
await source.AddFolderAsync(project, queryPath.Parent, cancellationToken : cancellationToken).ConfigureAwait(false);
}
//Clone the query
var newQuery = new QueryHierarchyItem()
{
Clauses = query.Clauses,
Columns = query.Columns,
FilterOptions = query.FilterOptions,
IsPublic = query.IsPublic,
LinkClauses = query.LinkClauses,
Name = query.Name,
QueryType = query.QueryType,
SortColumns = query.SortColumns,
SourceClauses = query.SourceClauses,
TargetClauses = query.TargetClauses,
Wiql = query.Wiql
};
return(await source.CreateQueryAsync(newQuery, project.Id, queryPath.Parent?.FullPath, cancellationToken : cancellationToken).ConfigureAwait(false));
}
public QueryHierarchyItem UpdateQuery()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
Guid queryId = this.Context.GetValue <Guid>("$sampleQueryId");
QueryHierarchyItem queryUpdate = new QueryHierarchyItem()
{
Wiql = "Select [System.Id], [System.Title], [System.State] From WorkItems Where [System.WorkItemType] = 'Bug' AND [System.State] = 'Active' order by [Microsoft.VSTS.Common.Priority] asc, [System.CreatedDate] desc"
};
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
QueryHierarchyItem query = workItemTrackingClient.UpdateQueryAsync(queryUpdate, projectId, queryId.ToString()).Result;
Console.WriteLine("Query updated successfully");
Console.WriteLine("Id: {0}", query.Id);
Console.WriteLine("Name: {0}", query.Name);
Console.WriteLine("Path: {0}", query.Path);
return(query);
}
catch (AggregateException ex)
{
Console.WriteLine("Error updating query: " + ex.InnerException.Message);
return(null);
}
}
public WorkItemListWindow(QueryHierarchyItem query, IList <WorkItem> workItems) : base("[" + query.Name + "] ")
{
X = 0;
Y = 2; // Leave one row for the toplevel menu
Width = Dim.Fill();
Height = Dim.Fill();
ColorScheme = Program.ColorScheme;
var scroll = new ListView
{
Width = Dim.Fill(),
Height = Dim.Fill(),
CanFocus = true
};
Add(scroll);
var fields = workItems
.Where(w => w.State() != "Closed")
.Select(i => new { Key = "[#" + i.Id + "] " + i.Title(), Value = i.State() })
.ToList();
var labelWidth = fields.Select(f => f.Value.Length).Max() + 2;
var lines = fields.Select(f => f.Value.PadLeft(labelWidth) + " | " + f.Key);
scroll.SetSource(new[] { string.Empty }.Concat(lines).ToList());
}
public QueryHierarchyItem GetDeletedQueryById()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
Guid queryId = this.Context.GetValue <Guid>("$sampleQueryId");
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
QueryHierarchyItem query = workItemTrackingClient.GetQueryAsync(projectId, queryId.ToString(), null, 1, true).Result;
Console.WriteLine("Id: {0}", query.Id);
Console.WriteLine("Name: {0}", query.Name);
Console.WriteLine("Path: {0}", query.Path);
return(query);
}
catch (AggregateException ex)
{
Console.WriteLine("Error getting query: " + ex.InnerException.Message);
return(null);
}
}
private async Task <QueryHierarchyItem> GetQueryFromTFS(Uri collectionUri, string projectName, List <string> queryFolderHierarchy)
{
witClient = await ConnectToTFS(collectionUri);
Console.WriteLine("Connected to TFS");
List <QueryHierarchyItem> queryHierarchyItems = this.witClient.GetQueriesAsync(projectName, depth: 2).Result;
// QueryHierarchyItem queryHierarchyItem = queryHierarchyItems.FirstOrDefault(qhi => qhi.Name.Equals("Shared Queries"));
QueryHierarchyItem queryHierarchyItem = queryHierarchyItems.FirstOrDefault();
for (int index = 0; index < queryFolderHierarchy.Count; index++)
{
if (index == 0)
{
queryHierarchyItem = queryHierarchyItems.FirstOrDefault(qhi => qhi.Name.Equals(queryFolderHierarchy[index]));
}
else
{
queryHierarchyItem = queryHierarchyItem.Children.FirstOrDefault(qhi => qhi.Name.Equals(queryFolderHierarchy[index]));
}
}
return(queryHierarchyItem);
}
public async Task <Guid> CreateStandardQuery2()
{
var witClient = _connection.GetClient <WorkItemTrackingHttpClient>();
var queries = await witClient.GetQueriesAsync(_teamProjectName, includeDeleted : false, depth : 2, expand : QueryExpand.Wiql);
var myQueries = queries.SingleOrDefault(item => item.Name == "My Queries");
var queryName = "Committed In Sprint";
var myNotDoneItemsQuery = myQueries.Children.SingleOrDefault(item => item.Name == queryName);
if (myNotDoneItemsQuery == null)
{
// if the 'REST Sample' query does not exist, create it.
myNotDoneItemsQuery = new QueryHierarchyItem
{
Name = queryName,
Wiql = "SELECT [System.Id],[System.WorkItemType],[System.Title],[System.AssignedTo],[System.State],[System.Tags],[System.IterationPath] FROM WorkItems WHERE [System.TeamProject] = @project AND [System.State] = 'Committed' AND [System.BoardColumn] = 'In Sprint' AND ([System.WorkItemType] = 'Bug' OR [System.WorkItemType] = 'Product Backlog Item') order by [System.ChangedDate] desc",
IsFolder = false
};
myNotDoneItemsQuery = await witClient.CreateQueryAsync(myNotDoneItemsQuery, _teamProjectName, myQueries.Name);
}
return(myNotDoneItemsQuery.Id);
}
public void Setup(string queryName, IEnumerable <string> tfsProjectNames, string query)
{
foreach (var tfsProjectName in tfsProjectNames)
{
var queryHierarchyItems = _witClient.GetQueriesAsync(tfsProjectName, depth: 2).Result;
var myQueriesFolder = queryHierarchyItems.FirstOrDefault(qhi => qhi.Name.Equals("My Queries"));
if (myQueriesFolder == null)
{
continue;
}
QueryHierarchyItem togglQuery = null;
if (myQueriesFolder.Children != null)
{
togglQuery = myQueriesFolder.Children.FirstOrDefault(qhi => qhi.Name.Equals(queryName));
}
if (togglQuery != null)
{
continue;
}
togglQuery = new QueryHierarchyItem
{
Name = queryName,
Wiql = query,
IsFolder = false
};
var result = _witClient.CreateQueryAsync(togglQuery, tfsProjectName, myQueriesFolder.Name).Result;
}
}
/// <summary>
/// Update Existing Query
/// </summary>
/// <param name="project"></param>
/// <param name="queryPath"></param>
/// <param name="newWiqlStr"></param>
static void EditQuery(string project, string queryPath, string newWiqlStr)
{
QueryHierarchyItem query = WitClient.GetQueryAsync(project, queryPath).Result;
query.Wiql = newWiqlStr;
query = WitClient.UpdateQueryAsync(query, project, queryPath).Result;
}
/// <summary>
/// Run stored query on azure devops service
/// </summary>
/// <param name="project">Team Project Name</param>
/// <param name="queryPath">Path to Query</param>
static List <int> RunStoredQuery(string project, string queryPath)
{
QueryHierarchyItem query = WitClient.GetQueryAsync(project, queryPath, QueryExpand.Wiql).Result;
string wiqlStr = query.Wiql;
return(GetQueryResult(wiqlStr, project));
}
/// <summary>
/// Downloads the work items for the query. This supports both flat
/// queries and hierarchical. For hierarchical, this will retrieve the
/// top two levels of the hierarchy of the query, which must be of type
/// "Tree of work items" with a tree type of "Parent/Child".
/// </summary>
public TeamResult RunQuery(string folderName, string queryName)
{
Console.WriteLine($"Running {folderName}/{queryName}");
// create instance of VssConnection using Personal Access Token
var connection = new VssConnection(new Uri(_collectionUrl), new VssBasicCredential(string.Empty, _personalAccessToken));
// get the client instance
var witClient = connection.GetClient <WorkItemTrackingHttpClient>();
// get 2 levels of the query hierarchy items
var queryHierarchyItems = witClient.GetQueriesAsync(_projectName, depth: 2).Result;
// holders for our return value
TeamResult teamResult = null;
// find the folder we're looking for
var queriesFolder = queryHierarchyItems.FirstOrDefault(qhi => qhi.Name.Equals(folderName));
if (queriesFolder != null)
{
// find the query we're looking for
QueryHierarchyItem query = null;
if (queriesFolder.Children != null)
{
query = queriesFolder.Children.FirstOrDefault(qhi => qhi.Name.Equals(queryName));
}
var result = witClient.QueryByIdAsync(query.Id).Result;
Console.Write($"Retrieving results ({result.QueryType} query)");
List <TeamItem> items = null;
switch (result.QueryType)
{
case QueryType.Tree:
items = ProcessHierarchyItems(result, witClient);
break;
case QueryType.Flat:
items = ProcessFlatItems(result, witClient);
break;
case QueryType.OneHop:
throw new NotImplementedException($"{nameof(QueryType.OneHop)} not supported");
}
teamResult = new TeamResult
{
Items = items,
QueryType = result.QueryType
};
}
Console.WriteLine("done");
return(teamResult);
}
public static async Task GetTask(VssConnection connection, string projeto)
{
WorkItemTrackingHttpClient witClient = connection.GetClient <WorkItemTrackingHttpClient>();
//WorkItem workitem = await witClient.GetWorkItemAsync(4621);
List <QueryHierarchyItem> queryHierarchyItems = witClient.GetQueriesAsync(projeto, depth: 2).Result;
QueryHierarchyItem myQueriesFolder = queryHierarchyItems.FirstOrDefault(qhi => qhi.Name.Equals("Shared Queries"));
if (myQueriesFolder != null)
{
string queryName = "Integra";
// See if our 'REST Sample' query already exists under 'My Queries' folder.
QueryHierarchyItem newBugsQuery = null;
if (myQueriesFolder.Children != null)
{
newBugsQuery = myQueriesFolder.Children.FirstOrDefault(qhi => qhi.Name.Equals(queryName));
}
if (newBugsQuery == null)
{
// if the 'REST Sample' query does not exist, create it.
newBugsQuery = new QueryHierarchyItem()
{
Name = queryName,
Wiql = "SELECT [System.Id],[System.WorkItemType],[System.Title],[System.AssignedTo],[System.State],[System.Tags] FROM WorkItems WHERE [System.TeamProject] = @project AND [System.WorkItemType] = 'Bug' AND [System.State] = 'New'",
IsFolder = false
};
newBugsQuery = witClient.CreateQueryAsync(newBugsQuery, projeto, myQueriesFolder.Name).Result;
}
WorkItemQueryResult result = witClient.QueryByIdAsync(newBugsQuery.Id).Result;
if (result.WorkItems.Any())
{
int skip = 0;
const int batchSize = 100;
IEnumerable <WorkItemReference> workItemRefs;
do
{
workItemRefs = result.WorkItems.Skip(skip).Take(batchSize);
if (workItemRefs.Any())
{
// get details for each work item in the batch
List <WorkItem> workItems = witClient.GetWorkItemsAsync(workItemRefs.Select(wir => wir.Id)).Result;
foreach (WorkItem workItem in workItems)
{
var teste = workItem;
}
}
skip += batchSize;
}while (workItemRefs.Count() == batchSize);
}
}
}
protected override QueryHierarchyItem DoNewItem()
{
var itemType = GetParameter <string>("ItemType").ToLower();
var isFolder = itemType.Equals("folder");
var item = isFolder? GetParameter <string>("Folder"): GetParameter <string>("Query");
var wiql = GetParameter <string>("Wiql");
var scope = GetParameter <string>("Scope").Equals("Personal") ? "My Queries" : "Shared Queries";
var force = GetParameter <bool>("Force");
var(_, tp) = GetCollectionAndProject();
var fullPath = NodeUtil.NormalizeNodePath(item, tp.Name, scope, includeScope: true, separator: '/');
var queryName = Path.GetFileName(fullPath);
var parentPath = Path.GetDirectoryName(fullPath);
var existingItem = GetItem <QueryHierarchyItem>();
if (existingItem != null && isFolder)
{
Log("Folder already exists.");
if (!force)
{
throw new Exception($"A folder with the specified name '{fullPath}' already exists.");
}
return(existingItem);
}
if (!ShouldProcess(tp, $"{(existingItem == null ? "Create" : "Overwrite")} " +
$"work item {itemType} '{fullPath}'"))
{
return(null);
}
var client = GetClient <WorkItemTrackingHttpClient>();
var newItem = new QueryHierarchyItem()
{
Name = queryName,
Path = parentPath,
IsFolder = isFolder,
Wiql = wiql
};
var parentFolder = GetItem <QueryHierarchyItem>(new{ Folder = parentPath, ItemType = "Folder" }) ??
NewItem <QueryHierarchyItem>(new { Folder = parentPath, ItemType = "Folder" });
this.Log($"Creating query '{queryName}' in folder '{parentPath}'");
var result = client.CreateQueryAsync(newItem, tp.Name, parentFolder.Id.ToString())
.GetResult($"Error creating new work item {itemType} '{fullPath}'");
return(result);
}
/// <summary>
/// Create new query
/// </summary>
/// <param name="project"></param>
/// <param name="queryPath"></param>
/// <param name="QueryName"></param>
/// <param name="wiqlStr"></param>
static void AddQuery(string project, string queryPath, string QueryName, string wiqlStr)
{
QueryHierarchyItem query = new QueryHierarchyItem();
query.QueryType = QueryType.Flat;
query.Name = QueryName;
query.Wiql = wiqlStr;
query = WitClient.CreateQueryAsync(query, project, queryPath).Result;
}
public List <Feature> GetFeatures(DateTime fromdate, DateTime?toDate)
{
List <Feature> features = new List <Feature>();
QueryHierarchyItem featuresQuery = _queriesFolder.Children?.FirstOrDefault(qhi => qhi.Name.Equals(FeaturesQueryName, StringComparison.InvariantCulture));
if (featuresQuery == null)
{
featuresQuery = new QueryHierarchyItem()
{
Name = FeaturesQueryName,
Wiql = string.Format(CultureInfo.InvariantCulture,
"SELECT [System.Id]," +
"[System.IterationId]," +
"[System.CreatedDate]," +
"[System.Title]," +
"[System.State]" +
"FROM WorkItems WHERE [System.TeamProject] = @project AND [System.WorkItemType] = 'Feature' AND [System.State] <> 'Removed' AND [System.CreatedDate] >= '{0:MM/dd/yyyy}'", fromdate),
IsFolder = false
};
if (toDate?.Year != 1)
{
featuresQuery.Wiql += string.Format(CultureInfo.InvariantCulture, Environment.NewLine + "AND [System.CreatedDate] <= '{1:MM/dd/yyyy}'", toDate);
}
}
featuresQuery = _workItemTrackingClient.CreateQueryAsync(featuresQuery, OnlineTfsTeamProjectName, _queriesFolder.Id.ToString()).Result;
WorkItemQueryResult featuresQueryResult = _workItemTrackingClient.QueryByIdAsync(featuresQuery.Id).Result;
if (featuresQueryResult.WorkItems.Any())
{
int skip = 0;
const int batchSize = 100;
IEnumerable <WorkItemReference> workItemRefs;
do
{
workItemRefs = featuresQueryResult.WorkItems.Skip(skip).Take(batchSize);
if (workItemRefs.Any())
{
List <string> columnptions = new List <string>
{
"System.Id", "System.IterationId", "System.CreatedDate", "System.Title", "System.State"
};
List <WorkItem> workItems = _workItemTrackingClient.GetWorkItemsAsync(workItemRefs.Select(wir => wir.Id), columnptions).Result;
foreach (WorkItem workItem in workItems)
{
Feature feature = new Feature();
FillFeaturesData(feature, workItem.Fields);
features.Add(feature);
}
}
skip += batchSize;
} while (workItemRefs.Count() == batchSize);
}
return(features);
}
public QueryViewModel(
MainViewModel mainViewModel,
String parentPath,
QueryHierarchyItem queryHierarchyItem)
{
Query = queryHierarchyItem;
FullPath = (parentPath + '/' + queryHierarchyItem.Name).Trim('/');
Execute = new RelayCommand(ExecuteMethod);
SelectAll = new RelayCommand(ExecuteSelectAll);
_mainViewModel = mainViewModel;
}
private VstsQuery ToVstsQuery(QueryHierarchyItem queryHierarchyItem)
{
return(new VstsQuery
{
Id = queryHierarchyItem.Id,
Name = queryHierarchyItem.Name,
IsFolder = queryHierarchyItem.IsFolder ?? false,
HasChildren = queryHierarchyItem.HasChildren ?? false,
Children = queryHierarchyItem.Children?.Select(ToVstsQuery).OrderBy(query => query.Name).ToArray()
});
}
public QueryHierarchyItem GetQueryByName(string project, string queryName)
{
VssConnection connection = new VssConnection(_uri, _credentials);
WorkItemTrackingHttpClient workItemTrackingHttpClient = connection.GetClient <WorkItemTrackingHttpClient>();
QueryHierarchyItem query = workItemTrackingHttpClient.GetQueryAsync(project, queryName).Result;
if (query != null)
{
return(query);
}
else
{
throw new NullReferenceException("Query '" + queryName + "' not found in project");
}
}
public QueryHierarchyItem GetQueryByName(string project, string queryName)
{
using (WorkItemTrackingHttpClient workItemTrackingHttpClient = new WorkItemTrackingHttpClient(_uri, _credentials))
{
QueryHierarchyItem query = workItemTrackingHttpClient.GetQueryAsync(project, queryName).Result;
if (query != null)
{
return(query);
}
else
{
throw new NullReferenceException("Query '" + queryName + "' not found in project");
}
}
}
public async Task <List <StatusRecord> > GetDataFromTFS(Uri collectionUri, string projectName, List <string> queryFolderHierarchy)
{
QueryHierarchyItem query = await GetQueryFromTFS(collectionUri, projectName, queryFolderHierarchy);
Console.WriteLine("Retrieved the Query");
WorkItemQueryResult queryResult = this.witClient.QueryByIdAsync(query.Id).Result;
Console.WriteLine("Executed the Query");
List <StatusRecord> statusRecords = await MapQueryResultToStatusRecords(queryResult);
PrintStatusRecords(statusRecords);
return(statusRecords);
}
public void UnDeleteQueryOrFolder()
{
Guid projectId = ClientSampleHelpers.FindAnyProject(this.Context).Id;
Guid queryId = this.Context.GetValue <Guid>("$sampleQueryId");
QueryHierarchyItem queryUpdate = new QueryHierarchyItem()
{
IsDeleted = false
};
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
workItemTrackingClient.UpdateQueryAsync(queryUpdate, projectId, queryId.ToString(), true);
Console.WriteLine("Query/folder deleted");
}
public QueryHierarchyItem GetQueryByName()
{
string project = ClientSampleHelpers.FindAnyProject(this.Context).Name;
string queryName = "Shared Queries/Current Sprint";
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
QueryHierarchyItem query = workItemTrackingClient.GetQueryAsync(project, queryName).Result;
if (query != null)
{
return(query);
}
else
{
throw new Exception(String.Format("Query '{0}' not found", queryName));
}
}
private async Task <QueryHierarchyItem> InternalGetStoredQueriesAsync(string projectName, QueryHierarchyItem parent, bool?includeDeleted, CancellationToken cancellationToken)
{
if (parent.Children == null)
{
using var mc = log?.Enter(LogLevel.RawApis, new object[] { projectName, parent.Path, QueryExpand.All, 2, includeDeleted, null, cancellationToken }, "GetQueryAsync");
parent = await WorkItemClient.GetQueryAsync(projectName, parent.Path, QueryExpand.All, depth : 2, includeDeleted, userState : null, cancellationToken);
}
for (int i = 0; i < parent.Children.Count; i++)
{
QueryHierarchyItem item = parent.Children[i];
if (item.HasChildren == true)
{
parent.Children[i] = await InternalGetStoredQueriesAsync(projectName, item, includeDeleted, cancellationToken);
}
}
return(parent);
}
/// <summary>
/// Get Content from Query Folders
/// </summary>
/// <param name="project">Team Project Name</param>
/// <param name="queries">Folder List</param>
static void GetFolderContent(string project, List <QueryHierarchyItem> queries)
{
foreach (QueryHierarchyItem query in queries)
{
if (query.IsFolder != null && (bool)query.IsFolder)
{
Console.WriteLine("Folder: " + query.Path);
if ((bool)query.HasChildren)
{
QueryHierarchyItem detiledQuery = WitClient.GetQueryAsync(project, query.Path, QueryExpand.All, 1).Result;
GetFolderContent(project, detiledQuery.Children.ToList());
}
}
else
{
Console.WriteLine("Query: " + query.Path);
}
}
}
