Example #1
0
        /// <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);
                }
            }
        }
Example #2
0
 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;
 }
Example #3
0
        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);
        }
Example #6
0
        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"];
                }
            }
        }
Example #7
0
        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);
        }
Example #8
0
        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
                }
            }
        }
Example #17
0
        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;
        }
Example #23
0
        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);
        }
Example #24
0
        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);
                }
            }
        }
Example #25
0
        /// <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;
            }
        }
Example #27
0
        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);
        }
Example #28
0
        /// <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;
        }
Example #30
0
        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);
            }
        }
Example #32
0
        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));
        }
Example #33
0
        /// <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);
                }
            }
        }
Example #35
0
        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);
            }
        }
Example #44
0
 /// <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();
 }
Example #45
0
 /// <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;
 }
Example #46
0
        /// <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);
                    }

                }
            }
        }
Example #49
0
 /// <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());
 }
Example #50
0
        /// <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;
        }
Example #51
0
 /// <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;
 }