/// <summary> /// Define Query Folders under TreeView /// </summary> /// <param name="query">Query Folder</param> /// <param name="father"></param> void DefineFolder(QueryFolder query, TreeViewItem father) { father.IsExpanded = true; var item = new TreeViewItem { IsExpanded = true }; var type = QueryTypes.Folder; if (query.IsPersonal) { type = QueryTypes.MyQ; } else if (query.Name == "Team Queries") { type = QueryTypes.TeamQ; } item.Header = CreateTreeItem(query.Name, type); father.Items.Add(item); foreach (var subQuery in query) { if (subQuery.GetType() == typeof(QueryFolder)) { DefineFolder((QueryFolder)subQuery, item); } else { DefineQuery((QueryDefinition)subQuery, item); } } }
private string GetQueryText(QueryFolder queryFolder, string queryFullname) { string result = null; string thisLevelName = queryFullname.TrimStart('/'); string queryPathLeft = string.Empty; if (thisLevelName.Contains("/")) { thisLevelName = thisLevelName.Remove(thisLevelName.IndexOf("/")); queryPathLeft = queryFullname.TrimStart('/'); queryPathLeft = queryPathLeft.Remove(0, thisLevelName.Length); } if (queryFolder.Name == thisLevelName) { foreach (QueryItem query in queryFolder) { if (query is QueryFolder) { result = GetQueryText(query as QueryFolder, queryPathLeft); } else if (query is QueryDefinition) { if (query.Name == queryPathLeft.TrimStart('/')) { result = (query as QueryDefinition).QueryText; } } if (result != null) { break; } } } return result; }
public void CancelCancelsTheView() { // Arrange QueryFolder data = this.SetupDummyQueryHierarchyOnProject(); this.sut.Start(); // Act this.sut.Cancel(); // Assert this.mockView.Verify(view => view.Cancel(), Times.Once(), "The view was not cancelled."); }
public void QueryTest() { // arrange string queryTitle = "TestTitle"; string queryCommand = "SELECT [System.Title], [System.State] FROM WorkItems WHERE [System.AssignedTo] = @me"; QueryFolder testQueryFolder = new QueryFolder("TestQueryFolder"); // act tfsHelperFunctions.AddNewQuery(queryTitle, queryCommand, testQueryFolder); // assert }
private static QueryDefinition CreateNewQuery(Project workItemProject, QueryFolder myQueriesFolder, string queryName) { QueryDefinition newBugsQuery = new QueryDefinition(queryName, @"SELECT [System.Id],[System.WorkItemType], [System.Title],[System.AssignedTo],[System.State],[System.Tags] FROM WorkItems WHERE[System.WorkItemType] = '{0}' AND[System.State] = 'New'"); myQueriesFolder.Add(newBugsQuery); workItemProject.QueryHierarchy.Save(); return(newBugsQuery); }
public void SetTeamQueries(QueryHierarchy sourceQueryCol, string sourceProjectName) { foreach (QueryFolder queryFolder in sourceQueryCol) { if (queryFolder.Name == "Team Queries" || queryFolder.Name == "Shared Queries") { QueryFolder teamQueriesFolder = (QueryFolder)store.Projects[projectName].QueryHierarchy["Shared Queries"]; SetQueryItem(queryFolder, teamQueriesFolder, sourceProjectName); QueryFolder test = (QueryFolder)store.Projects[projectName].QueryHierarchy["Shared Queries"]; } } }
internal static QueryFolderWrapper GetInstance() { QueryFolder real = default(QueryFolder); RealInstanceFactory(ref real); var instance = (QueryFolderWrapper)QueryFolderWrapper.GetWrapper(real); InstanceFactory(ref instance); if (instance == null) { Assert.Inconclusive("Could not Create Test Instance"); } return(instance); }
private void SetQueryItem(QueryFolder queryFolder, QueryFolder parentFolder, string sourceProjectName) { QueryItem newItem = null; foreach (QueryItem subQuery in queryFolder) { try { if (subQuery.GetType() == typeof(QueryFolder)) { newItem = new QueryFolder(subQuery.Name); if (!parentFolder.Contains(subQuery.Name)) { parentFolder.Add(newItem); store.Projects[projectName].QueryHierarchy.Save(); SetQueryItem((QueryFolder)subQuery, (QueryFolder)newItem, sourceProjectName); } else { logger.Info(String.Format("Query Folder {0} already exists", subQuery)); } } else { QueryDefinition oldDef = (QueryDefinition)subQuery; string queryText = oldDef.QueryText.Replace(sourceProjectName, projectName).Replace("User Story", "Product Backlog Item").Replace("Issue", "Impediment"); newItem = new QueryDefinition(subQuery.Name, queryText); if (!parentFolder.Contains(subQuery.Name)) { parentFolder.Add(newItem); store.Projects[projectName].QueryHierarchy.Save(); } else { logger.Info(String.Format("Query Definition {0} already exists", subQuery)); } } } catch (Exception ex) { if (newItem != null) { newItem.Delete(); } logger.Info(String.Format("Error creating Query: {0} : {1}", subQuery, ex.Message)); continue; } } }
public bool TryAddNewQueryFolder(out QueryFolder childFolder, TfsTeamProjectCollection tfsTeamProjectCollection, Project teamProject, Guid parentFolderId) { try { childFolder = _teamPilgrimTfsService.AddNewQueryFolder(tfsTeamProjectCollection, teamProject, parentFolderId); return true; } catch (Exception ex) { LastException = ex; } childFolder = null; return false; }
/// <summary> /// Finds the specified query item recursively. /// </summary> /// <param name="queryItem">The query item for which to search.</param> /// <param name="folder">The folder in which to search.</param> /// <returns></returns> private QueryItem Find(QueryItem queryItem, QueryFolder folder) { foreach (QueryItem item in folder) { if (item.Path == queryItem.Path) { return(item); } if (queryItem.Path.StartsWith(item.Path) && item is QueryFolder) { return(Find(queryItem, item as QueryFolder)); } } return(null); }
public bool TryAddNewQueryFolder(out QueryFolder childFolder, TfsTeamProjectCollection tfsTeamProjectCollection, Project teamProject, Guid parentFolderId) { try { childFolder = _teamPilgrimTfsService.AddNewQueryFolder(tfsTeamProjectCollection, teamProject, parentFolderId); return(true); } catch (Exception ex) { LastException = ex; } childFolder = null; return(false); }
/// <summary> /// Copies the collection to the destination foloder. /// </summary> /// <param name="collection">The collection.</param> /// <param name="destinationFolder">The destination folder.</param> private void CopyQueryHierarchy(IEnumerable <QueryItem> collection, QueryFolder destinationFolder) { foreach (QueryItem item in collection) { if (item is QueryFolder) { QueryFolder copiedFolder = new QueryFolder(item.Name, destinationFolder); CopyQueryHierarchy(item as IEnumerable <QueryItem>, copiedFolder); } if (item is QueryDefinition) { QueryDefinition copiedDefinition = new QueryDefinition(item.Name, ((QueryDefinition)item).QueryText, destinationFolder); } } }
public WorkItemQueryFolderModel(IWorkItemQueryCommandModel workItemQueryCommandModel, Project project, int depth, QueryFolder queryFolder, IEnumerable<WorkItemQueryChildModel> childQueryItemViewModels, QueryFolderTypeEnum? queryFolderType) : base(workItemQueryCommandModel, depth) { Project = project; QueryFolder = queryFolder; QueryFolderType = queryFolderType; var childQueryItemViewModelsArray = childQueryItemViewModels.ToArray(); foreach (var workItemQueryChildModel in childQueryItemViewModelsArray) { workItemQueryChildModel.ParentQueryFolder = this; } QueryItems = new ObservableCollection<WorkItemQueryChildModel>(childQueryItemViewModelsArray); }
public WorkItemQueryFolderModel(IWorkItemQueryCommandModel workItemQueryCommandModel, Project project, int depth, QueryFolder queryFolder, IEnumerable <WorkItemQueryChildModel> childQueryItemViewModels, QueryFolderTypeEnum?queryFolderType) : base(workItemQueryCommandModel, depth) { Project = project; QueryFolder = queryFolder; QueryFolderType = queryFolderType; var childQueryItemViewModelsArray = childQueryItemViewModels.ToArray(); foreach (var workItemQueryChildModel in childQueryItemViewModelsArray) { workItemQueryChildModel.ParentQueryFolder = this; } QueryItems = new ObservableCollection <WorkItemQueryChildModel>(childQueryItemViewModelsArray); }
public void QueryById() { // Querying by ID doesn't really exist in the WIT model like it does in REST. // In this case, we are looking up the query definition by its ID and then creating a new Query with its corresponding wiql // Get an existing query and associated ID for proof of concept. If we already have a query guid, we can skip this block. QueryHierarchy queryHierarchy = TeamProject.QueryHierarchy; var queryFolder = queryHierarchy as QueryFolder; QueryItem queryItem = queryFolder?.Where(f => f.IsPersonal).FirstOrDefault(); QueryFolder myQueriesFolder = queryItem as QueryFolder; if (myQueriesFolder != null && myQueriesFolder.Count > 0) { var queryId = myQueriesFolder.First().Id; // Replace this value with your query id // Get the query definition var queryDefinitionById = WIStore.GetQueryDefinition(queryId); var context = new Dictionary <string, string>() { { "project", TeamProject.Name } }; // Obtain query results using the query definition's QueryText Query obj = new Query(this.WIStore, queryDefinitionById.QueryText, context); WorkItemCollection queryResults = obj.RunQuery(); Console.WriteLine($"Query with name: '{queryDefinitionById.Name}' and id: '{queryDefinitionById.Id}' returned {queryResults.Count} results:"); if (queryResults.Count > 0) { foreach (WorkItem result in queryResults) { Console.WriteLine($"WorkItem Id: '{result.Id}' Title: '{result.Title}'"); } } else { Console.WriteLine($"Query with name: '{queryDefinitionById.Name}' and id: '{queryDefinitionById.Id}' did not return any results."); Console.WriteLine($"Try assigning work items to yourself or following work items and run the sample again."); } } else { Console.WriteLine("My Queries haven't been populated yet. Open up the Queries page in the browser to populate these, and then run the sample again."); } Console.WriteLine(); }
/// <summary> /// Add Query Definition under a specific Query Folder. /// </summary> /// <param name="targetHierarchy">The object that represents the whole of the target query tree</param> /// <param name="query">Query Definition - Contains the Query Details</param> /// <param name="QueryFolder">Parent Folder</param> void MigrateQuery(QueryHierarchy targetHierarchy, QueryDefinition query, QueryFolder parentFolder) { if (parentFolder.FirstOrDefault(q => q.Name == query.Name) != null) { this.totalQueriesSkipped++; Trace.WriteLine($"Skipping query '{query.Name}' as already exists"); } else { // Sort out any path issues in the quertText var fixedQueryText = query.QueryText.Replace($"'{Engine.Source.Config.Project}", $"'{Engine.Target.Config.Project}"); // the ' should only items at the start of areapath etc. if (config.PrefixProjectToNodes) { // we need to inject the team name as a folder in the structure too fixedQueryText = fixedQueryText.Replace($"{Engine.Target.Config.Project}\\", $"{Engine.Target.Config.Project}\\{Engine.Source.Config.Project}\\"); } if (config.SourceToTargetFieldMappings != null) { foreach (var sourceField in config.SourceToTargetFieldMappings.Keys) { fixedQueryText = query.QueryText.Replace($"{sourceField}", $"'{config.SourceToTargetFieldMappings[sourceField]}"); } } // you cannot just add an item from one store to another, we need to create a new object var queryCopy = new QueryDefinition(query.Name, fixedQueryText); this.totalQueriesAttempted++; Trace.WriteLine($"Migrating query '{query.Name}'"); parentFolder.Add(queryCopy); try { targetHierarchy.Save(); // moved the save here for better error message this.totalQueriesMigrated++; } catch (Exception ex) { this.totalQueryFailed++; Trace.WriteLine($"Error saving query '{query.Name}', probably due to invalid area or iteration paths"); Trace.WriteLine($"Source Query: '{query}'"); Trace.WriteLine($"Target Query: '{fixedQueryText}'"); Trace.WriteLine(ex.Message); targetHierarchy.Refresh(); // get the tree without the last edit } } }
public QueryFolder AddNewQueryFolder(TfsTeamProjectCollection teamProjectCollection, Project teamProject, Guid parentFolderId) { this.Logger().Trace("AddNewQueryFolder"); var workItemStore = GetWorkItemStore(teamProjectCollection); var queryHierarchy = workItemStore.GetQueryHierarchy(teamProject); var loadedParentFolder = queryHierarchy.Find(parentFolderId) as QueryFolder; var queryFolder = new QueryFolder("New Folder"); Debug.Assert(loadedParentFolder != null, "loadedParentFolder != null"); loadedParentFolder.Add(queryFolder); queryHierarchy.Save(); return(queryFolder); }
void CreateFolderHyerarchy(string[] toCreate, QueryItem currentItem, int focus = 0) { if (currentItem is QueryFolder) { QueryFolder currentFolder = (QueryFolder)currentItem; if (!currentFolder.Contains(toCreate[focus])) { currentFolder.Add(new QueryFolder(toCreate[focus])); Trace.WriteLine(string.Format(" Created: {0}", toCreate[focus])); } if (toCreate.Length != focus + 1) { CreateFolderHyerarchy(toCreate, currentFolder[toCreate[focus]], focus + 1); } } }
public void CopyTest() { // arrange QueryFolder testFolderOne = new QueryFolder("TestFolderOne"); QueryFolder testFolderTwo = new QueryFolder("TestFolderTwo"); string queryTitle = "TestTitle"; string queryCommand = "SELECT [System.Title], [System.State] FROM WorkItems WHERE [System.AssignedTo] = @me"; // act tfsHelperFunctions.AddNewQuery(queryTitle, queryCommand, testFolderOne); tfsHelperFunctions.CopyPreviousQueryFolderContent(testFolderOne, testFolderTwo); // assert }
private List <QueryDefinition> GetQueries(QueryFolder root) { var queries = new List <QueryDefinition>(); foreach (var query in root) { if (typeof(QueryFolder) == query.GetType()) { queries.AddRange(GetQueries((QueryFolder)query)); } else { queries.Add((QueryDefinition)query); } } return(queries); }
private void CreateFolderHyerarchy(string[] toCreate, QueryItem currentItem, int focus = 0) { if (currentItem is QueryFolder) { QueryFolder currentFolder = (QueryFolder)currentItem; if (!currentFolder.Contains(toCreate[focus])) { currentFolder.Add(new QueryFolder(toCreate[focus])); Log.LogInformation(" Created: {0}", toCreate[focus]); } if (toCreate.Length != focus + 1) { CreateFolderHyerarchy(toCreate, currentFolder[toCreate[focus]], focus + 1); } } }
public QueryFolder AddNewQueryFolder(TfsTeamProjectCollection teamProjectCollection, Project teamProject, Guid parentFolderId) { this.Logger().Trace("AddNewQueryFolder"); var workItemStore = GetWorkItemStore(teamProjectCollection); var queryHierarchy = workItemStore.GetQueryHierarchy(teamProject); var loadedParentFolder = queryHierarchy.Find(parentFolderId) as QueryFolder; var queryFolder = new QueryFolder("New Folder"); Debug.Assert(loadedParentFolder != null, "loadedParentFolder != null"); loadedParentFolder.Add(queryFolder); queryHierarchy.Save(); return queryFolder; }
private static QueryDefinition FindQuery(string queryPath, QueryFolder queryFolder) { var parts = queryPath.Split('\\'); for (int i = 0; i < parts.Length - 1; i++) { queryFolder = queryFolder[parts[i]] as QueryFolder; } string queryName = parts[parts.Length - 1]; if (!queryFolder.Contains(queryName)) { return(null); } var queryDef = queryFolder[queryName] as QueryDefinition; return(queryDef); }
private static void DefineFolder(QueryFolder query, TfsQueryTreeItemViewModel parent, ICommand command) { TfsQueryTreeItemViewModel firstLevelFolder = new TfsFolderQueryItem(parent, query.Name);; parent.Children.Add(firstLevelFolder); foreach (QueryItem subQuery in query) { if (subQuery.GetType() == typeof(QueryFolder)) { DefineFolder((QueryFolder)subQuery, firstLevelFolder, command); } else { DefineQuery((QueryDefinition)subQuery, firstLevelFolder, command); } } }
/// <summary> /// Helper function for overloaded GetAllTeamQueries function, grabs queries from specified folder /// </summary> /// <param name="folder"></param> /// <returns></returns> private static List <QueryDefinition> GetAllTeamQueries(QueryFolder folder) { List <QueryDefinition> queryList = new List <QueryDefinition>(); foreach (QueryItem queryItem in folder) { if (queryItem is QueryFolder) { queryList.AddRange(GetAllTeamQueries(queryItem as QueryFolder)); } else { queryList.Add(queryItem as QueryDefinition); } } return(queryList); }
public List <string> GetAvailableQueries(string projectName, string queryFolderName) { List <string> result = new List <string>(); try { QueryHierarchy queryRoot = store.Projects[projectName].QueryHierarchy; var entity = queryRoot[queryFolderName]; QueryFolder root = (QueryFolder)queryRoot[queryFolderName]; var queries = GetQueries(root); return(queries.Select(o => o.Name).ToList()); } catch (Exception ex) { Exception exception = new Exception("Make sure you set TfsURL before calling this method, and that the query is valid. Check inner exception for more details.", ex); throw exception; } }
private IEnumerable GetAllContainedQueriesList(QueryFolder queryFolder) { var queryItems = new List <QueryItem>(); foreach (var item in queryFolder) { var type = item.GetType(); if (type.Name == "QueryFolder") { IEnumerable subQueryItems = GetAllContainedQueriesList(item as QueryFolder); queryItems.AddRange(subQueryItems.Cast <QueryItem>()); } else { queryItems.Add(item); } } return(queryItems); }
/// <summary> /// Copies all queries from specified folder, adds them to specified folder without /// modifying the former folder's queries /// </summary> /// <param name="oldFolder"></param> /// <param name="newFolder"></param> public void CopyPreviousQueryFolderContent(QueryFolder oldFolder, QueryFolder newFolder) { // List of all the old folder's queries List<QueryDefinition> oldQueryList = new List<QueryDefinition>(); oldQueryList.AddRange(GetAllTeamQueries(oldFolder)); // List for the new folder's queries, copy of the previous list List<QueryDefinition> newQueryList = new List<QueryDefinition>(); newQueryList.AddRange(oldQueryList); // iterates through each query in copied list, adds newly constructed queries in new folder foreach (var queryItem in newQueryList) { QueryDefinition queryDefinition = new QueryDefinition(queryItem.Name, queryItem.QueryText); newFolder.Add(queryDefinition); } newFolder.Project.QueryHierarchy.Save(); }
private static IEnumerable<QueryDefinition> GetQueryDefinitions(QueryFolder rootFolder) { var queryDefinitions = new List<QueryDefinition>(); foreach (QueryItem queryItem in rootFolder) { var subFolder = queryItem as QueryFolder; if (subFolder != null) { queryDefinitions.AddRange(GetQueryDefinitions(subFolder)); } var queryDefinition = queryItem as QueryDefinition; if (queryDefinition != null) { queryDefinitions.Add(queryDefinition); } } return queryDefinitions; }
static QueryDefinition GetWorkItemQueryByName(QueryFolder folder, string queryPath) { foreach (var item in folder) { Console.WriteLine($"{item.Name} {item.Path}"); if (item.Path == queryPath && item is QueryDefinition) return item as QueryDefinition; if (!(item is QueryFolder)) continue; var query = GetWorkItemQueryByName(item as QueryFolder, queryPath); if (query != null) return query; } return null; }
/// <summary> /// Execute a WIQL query to return a list of bugs using the .NET client library /// </summary> /// <returns>List of Microsoft.TeamFoundation.WorkItemTracking.WebApi.Models.WorkItem</returns> public List <IDefect> GetMyTasks() { List <IDefect> result = new List <IDefect>(); using (TfsTeamProjectCollection service = Service) { WorkItemStore workItemStore = service.GetService <WorkItemStore>(); // get the WorkItemStore service // get the project context for the work item store Project workItemProject = workItemStore.Projects[TeamProjectName]; // search for the 'My Queries' folder QueryFolder myQueriesFolder = workItemProject .QueryHierarchy .FirstOrDefault(qh => qh is QueryFolder && qh.IsPersonal) as QueryFolder; if (myQueriesFolder != null) { // search for the 'SOAP Sample' query QueryDefinition newBugsQuery = myQueriesFolder .FirstOrDefault(qi => qi is QueryDefinition && qi.Name.Equals(myTaskQueryName)) as QueryDefinition; if (newBugsQuery == null) { return(result); } // run the 'SOAP Sample' query WorkItemCollection workItems = workItemStore.Query(newBugsQuery.GetQuery(project: TeamProjectName, user: workItemStore.UserIdentityName)); foreach (WorkItem workItem in workItems) { result.Add(ToDefectItem(workItem)); } } return(result); } }
public static Tuple <Project, QueryFolder> GetShareQueryFolder(string targetTfsCollection, string targetTfsProject) { var targetTfsTeamProjectCollection = GetTfsTeamProjectCollection(targetTfsCollection); WorkItemStore targetWorkItemStore = targetTfsTeamProjectCollection.GetService <WorkItemStore>(); Project targetProject = targetWorkItemStore.Projects[targetTfsProject]; QueryFolder targetQueryFolder = null; var targetQueryHierarchy = targetProject.QueryHierarchy; foreach (var targetSubItem in targetQueryHierarchy) { targetQueryFolder = targetSubItem as QueryFolder; if (targetQueryFolder != null && targetQueryFolder.Name == "Shared Queries") { break; } } return(new Tuple <Project, QueryFolder>(targetProject, targetQueryFolder)); }
/// <summary> /// Copies all queries from specified folder, adds them to specified folder without /// modifying the former folder's queries /// </summary> /// <param name="oldFolder"></param> /// <param name="newFolder"></param> public void CopyPreviousQueryFolderContent(QueryFolder oldFolder, QueryFolder newFolder) { // List of all the old folder's queries List <QueryDefinition> oldQueryList = new List <QueryDefinition>(); oldQueryList.AddRange(GetAllTeamQueries(oldFolder)); // List for the new folder's queries, copy of the previous list List <QueryDefinition> newQueryList = new List <QueryDefinition>(); newQueryList.AddRange(oldQueryList); // iterates through each query in copied list, adds newly constructed queries in new folder foreach (var queryItem in newQueryList) { QueryDefinition queryDefinition = new QueryDefinition(queryItem.Name, queryItem.QueryText); newFolder.Add(queryDefinition); } newFolder.Project?.QueryHierarchy.Save(); }
private void btnSelectProject_Click(object sender, EventArgs e) { var tfsPp = new TeamProjectPicker(TeamProjectPickerMode.SingleProject, false, new UICredentialsProvider()); DialogResult result = tfsPp.ShowDialog(); if (result == DialogResult.OK && tfsPp.SelectedProjects != null && tfsPp.SelectedProjects.FirstOrDefault() != null) { ClearExisting(); rtxtLog.AppendTextWithNewLine("Connected to " + tfsPp.SelectedTeamProjectCollection, Color.Green); rtxtLog.AppendTextWithNewLine("Connected to " + tfsPp.SelectedProjects.FirstOrDefault().Name, Color.Green); try { _workItemStore = (WorkItemStore)tfsPp.SelectedTeamProjectCollection.GetService(typeof(WorkItemStore)); ProjectInfo firstOrDefault = tfsPp.SelectedProjects.FirstOrDefault(); if (firstOrDefault != null && _workItemStore != null) { _tfsProject = _workItemStore.Projects[firstOrDefault.Name]; } QueryHierarchy queryHierarchy = _tfsProject.QueryHierarchy; // if it's null, check your permission var queryFolder = queryHierarchy as QueryFolder; QueryItem myQueryItem = queryFolder.FirstOrDefault(); _myQueryFolder = myQueryItem as QueryFolder; if (_myQueryFolder != null && _myQueryFolder.Count > 0) { lbxQueries.Items.Clear(); foreach (var item in _myQueryFolder) { lbxQueries.Items.Add(item.Name); } rtxtLog.AppendTextWithNewLine("Retrieved " + _myQueryFolder.Count + " Queries From My Queries Folder", Color.Green); return; } rtxtLog.AppendTextWithNewLine("No Queries in My Queries Folder", Color.DarkOrange); } catch (Exception exception) { rtxtLog.AppendTextWithNewLine(Utilities.ReadException(exception), Color.Red); } } }
public static QueryItem GetQueryItemFromPath(string path, string projectName) { string[] strArray = path.Split(cPathSeperators); int length = strArray.Length; QueryItem queryItem = (QueryItem)TfsContext.WorkItemStore.Projects[projectName].QueryHierarchy; for (int index = 0; index < length; ++index) { string name = strArray[index]; QueryFolder queryFolder = queryItem as QueryFolder; if (queryFolder != null && queryFolder.Contains(name)) { queryItem = queryFolder[name]; } else { queryItem = (QueryItem)null; break; } } return(queryItem); }
/// <summary> /// Performs the actual work of populating the work item tree. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The event arguments.</param> private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e) { this.logger.Log(TraceEventType.Verbose, "Work Item Query Picker starting background query to get query tree"); QueryFolder rootQueryFolder = (QueryFolder)e.Argument; foreach (QueryItem queryItem in rootQueryFolder) { if (this.backgroundWorker.CancellationPending) { break; } this.GetNodesForQueryFolder(queryItem as QueryFolder, this.treeView.Nodes, 0); } if (this.backgroundWorker.CancellationPending) { e.Cancel = true; } this.logger.Log(TraceEventType.Verbose, "Work Item Query Picker completed background query to get query tree"); }
private QueryDefinition FindQueryRecursive(QueryFolder folder) { var query = folder.OfType <QueryDefinition>().FirstOrDefault(q => q.Name == RequirementsQuery); if (query != null) { return(query); } else { foreach (var subFolder in folder.OfType <QueryFolder>()) { query = FindQueryRecursive(subFolder); if (query != null) { return(query); } } } return(null); }
private void ConnectToTfs(CommandLineOptions options) { Log(string.Format(CultureInfo.InvariantCulture, "Connecting to Tfs at {0}...", options.TfsServerUrl)); // Connect to Team Foundation Server Uri tfsUri = new Uri(options.TfsServerUrl); _teamProjectCollection = new TfsTeamProjectCollection(tfsUri); _linkService = _teamProjectCollection.GetService<TswaClientHyperlinkService>(); _workItemStore = _teamProjectCollection.GetService<WorkItemStore>(); _tfsProject = _workItemStore.Projects[options.TfsProject]; if (options.TfsQuery == null) { _tfsQueryFolder = _tfsProject.QueryHierarchy[options.TfsQueryHierarchy] as QueryFolder; _tfsQueryItem = _tfsQueryFolder[options.TfsQueryName]; } else { _tfsQueryItem = options.TfsQuery; } }
public List <string> GetAvailableQueries(string projectName, string queryFolderName) { List <string> result = new List <string>(); try { QueryHierarchy queryRoot = store.Projects[projectName].QueryHierarchy; QueryFolder folder = (QueryFolder)queryRoot[queryFolderName]; foreach (QueryDefinition query in folder) { result.Add(query.Name); } return(result); } catch (Exception ex) { Exception exception = new Exception("Make sure you set TfsURL before calling this method, and that the query is valid. Check inner exception for more details.", ex); throw exception; } }
private QueryDefinition FindQueryRecursive(QueryFolder folder) { var query = folder.OfType<QueryDefinition>().FirstOrDefault(q => q.Name == RequirementsQuery); if (query != null) { return query; } else { foreach (var subFolder in folder.OfType<QueryFolder>()) { query = FindQueryRecursive(subFolder); if (query != null) { return query; } } } return null; }
public void NewQuery(string projectName, QueryFolder parent) { _newQueryMethod.Value.Invoke(_witPackageInstance, new object[] { projectName, parent }); }
private void SetQueryItem(QueryFolder queryFolder, QueryFolder parentFolder, string sourceProjectName) { QueryItem newItem = null; foreach (QueryItem subQuery in queryFolder) { try { if (subQuery.GetType() == typeof(QueryFolder)) { newItem = new QueryFolder(subQuery.Name); if (!parentFolder.Contains(subQuery.Name)) { parentFolder.Add(newItem); store.Projects[projectName].QueryHierarchy.Save(); SetQueryItem((QueryFolder)subQuery, (QueryFolder)newItem, sourceProjectName); } else { logger.WarnFormat("Query Folder {0} already exists", subQuery); } } else { QueryDefinition oldDef = (QueryDefinition)subQuery; string queryText = oldDef.QueryText.Replace(sourceProjectName, projectName).Replace("User Story", "Product Backlog Item").Replace("Issue", "Impediment"); newItem = new QueryDefinition(subQuery.Name, queryText); if (!parentFolder.Contains(subQuery.Name)) { parentFolder.Add(newItem); store.Projects[projectName].QueryHierarchy.Save(); } else { logger.WarnFormat("Query Definition {0} already exists", subQuery); } } } catch (Exception ex) { if (newItem != null) newItem.Delete(); logger.ErrorFormat("Error creating Query: {0} : {1}", subQuery, ex.Message); continue; } } }
private void DefineFolder(QueryFolder query, TreeNode parent) { var item = new TreeNode { Text = query.Name, Tag = query }; parent.Nodes.Add(item); foreach (QueryItem subQuery in query) { if (subQuery.GetType() == typeof (QueryFolder)) DefineFolder((QueryFolder) subQuery, item); else DefineQuery((QueryDefinition) subQuery, item); } }
/// <summary> /// Moves a query folder or query to another targeted folder /// </summary> /// <param name="queryItem"></param> /// <param name="targetFolder"></param> public void MoveQueryItem(QueryItem queryItem, QueryFolder targetFolder) { targetFolder.Add(queryItem); targetFolder.Project.QueryHierarchy.Save(); }
/// <summary> /// Adds a query in "My Queries" /// </summary> /// <param name="queryTitle"></param> /// <param name="queryCommand"></param> /// <param name="parentFolder"></param> /// <returns></returns> public QueryDefinition AddNewQuery(string queryTitle, string queryCommand, QueryFolder parentFolder) { QueryDefinition query = new QueryDefinition(queryTitle, queryCommand, parentFolder); MyProject.QueryHierarchy.Save(); return query; }
/// <summary> /// Helper function for overloaded GetAllTeamQueries function, grabs queries from specified folder /// </summary> /// <param name="folder"></param> /// <returns></returns> private static List<QueryDefinition> GetAllTeamQueries(QueryFolder folder) { List<QueryDefinition> queryList = new List<QueryDefinition>(); foreach (QueryItem queryItem in folder) { if (queryItem is QueryFolder) { queryList.AddRange(GetAllTeamQueries(queryItem as QueryFolder)); } else { queryList.Add(queryItem as QueryDefinition); } } return queryList; }
public void NewQueryDefinition(Project project, QueryFolder parent) { parent = parent ?? WorkItemTrackingDocumentService.GetDefaultParent(project, false); _workItemTrackingPackage.Value.NewQuery(project.Name, parent); }
/// <summary> /// Recursively load the treeview /// </summary> /// <param name="queryFolder">The Query Folder to get information about</param> /// <param name="node">The node to add the query folder information to</param> private void GetNodesForQueryTree(QueryFolder queryFolder, TreeNode node) { //Add the folder to the treeview TreeNode folderNode = new TreeNode(); folderNode.Text = queryFolder.Name; folderNode.Tag = queryFolder; folderNode.Image = _graphicDictionary["Closed Folder.png"]; node.Items.Add(folderNode); int lastFolder = node.Items.Count - 1; //Loop through all items in the list of sub-items for this folder foreach (QueryItem queryItem in queryFolder) { //If the item is a query folder, call this method if (queryItem is QueryFolder) { GetNodesForQueryTree(queryItem as QueryFolder, node.Items[lastFolder]); } else { try { //If it isn't, add the query to the list of queries TreeNode itemNode = new TreeNode(); QueryDefinition qd = _wis.GetQueryDefinition(queryItem.Id); itemNode.Text = queryItem.Name; itemNode.Tag = queryItem; ImageSource img = null; if (qd.QueryType == QueryType.OneHop) { img = _graphicDictionary["Directed Link Query.png"]; } else if (qd.QueryType == QueryType.List) { img = _graphicDictionary["Flat Query.png"]; } else { img = _graphicDictionary["Tree Query.png"]; } itemNode.Image = img; folderNode.Items.Add(itemNode); } catch (ArgumentException ex) { /* MessageBox.Show("Could not get the query definition because of an invalid ID. Query Information is" + " as follows:\nQuery Item ID:" + queryItem.Id + "\nQuery Item Name: " + queryItem.Name + "\nSpecific message: " + ex.Message + "\nProcessing will continue.", "Retrieve Query Definition", MessageBoxButton.OK, MessageBoxImage.Error); */ Trace.WriteLine(ex); } } } }
/// <summary> /// Helper function for GetAllTeamQueries, grabs specified folder /// </summary> /// <param name="folder"></param> /// <param name="folders"></param> /// <returns></returns> private static QueryFolder GetQueryFolder(QueryFolder folder, string[] folders) { return folders.Length == 0 ? folder : GetQueryFolder((QueryFolder)folder[folders[0]], folders.Skip(1).ToArray()); }
/// <summary> /// Helper function for Search, used to iterate through each /// query folder and return the exact match to the folderName /// argument /// </summary> /// <param name="hierarchyFolder"></param> /// <param name="folderName"></param> /// <returns></returns> private static QueryFolder Search(QueryFolder hierarchyFolder, string folderName) { // iterate through all folders in project hierarchy foreach (QueryFolder folder in hierarchyFolder.OfType<QueryFolder>()) { // compare strings, case-insensitive if (folderName.Equals(folder.Name, StringComparison.OrdinalIgnoreCase)) { return folder; } var result = Search(folder, folderName); if (result == null) continue; return result; } return null; }
/// <summary> /// Create a new folder under My Queries /// </summary> /// <param name="folderName"></param> /// <returns></returns> public QueryFolder AddNewFolder(string folderName) { QueryFolder folder = new QueryFolder(folderName, GetMyQueriesFolder()); MyProject.QueryHierarchy.Save(); return folder; }