public void SetTeamQueries(QueryHierarchy sourceQueryCol, string sourceProjectName) { foreach (QueryFolder queryFolder in sourceQueryCol) { if (queryFolder.Name == "Team Queries" || queryFolder.Name == "Shared Queries") { QueryFolder teamQueriesFolder = null; if (store.Projects[projectName].QueryHierarchy.Contains("Shared Queries")) { teamQueriesFolder = (QueryFolder)store.Projects[projectName].QueryHierarchy["Shared Queries"]; } // seems there is no way to get the localized name dynamically if (store.Projects[projectName].QueryHierarchy.Contains("Freigegebene Abfragen")) { teamQueriesFolder = (QueryFolder)store.Projects[projectName].QueryHierarchy["Freigegebene Abfragen"]; } if (teamQueriesFolder != null) { SetQueryItem(queryFolder, teamQueriesFolder, sourceProjectName); } // test seems to be unnecessary //QueryFolder test = (QueryFolder)store.Projects[projectName].QueryHierarchy["Shared Queries"]; } } }
internal override void InternalExecute() { Stopwatch stopwatch = Stopwatch.StartNew(); ////////////////////////////////////////////////// WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules); TfsQueryContext tfsqc = new TfsQueryContext(targetStore); TfsTeamService teamService = me.Target.Collection.GetService <TfsTeamService>(); QueryHierarchy qh = targetStore.Store.Projects[me.Target.Config.Project].QueryHierarchy; List <TeamFoundationTeam> teamList = teamService.QueryTeams(me.Target.Config.Project).ToList(); Trace.WriteLine(string.Format("Found {0} teams?", teamList.Count)); ////////////////////////////////////////////////// int current = teamList.Count; int count = 0; long elapsedms = 0; foreach (TeamFoundationTeam team in teamList) { Stopwatch witstopwatch = Stopwatch.StartNew(); Trace.Write(string.Format("Processing team {0}", team.Name)); Regex r = new Regex(@"^Project - ([a-zA-Z ]*)"); string path; if (r.IsMatch(team.Name)) { Trace.Write(string.Format(" is a Project")); path = string.Format(@"Projects\{0}", r.Match(team.Name).Groups[1].Value.Replace(" ", "-")); } else { Trace.Write(string.Format(" is a Team")); path = string.Format(@"Teams\{0}", team.Name.Replace(" ", "-")); } Trace.Write(string.Format(" and new path is {0}", path)); //me.AddFieldMap("*", new RegexFieldMap("KM.Simulation.Team", "System.AreaPath", @"^Project - ([a-zA-Z ]*)", @"Nemo\Projects\$1")); string[] bits = path.Split(char.Parse(@"\")); CreateFolderHyerarchy(bits, qh["Shared Queries"]); //_me.ApplyFieldMappings(workitem); qh.Save(); witstopwatch.Stop(); elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds; current--; count++; TimeSpan average = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count)); TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current)); Trace.WriteLine(""); //Trace.WriteLine(string.Format("Average time of {0} per work item and {1} estimated to completion", string.Format(@"{0:s\:fff} seconds", average), string.Format(@"{0:%h} hours {0:%m} minutes {0:s\:fff} seconds", remaining))); } ////////////////////////////////////////////////// stopwatch.Stop(); Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed); }
public WorkItemRead(TfsTeamProjectCollection tfs, Project sourceProject) { this.tfs = tfs; projectName = sourceProject.Name; store = (WorkItemStore)tfs.GetService(typeof(WorkItemStore)); queryCol = store.Projects[sourceProject.Name].QueryHierarchy; workItemTypes = store.Projects[sourceProject.Name].WorkItemTypes; }
private static void ImportQuery(WorkItemQueryInfo query, QueryHierarchy queryHierarchy) { var currentFolder = queryHierarchy.OfType <QueryFolder>().FirstOrDefault(i => !i.IsPersonal); if (currentFolder == null) { throw new InvalidOperationException("The query hierarchy does not contain a shared (non-personal) root folder."); } var currentFolderNameIndex = 0; var pathComponents = (query.Path ?? string.Empty).Split('/'); while (currentFolderNameIndex < pathComponents.Length) { var childFolderName = pathComponents[currentFolderNameIndex]; if (currentFolder.Contains(childFolderName)) { var itemWithName = currentFolder[childFolderName]; if (itemWithName is QueryDefinition) { throw new ArgumentException("A query folder was requested but a query file with the same name exists at the same location: " + childFolderName); } else { currentFolder = (QueryFolder)itemWithName; } } else { if (!string.IsNullOrEmpty(childFolderName)) { // If childFolderName is empty then we import into the root, otherwise create the folder. var newFolder = new QueryFolder(childFolderName); currentFolder.Add(newFolder); currentFolder = newFolder; } } currentFolderNameIndex++; } if (currentFolder.Contains(query.Name)) { var itemWithName = currentFolder[query.Name]; if (itemWithName is QueryFolder) { throw new ArgumentException("A query file was requested but a query folder with the same name exists at the same location: " + query.Name); } else { var existingQuery = (QueryDefinition)itemWithName; existingQuery.QueryText = query.Text; } } else { var newQuery = new QueryDefinition(query.Name, query.Text); currentFolder.Add(newQuery); } }
public TPWiWrapper(TeamExplorerIntergator teamExpolorer) { tpCollection = teamExpolorer.tpCollection; teamProjectName = teamExpolorer.tpName; wiStore = (WorkItemStore)tpCollection.GetService(typeof(WorkItemStore)); qh = wiStore.Projects[teamProjectName].QueryHierarchy; wiTypes = wiStore.Projects[teamProjectName].WorkItemTypes; }
public TPWiWrapper(string tpCollectionUrl, string aTeamProjectName) { tpCollection = new TfsTeamProjectCollection(new Uri(tpCollectionUrl)); teamProjectName = aTeamProjectName; wiStore = (WorkItemStore)tpCollection.GetService(typeof(WorkItemStore)); qh = wiStore.Projects[teamProjectName].QueryHierarchy; wiTypes = wiStore.Projects[teamProjectName].WorkItemTypes; }
/// <summary> /// Constructor that takes in the projects URL, grabs the work item store where /// the queries are found, as well as the specific project name /// </summary> /// <param name="tfsUrl"></param> /// <param name="projectName"></param> public TfsHelperFunctions(string tfsUrl, string projectName) { _coll = TfsTeamProjectCollectionFactory.GetTeamProjectCollection( new Uri(tfsUrl)); Store = new WorkItemStore(_coll); MyProject = Store.Projects[projectName]; QueryHierarchy = Store.Projects[projectName].QueryHierarchy; }
public WorkItemWrite(TfsTeamProjectCollection tfs, Project destinationProject) { this.tfs = tfs; projectName = destinationProject.Name; this.destinationProject = destinationProject; store = new WorkItemStore(tfs, WorkItemStoreFlags.BypassRules); queryCol = store.Projects[destinationProject.Name].QueryHierarchy; workItemTypes = store.Projects[destinationProject.Name].WorkItemTypes; itemMap = new Hashtable(); itemMapCIC = new Hashtable(); }
public WorkItemWrite(TfsTeamProjectCollection tfs, Project destinationProject) { this.tfs = tfs; projectName = destinationProject.Name; this.destinationProject = destinationProject; store = (WorkItemStore)tfs.GetService(typeof(WorkItemStore)); queryCol = store.Projects[destinationProject.Name].QueryHierarchy; workItemTypes = store.Projects[destinationProject.Name].WorkItemTypes; itemMap = new Hashtable(); itemMapCIC = new Hashtable(); }
/// <summary> /// Constructor that takes in the projects URL, grabs the work item store where /// the queries are found, as well as the specific project name /// </summary> /// <param name="tfsUrl"></param> /// <param name="projectName"></param> public TfsHelperFunctions(string tfsUrl, string projectName) { var coll = TfsTeamProjectCollectionFactory.GetTeamProjectCollection( new Uri(tfsUrl)); store = new WorkItemStore(coll); MyProject = store.Projects[projectName]; QueryHierarchy = store.Projects[projectName].QueryHierarchy; }
protected override void InternalExecute() { Stopwatch stopwatch = Stopwatch.StartNew(); ////////////////////////////////////////////////// TfsTeamService teamService = Engine.Target.GetService <TfsTeamService>(); QueryHierarchy qh = ((TfsWorkItemMigrationClient)Engine.Target.WorkItems).Store.Projects[Engine.Target.Config.AsTeamProjectConfig().Project].QueryHierarchy; List <TeamFoundationTeam> teamList = teamService.QueryTeams(Engine.Target.Config.AsTeamProjectConfig().Project).ToList(); Log.LogInformation("Found {0} teams?", teamList.Count); ////////////////////////////////////////////////// int current = teamList.Count; int count = 0; long elapsedms = 0; foreach (TeamFoundationTeam team in teamList) { Stopwatch witstopwatch = Stopwatch.StartNew(); Log.LogTrace("Processing team {0}", team.Name); Regex r = new Regex(@"^Project - ([a-zA-Z ]*)"); string path; if (r.IsMatch(team.Name)) { Log.LogInformation("{0} is a Project", team.Name); path = string.Format(@"Projects\{0}", r.Match(team.Name).Groups[1].Value.Replace(" ", "-")); } else { Log.LogInformation("{0} is a Team", team.Name); path = string.Format(@"Teams\{0}", team.Name.Replace(" ", "-")); } Log.LogInformation(" and new path is {0}", path); //me.AddFieldMap("*", new RegexFieldMap("KM.Simulation.Team", "System.AreaPath", @"^Project - ([a-zA-Z ]*)", @"Nemo\Projects\$1")); string[] bits = path.Split(char.Parse(@"\")); CreateFolderHyerarchy(bits, qh["Shared Queries"]); //_me.ApplyFieldMappings(workitem); qh.Save(); witstopwatch.Stop(); elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds; current--; count++; TimeSpan average = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count)); TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current)); Log.LogInformation("Average time of {average} per work item and {remaining} estimated to completion", average.ToString("c"), remaining.ToString("c")); } ////////////////////////////////////////////////// stopwatch.Stop(); Log.LogInformation("DONE in {Elapsed} ", stopwatch.Elapsed.ToString("c")); }
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) { if (values == null) { return(DependencyProperty.UnsetValue); } if (values.Length < 2) { return(DependencyProperty.UnsetValue); } QueryFolder folder = values[0] as QueryFolder; QueryHierarchy hierarchy = values[0] as QueryHierarchy; QueryDefinition definition = values[0] as QueryDefinition; var brush = EnabledBrush; bool isEnabled = values[1] is bool?(bool)values[1] : false; if (!isEnabled) { return(DisabledBrush); } if (definition != null) { switch (definition.QueryType) { case QueryType.Invalid: brush = DisabledBrush; break; case QueryType.List: brush = DisabledBrush; break; case QueryType.OneHop: brush = EnabledBrush; break; case QueryType.Tree: brush = EnabledBrush; break; default: brush = DisabledBrush; break; } } return(brush); }
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 QueryHierarchyWrapper GetInstance() { QueryHierarchy real = default(QueryHierarchy); RealInstanceFactory(ref real); var instance = (QueryHierarchyWrapper)QueryHierarchyWrapper.GetWrapper(real); InstanceFactory(ref instance); if (instance == null) { Assert.Inconclusive("Could not Create Test Instance"); } return(instance); }
public static TfsRootFolderQueryItem BuildTreeViewFromTfs(QueryHierarchy queryHierarchy, string header, ICommand command) { TfsRootFolderQueryItem root = new TfsRootFolderQueryItem(null, header); foreach (var queryItem in queryHierarchy) { if (queryItem is QueryFolder qf) { DefineRootFolder(qf, root, command); } } return(root); }
private QueryItem GetQueryByName(string name, string projectName) { WorkItemStore workItemStore = (WorkItemStore)Session["WorkItemStore"]; var project = workItemStore.Projects[projectName]; QueryHierarchy query = project.QueryHierarchy; var queryFolder = query as QueryFolder; QueryItem queryItem = queryFolder["Shared Queries"]; queryFolder = queryItem as QueryFolder; IEnumerable queries = GetAllContainedQueriesList(queryFolder); return(queries.Cast <QueryItem>().FirstOrDefault(item => item.Name == name)); }
public JsonResult GetSharedQueriesList(string projectName) { WorkItemStore workItemStore = (WorkItemStore)Session["WorkItemStore"]; var project = workItemStore.Projects[projectName]; QueryHierarchy query = project.QueryHierarchy; var queryFolder = query as QueryFolder; var queryItem = queryFolder["Shared Queries"]; queryFolder = queryItem as QueryFolder; IEnumerable <string> names = (IEnumerable <string>)GetQueriesNames(GetAllContainedQueriesList(queryFolder)); return(Json(names, JsonRequestBehavior.AllowGet)); }
static void Main(string[] args) { TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri("https://code-inside.visualstudio.com/DefaultCollection")); // http://stackoverflow.com/questions/10748412/retrieving-work-items-and-their-linked-work-items-in-a-single-query-using-the-tf/10757338#10757338 var workItemStore = tfs.GetService <WorkItemStore>(); var project = workItemStore.Projects["Grocerylist"]; QueryHierarchy queryHierarchy = project.QueryHierarchy; var queryFolder = queryHierarchy as QueryFolder; QueryItem queryItem = queryFolder["My Queries"]; queryFolder = queryItem as QueryFolder; if (queryFolder != null) { Dictionary <string, string> variables = new Dictionary <string, string>(); variables.Add("project", "Grocerylist"); var myQuery = queryFolder["New Query 1"] as QueryDefinition; if (myQuery != null) { var wiCollection = workItemStore.Query(myQuery.QueryText, variables); foreach (WorkItem workItem in wiCollection) { Console.WriteLine("WorkItem -----------------------------"); Console.WriteLine(workItem.Title); foreach (Revision rev in workItem.Revisions) { Console.WriteLine(" - Revition: " + rev.Index); foreach (Field f in rev.Fields) { if (!Object.Equals(f.Value, f.OriginalValue)) { Console.WriteLine(" - Changes: {0}: {1} -> {2}", f.Name, f.OriginalValue, f.Value); } } Console.WriteLine(" ------------------"); } } Console.ReadLine(); } } }
/// <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 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(); }
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; } }
public List <string> GetAvailableQueryFolders(string projectName) { List <string> result = new List <string>(); try { QueryHierarchy queryRoot = store.Projects[projectName].QueryHierarchy; foreach (QueryFolder folder in queryRoot) { result.Add(folder.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 void BuildQueryHierarchy(QueryHierarchy QueryHierarchy, string project) { var rootContent = new StackPanel { Orientation = Orientation.Horizontal, Margin = new Thickness(4) }; var lbl = new TextBlock { Text = project, FontSize = 15 }; rootContent.Children.Add(lbl); var root = new TreeViewItem { IsExpanded = true, Header = rootContent }; foreach (QueryFolder query in QueryHierarchy) { DefineFolder(query, root); } Queries.Items.Add(root); }
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 IEnumerable <IWorkItemSummary> GetWorkItemsBySavedQuery(string projectName, string queryFolderName, string queryName) { try { QueryHierarchy queryRoot = store.Projects[projectName].QueryHierarchy; QueryFolder folder = (QueryFolder)queryRoot[queryFolderName]; QueryDefinition query1 = (QueryDefinition)folder[queryName]; WorkItemCollection queryResultsqueryResults = store.Query(query1.QueryText); List <IWorkItemSummary> result = new List <IWorkItemSummary>(); foreach (WorkItem workItem in queryResultsqueryResults) { result.Add(new DefaultWorkItemSummary(workItem)); } 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; } }
public void SetTeamQueries(QueryHierarchy sourceQueryCol, string sourceProjectName) { foreach (QueryFolder queryFolder in sourceQueryCol) { if (queryFolder.Name == "Team Queries" || queryFolder.Name == "Shared Queries") { QueryFolder teamQueriesFolder = null; foreach (var localSharedQueryString in _sharedQueriesString) { if (store.Projects[projectName].QueryHierarchy.Contains(localSharedQueryString)) { teamQueriesFolder = (QueryFolder)store.Projects[projectName].QueryHierarchy[localSharedQueryString]; } } if (teamQueriesFolder != null) { SetQueryItem(queryFolder, teamQueriesFolder, sourceProjectName); } } } }
private void BuildQueryHierarchy(QueryHierarchy QueryHierarchy, string project) { var rootContent = new StackPanel { Orientation = Orientation.Horizontal, Margin = new Thickness(4) }; var lbl = new TextBlock{ Text = project, FontSize = 15 }; rootContent.Children.Add(lbl); var root = new TreeViewItem {IsExpanded = true, Header = rootContent}; foreach (QueryFolder query in QueryHierarchy) { DefineFolder(query, root); } Queries.Items.Add(root); }
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) { if (values == null) { return(DependencyProperty.UnsetValue); } if (values.Length < 2) { return(DependencyProperty.UnsetValue); } QueryFolder folder = values[0] as QueryFolder; QueryHierarchy hierarchy = values[0] as QueryHierarchy; QueryDefinition definition = values[0] as QueryDefinition; string imagePath = TeamExplorerFolderCollapsed; bool isExpandend = values[1] is bool?(bool)values[1] : false; if (definition != null) { switch (definition.QueryType) { case QueryType.Invalid: imagePath = TeamExplorerNoWorkItems; break; case QueryType.List: imagePath = TeamExplorerFlatList; break; case QueryType.OneHop: imagePath = TeamExplorerDirectLink; break; case QueryType.Tree: imagePath = TeamExplorerTree; break; default: imagePath = Error; break; } } else if (folder != null) { hierarchy = folder.Parent as QueryHierarchy; if (hierarchy != null) { // Our parent is the hierarchy so we are either My Queries or Team Queries imagePath = folder.IsPersonal ? TeamExplorerMyQueries : TeamExplorerTeamQueries; } else { imagePath = isExpandend ? TeamExplorerFolderExpanded : TeamExplorerFolderCollapsed; } } else if (hierarchy != null) { imagePath = TeamExplorerWorkItemsRoot; } try { return(new BitmapImage(new Uri(imagePath, UriKind.Relative))); } catch { return(DependencyProperty.UnsetValue); } }
static partial void RealInstanceFactory(ref QueryHierarchy real, string callerName) { var project = ProjectWrapper_UnitTests.GetRealInstance(); real = project.QueryHierarchy; }
public void BuildQueryTree(QueryHierarchy queryHierarchy, string project) { projectName = project; BuildQueryHierarchy(queryHierarchy, project); }
private void BuildQueryHierarchy(ProjectInfo project, QueryHierarchy queryHierarchy) { tvwQueries.Nodes.Clear(); var root = new TreeNode(project.Name); foreach (QueryFolder query in queryHierarchy) { DefineFolder(query, root); } tvwQueries.Nodes.Add(root); }
/// <summary> /// Define Query Folders under the current parent /// </summary> /// <param name="targetHierarchy">The object that represents the whole of the target query tree</param> /// <param name="sourceFolder">The source folder in tree on source instance</param> /// <param name="parentFolder">The target folder in tree on target instance</param> private void MigrateFolder(QueryHierarchy targetHierarchy, QueryFolder sourceFolder, QueryFolder parentFolder) { // We only migrate non-private folders and their contents if (sourceFolder.IsPersonal) { Log.LogInformation("Found a personal folder {sourceFolderName}. Migration only available for shared Team Query folders", sourceFolder.Name); } else { this.totalFoldersAttempted++; // we need to replace the team project name in folder names as it included in query paths var requiredPath = sourceFolder.Path.Replace($"{Source.Project}/", $"{Target.Project}/"); // Is the project name to be used in the migration as an extra folder level? if (_Options.PrefixProjectToNodes == true) { // we need to inject the team name as a folder in the structure requiredPath = requiredPath.Replace(_Options.SharedFolderName, $"{_Options.SharedFolderName}/{Source.Project}"); // If on the root level we need to check that the extra folder has already been added if (sourceFolder.Path.Count(f => f == '/') == 1) { var targetSharedFolderRoot = (QueryFolder)parentFolder[_Options.SharedFolderName]; QueryFolder extraFolder = (QueryFolder)targetSharedFolderRoot.FirstOrDefault(q => q.Path == requiredPath); if (extraFolder == null) { // we are at the root level on the first pass and need to create the extra folder for the team name Log.LogInformation("Adding a folder '{Project}'", Source.Project); extraFolder = new QueryFolder(Source.Project); targetSharedFolderRoot.Add(extraFolder); targetHierarchy.Save(); // moved the save here a more immediate and relavent error message } // adjust the working folder to the newly added one parentFolder = targetSharedFolderRoot; } } // check if there is a folder of the required name, using the path to make sure it is unique QueryFolder targetFolder = (QueryFolder)parentFolder.FirstOrDefault(q => q.Path == requiredPath); if (targetFolder != null) { Log.LogInformation("Skipping folder '{sourceFolderName}' as already exists", sourceFolder.Name); } else { Log.LogInformation("Migrating a folder '{sourceFolderName}'", sourceFolder.Name); targetFolder = new QueryFolder(sourceFolder.Name); parentFolder.Add(targetFolder); targetHierarchy.Save(); // moved the save here a more immediate and relavent error message } // Process child items foreach (QueryItem sub_query in sourceFolder) { if (sub_query.GetType() == typeof(QueryFolder)) { MigrateFolder(targetHierarchy, (QueryFolder)sub_query, (QueryFolder)targetFolder); } else { MigrateQuery(targetHierarchy, (QueryDefinition)sub_query, (QueryFolder)targetFolder); } } } }
static partial void RealInstanceFactory(ref QueryHierarchy real, [CallerMemberName] string callerName = "");
public void SetTeamQueries(QueryHierarchy sourceQueryCol, string sourceProjectName) { foreach (QueryFolder queryFolder in sourceQueryCol) { if (queryFolder.Name == "Team Queries" || queryFolder.Name == "Shared Queries") { QueryFolder teamQueriesFolder = null; foreach (var localSharedQueryString in _sharedQueriesString) { if (store.Projects[projectName].QueryHierarchy.Contains(localSharedQueryString)) teamQueriesFolder = (QueryFolder)store.Projects[projectName].QueryHierarchy[localSharedQueryString]; } if (teamQueriesFolder != null) SetQueryItem(queryFolder, teamQueriesFolder, sourceProjectName); } } }