public TagAdminPageViewModel(IServiceProvider serviceProvider, ITeamFoundationContext teamFoundationContext, ITagAdminContext tagAdminContext) { _serviceProvider = serviceProvider; _teamFoundationContext = teamFoundationContext; _tagAdminContext = tagAdminContext; _eventAggregator = _tagAdminContext.EventAggregator; var logPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), $"Tag Admin for Visual Studio 2017\\TagAdminForVisualStudio2017-{DateTime.Now:dd-MM-yyyy}.log"); _log = new LoggerConfiguration().WriteTo.File(logPath, fileSizeLimitBytes: 5000000) .CreateLogger(); _log.Information("Initializing TagAdminPageViewModel - ServiceProvider: {serviceprovider}, TFSContext: {@tfs}, TagAdminContext: {@tagAdmin}", _serviceProvider != null, new { Collection = _teamFoundationContext.TeamProjectCollection.Name, User = _teamFoundationContext.TeamProjectCollection.ConfigurationServer.AuthorizedIdentity.UniqueName, Project = _teamFoundationContext.TeamProjectName, }, _tagAdminContext.EventAggregator != null); ShowBusy(true); Subscriptions(); Triggers(); }
/// <summary> /// Retrieves the shelveset list for the current user /// </summary> /// <param name="userName">The user name </param> /// <param name="secondUsername">The second user name </param> /// <param name="context">The Team foundation server context</param> /// <param name="shelveSets">The shelveset list to be returned</param> private static void FetchShevlesets(string userName, string secondUsername, ITeamFoundationContext context, out ObservableCollection <Shelveset> shelveSets) { shelveSets = new ObservableCollection <Shelveset>(); if (context != null && context.HasCollection && context.HasTeamProject) { var vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { string user = string.IsNullOrWhiteSpace(userName) ? vcs.AuthorizedUser : userName; foreach (var shelveSet in vcs.QueryShelvesets(null, user).OrderByDescending(s => s.CreationDate)) { shelveSets.Add(shelveSet); } if (!string.IsNullOrWhiteSpace(secondUsername) && secondUsername != userName) { user = string.IsNullOrWhiteSpace(secondUsername) ? vcs.AuthorizedUser : secondUsername; foreach (var shelveSet in vcs.QueryShelvesets(null, user).OrderByDescending(s => s.CreationDate)) { shelveSets.Add(shelveSet); } } } } }
public Changeset GetChangeset(ITeamFoundationContext currentContext, int changesetId) { var versionControl = currentContext.TeamProjectCollection.GetService <VersionControlServer>(); var changeset = versionControl.GetChangeset(changesetId); return(changeset); }
private void PerformSearch() { this.TextBoxSearch.Foreground = Brushes.Black; if (!string.IsNullOrWhiteSpace(this.TextBoxSearch.Text)) { ITeamFoundationContext context = this.ParentSection.GetContext(); IIdentityManagementService ims = context.TeamProjectCollection.GetService <IIdentityManagementService>(); // First try search by AccountName TeamFoundationIdentity userIdentity = ims.ReadIdentity(IdentitySearchFactor.AccountName, this.TextBoxSearch.Text, MembershipQuery.None, ReadIdentityOptions.ExtendedProperties); if (userIdentity == null) { // Next we try search by DisplayName userIdentity = ims.ReadIdentity(IdentitySearchFactor.DisplayName, this.TextBoxSearch.Text, MembershipQuery.None, ReadIdentityOptions.ExtendedProperties); if (userIdentity == null) { this.TextBoxSearch.Foreground = Brushes.DarkRed; return; } } this.ParentSection.UserAccountName = this.TextBoxSearch.Text; this.ParentSection.UserDisplayName = userIdentity.DisplayName; } else { this.ParentSection.UserAccountName = "@Me"; this.ParentSection.UserDisplayName = string.Empty; } this.ParentSection.Refresh(); }
private async Task RefreshAsyncShelveSets() { try { // Set our busy flag and clear the previous data this.IsBusy = true; this.Shelvesets.Clear(); ObservableCollection <Shelveset> lshelvesests = new ObservableCollection <Shelveset>(); // Make the server call asynchronously to avoid blocking the UI await Task.Run(() => { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { VersionControlServer vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { // Ask the derived section for the history parameters string user; GetShelvesetParameters(vcs, out user); foreach (Shelveset shelveset in vcs.QueryShelvesets(null, user)) { lshelvesests.Add(shelveset); } } } }); // The shelvesets are not in the right order, lets sort them by date var sortedShelvesets = ( from ss in lshelvesests orderby ss.CreationDate descending select ss).ToList(); ObservableCollection <Shelveset> lshelvesests2 = new ObservableCollection <Shelveset>(); foreach (var s in sortedShelvesets) { lshelvesests2.Add(s); // only bring back the last 15 if (lshelvesests2.Count >= 15) { break; } } this.Shelvesets = lshelvesests2; } catch (Exception ex) { this.ShowNotification(ex.Message, NotificationType.Error); } finally { // Always clear our busy flag when done this.IsBusy = false; } }
public AssociatedWorkitemsPageContent(IServiceProvider serviceProvider, ITeamFoundationContext teamFoundationContext, ITagAdminContext tagAdminContext, object context) { InitializeComponent(); var tagsList = context as AsyncObservableCollection <Tag>; DataContext = new AssociatedWorkitemViewModel(serviceProvider, teamFoundationContext, tagAdminContext, tagsList?.ToList()); }
/// <summary> /// Retrieves the shelveset for pending change for the current user /// </summary> /// <param name="context">The Team foundation server context</param> internal Shelveset FetchPendingChangeShelveset(ITeamFoundationContext context) { if (context != null && context.HasCollection && context.HasTeamProject) { var vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { var machineName = Environment.MachineName; var currentUserName = Environment.UserName; var workspace = vcs.GetWorkspace(machineName, currentUserName); var changes = workspace.GetPendingChanges();//we want to shelve all pending changes in the workspace if (changes.Length != 0) { var pendChange = new Shelveset(vcs, "Pending Changes", workspace.OwnerName); workspace.Shelve(pendChange, changes, ShelvingOptions.Replace);//you can specify to replace existing shelveset, or to remove pending changes from the local workspace with ShelvingOptions pendChange.CreationDate = DateTime.Now; return(pendChange); } } } return(null); }
public void SetLastWorkItem(ITeamExplorer teamExplorer, ITeamFoundationContext context) { var lastChangeset = GetLastUserChangeSet(context.TeamProjectCollection, context.TeamProjectName); if (lastChangeset == null) return; SetLastWorkItem(teamExplorer, lastChangeset); }
private void OnGetTags(ITeamFoundationContext context) { OnClearSelectionCommand(null); //if context has changed by user update our local context // also fixes issue: The project specified is not found in hierarchy issue _teamFoundationContext = context; GetTagsFromService(context); }
private async Task RefreshAsyncWorkitems() { try { // Set our busy flag and clear the previous data this.IsBusy = true; this.WorkItems.Clear(); ObservableCollection <WorkItem> lworkItems = new ObservableCollection <WorkItem>(); // Make the server call asynchronously to avoid blocking the UI await Task.Run(() => { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { WorkItemStore wis = context.TeamProjectCollection.GetService <WorkItemStore>(); if (wis != null) { WorkItemCollection wic; if (!string.IsNullOrWhiteSpace(this.UserAccountName)) { string user = "******" + this.UserDisplayName + "'"; wic = wis.Query("SELECT [System.Id], [System.Title], [System.State] FROM WorkItems WHERE [System.WorkItemType] <> '' AND [System.State] <> '' AND [System.AssignedTo] EVER " + user + " ORDER BY [System.ChangedDate] desc"); } else { wic = wis.Query("SELECT [System.Id], [System.Title], [System.State] FROM WorkItems WHERE [System.WorkItemType] <> '' AND [System.State] <> '' AND [System.TeamProject] = '" + context.TeamProjectName + "'ORDER BY [System.ChangedDate] desc"); } int i = 0; foreach (WorkItem wi in wic) { lworkItems.Add(wi); i++; if (i >= 12) { break; } } } } }); // Now back on the UI thread, update the bound collection and section title this.WorkItems = lworkItems; } catch (Exception ex) { this.ShowNotification(ex.Message, NotificationType.Error); } finally { // Always clear our busy flag when done this.IsBusy = false; } }
public static bool IsConnectedToTfsCollectionAndProject(ITeamFoundationContext context) { if (context != null) { return(context.HasCollection && context.HasTeamProject); } return(false); }
public static bool IsConnectedToTfsCollectionAndProject(ITeamFoundationContext context) { if (context != null) { return context.HasCollection && context.HasTeamProject; } return false; }
/// <summary> /// Associates a new version control server (child of a TeamProjectCollection) /// with this instance. Should be called when the TeamProjectCollection changes. /// </summary> private void SetVersionControlServer(ITeamFoundationContext tfContext) { RemoveVersionControlReferences(); if (tfContext != null && tfContext.TeamProjectCollection != null) { m_vcServer = tfContext.TeamProjectCollection.GetService <VersionControlServer>(); m_vcServer.CommitCheckin += VersionControlServer_CommitCheckin; } }
private void UpdateText(ITeamFoundationContext teamFoundationContext) { if (teamFoundationContext == null || string.IsNullOrEmpty(teamFoundationContext.TeamProjectName)) { Text = string.Empty; } else { Text = "Plugin connected to " + teamFoundationContext.TeamProjectName; } }
public void SetLastWorkItems(ITeamExplorer teamExplorer, ITeamFoundationContext context) { var lastChangeset = GetLastUserChangeSet(context.TeamProjectCollection, context.TeamProjectName); if (lastChangeset == null) { return; } SetWorkItemsFromChangeset(teamExplorer, lastChangeset); }
/// <summary> /// Refresh the changeset data asynchronously. /// </summary> private async Task RefreshAsync() { try { var pc = GetService <IPendingChangesExt>(); var currentlyAssociatedWorkItems = pc.WorkItems; // Set our busy flag and clear the previous data this.IsBusy = true; this.RecentWorkItems.Clear(); var workItems = new ObservableCollection <AssociatedWorkItemInfo>(); // Make the server call asynchronously to avoid blocking the UI await Task.Run(() => { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { var vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { string path = "$/" + context.TeamProjectName; foreach (Changeset changeset in vcs.QueryHistory(path, VersionSpec.Latest, 0, RecursionType.Full, vcs.AuthorizedUser, null, null, 10, false, true)) { foreach (var wi in changeset.AssociatedWorkItems) { if (workItems.All(w => w.Id != wi.Id) && currentlyAssociatedWorkItems.All(w => w.WorkItem.Id != wi.Id)) { workItems.Add(wi); } } } } } }); // Now back on the UI thread, update the bound collection and section title this.RecentWorkItems = new ObservableCollection <AssociatedWorkItemInfo>(workItems.Take(5)); this.Title = this.RecentWorkItems.Count > 0 ? String.Format(" {0} ({1})", SectionTitle, this.RecentWorkItems.Count) : SectionTitle; } catch (Exception ex) { ShowNotification(ex.Message, NotificationType.Error); } finally { // Always clear our busy flag when done this.IsBusy = false; } }
private string GetPath() { if (!string.IsNullOrEmpty(QueryPath)) { return(QueryPath); } ITeamFoundationContext context = CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { return("$/" + context.TeamProjectName); } return("$/"); }
/// <summary> /// Refresh the changeset data asynchronously. /// </summary> private async Task RefreshAsync() { try { // Set our busy flag and clear the previous data this.IsBusy = true; this.Changesets.Clear(); ObservableCollection <Changeset> changesets = new ObservableCollection <Changeset>(); // Make the server call asynchronously to avoid blocking the UI await Task.Run(() => { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { VersionControlServer vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { // Ask the derived section for the history parameters string user; int maxCount; GetHistoryParameters(vcs, out user, out maxCount); string path = "$/" + context.TeamProjectName; foreach (Changeset changeset in vcs.QueryHistory(path, VersionSpec.Latest, 0, RecursionType.Full, user, null, null, maxCount, false, true)) { changesets.Add(changeset); } } } }); // Now back on the UI thread, update the bound collection and section title this.Changesets = changesets; this.Title = this.Changesets.Count > 0 ? String.Format("{0} ({1})", this.BaseTitle, this.Changesets.Count) : this.BaseTitle; } catch (Exception ex) { ShowNotification(ex.Message, NotificationType.Error); } finally { // Always clear our busy flag when done this.IsBusy = false; } }
/// <summary> /// Refresh the changeset data asynchronously. /// </summary> private async Task RefreshAsync() { if (!IsEnabled) { IsBusy = false; return; } try { IsBusy = true; Changesets.Clear(); ObservableCollection <ChangesetInfo> changesets = new ObservableCollection <ChangesetInfo>(); await Task.Run(() => { ITeamFoundationContext context = CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { VersionControlServer vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { // Ask the derived section for the history parameters string user; int maxCount; GetHistoryParameters(vcs, out user, out maxCount); string path = GetPath(); foreach (Changeset changeset in vcs.QueryHistory(path, VersionSpec.Latest, 0, RecursionType.Full, user, null, null, maxCount, false, true)) { changesets.Add(new ChangesetInfo(changeset, IsUserNameVisible ? null : string.Empty)); } } } }); Changesets = changesets; SectionTitle = Changesets.Count > 0 ? String.Format("{0} ({1})", BaseTitle, Changesets.Count) : BaseTitle; } catch (Exception ex) { Output.Exception(ex); } finally { IsBusy = false; } }
public WorkItemSearchReplaceViewModel(QueryItem queryItem, IServiceProvider provider) : base(provider) { this.queryItem = queryItem; context = TfsContext.TfsContextManager.CurrentContext; PreviewCommand = new DelegateCommand <object>(Preview, CanPreview); ExecuteCommand = new DelegateCommand <object>(Execute, CanExecute); OpenWorkItemCommand = new DelegateCommand <Uri>(OpenWorkItem); WorkItemsListProvider = new WorkItemsListProvider(); PreviewFields = new ObservableCollection <string>(); Initialize(); }
private List <string> GetRecentUsers() { List <string> names = new List <string>(); ITeamFoundationContext context = this.ParentSection.GetContext(); if (context != null && context.HasCollection && context.HasTeamProject) { // first we get the recent users who committed code changes VersionControlServer vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { // Ask the derived section for the history parameters string path = "$/" + context.TeamProjectName; foreach (Changeset changeset in vcs.QueryHistory(path, VersionSpec.Latest, 0, RecursionType.Full, string.Empty, null, null, 250, false, true, false).Cast <Changeset>().Where(changeset => !names.Contains(changeset.CommitterDisplayName))) { names.Add(changeset.CommitterDisplayName); } } // next we get the users who recently committed work item changes WorkItemStore wis = context.TeamProjectCollection.GetService <WorkItemStore>(); if (wis != null) { WorkItemCollection wic = wis.Query("SELECT [System.Id] FROM WorkItems WHERE [System.WorkItemType] <> '' AND [System.State] <> '' AND [System.TeamProject] = '" + context.TeamProjectName + "' ORDER BY [System.ChangedDate] desc"); int i = 0; foreach (WorkItem wi in wic) { if (!names.Contains(wi.ChangedBy)) { names.Add(wi.ChangedBy); } i++; if (i >= 250) { break; } } } names.Sort(); } return(names); }
/// <summary> /// Gets if the version control service is available or not. /// </summary> /// <returns></returns> protected override async Task <bool> GetIfVersionControlServiceIsAvailable() { // Make sure we have a connection to Team Foundation. ITeamFoundationContext context = this.CurrentContext; if (context == null || !context.HasCollection) { return(false); } // Make sure we can access the Version Control Server. VersionControlServer versionControlService = null; await Task.Run(() => versionControlService = context.TeamProjectCollection.GetService <VersionControlServer>()); // Return if we could connect to the TFS Version Control or not. return(versionControlService != null); }
public void ViewWorkItemDetails(int workItemId) { try { ITeamFoundationContext context = this.CurrentContext; EnvDTE80.DTE2 dte2 = Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(DTE)) as EnvDTE80.DTE2; if (dte2 != null) { DocumentService witDocumentService = (DocumentService)dte2.DTE.GetObject("Microsoft.VisualStudio.TeamFoundation.WorkItemTracking.DocumentService"); var widoc = witDocumentService.GetWorkItem(context.TeamProjectCollection, workItemId, this); witDocumentService.ShowWorkItem(widoc); } } catch (Exception ex) { this.ShowNotification(ex.Message, NotificationType.Error); } }
public void ViewHistory() { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { VersionControlServer vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { string path = "$/" + context.TeamProjectName; VersionControlExt vc = GetVersionControlExt(this.ServiceProvider); if (vc != null) { vc.History.Show(path, VersionSpec.Latest, 0, RecursionType.Full, this.UserAccountName, null, null, 250, true); } } } }
public MainView(ITeamFoundationContext tfsContext, ITeamExplorer iTeamExplorer) { InitializeComponent(); _teamFoundationContext = tfsContext; itfs = iTeamExplorer; bs = tfs.GetService <IBuildServer>(); var dte = Package.GetGlobalService(typeof(EnvDTE.DTE)) as EnvDTE.DTE; if (dte != null) { var fi = new FileInfo(dte.FileName); IdePath = fi.DirectoryName; } LoadcbBuildDef(); }
/// <summary> /// Returns whether the user identity of the given account name or display name exists or not /// </summary> /// <param name="userDisplayNameOrAccount">The given account name or display name</param> /// <returns>True if the given user account or display name exists. False otherwise</returns> private bool UserIdentityExists(string userDisplayNameOrAccount) { ITeamFoundationContext context = this.ParentSection.Context; IIdentityManagementService ims = context.TeamProjectCollection.GetService <IIdentityManagementService>(); // First try search by AccountName TeamFoundationIdentity userIdentity = ims.ReadIdentity(IdentitySearchFactor.AccountName, userDisplayNameOrAccount, MembershipQuery.None, ReadIdentityOptions.ExtendedProperties); if (userIdentity == null) { // Next we try search by DisplayName userIdentity = ims.ReadIdentity(IdentitySearchFactor.DisplayName, userDisplayNameOrAccount, MembershipQuery.None, ReadIdentityOptions.ExtendedProperties); if (userIdentity == null) { return(false); } } return(true); }
private async Task RefreshAsync() { try { this.IsBusy = true; this.Builds.Clear(); var buildRefresh = new ObservableCollection <BuildDefinitionViewModel>(); await Task.Run(() => { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { var buildServer = context.TeamProjectCollection.GetService <IBuildServer>(); if (buildServer != null) { var buildDefinitions = buildServer.QueryBuildDefinitions(context.TeamProjectName); var builDefinitionTree = BuildDefinitionTreeBuilder.Build(buildDefinitions, _optionsViewModel.OptionsModel.SplitCharacter.HasValue ? _optionsViewModel.OptionsModel.SplitCharacter.Value : '.'); foreach (var rootNode in builDefinitionTree) { buildRefresh.Add(new BuildDefinitionViewModel(rootNode)); } } } }); this.Builds = buildRefresh; } catch (Exception ex) { this.ShowNotification(ex.Message, NotificationType.Error); } finally { this.IsBusy = false; } }
private async Task RefreshAsyncChangesets() { try { // Set our busy flag and clear the previous data this.IsBusy = true; this.Changesets.Clear(); ObservableCollection <Changeset> lchangesets = new ObservableCollection <Changeset>(); // Make the server call asynchronously to avoid blocking the UI await Task.Run(() => { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { VersionControlServer vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { string path = "$/" + context.TeamProjectName; foreach (Changeset changeset in vcs.QueryHistory(path, VersionSpec.Latest, 0, RecursionType.Full, this.UserAccountName, null, null, 12, false, true)) { lchangesets.Add(changeset); } } } }); // Now back on the UI thread, update the bound collection and section title this.Changesets = lchangesets; } catch (Exception ex) { this.ShowNotification(ex.Message, NotificationType.Error); } finally { // Always clear our busy flag when done this.IsBusy = false; } }
public void ViewHistory() { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { VersionControlServer vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { // Ask the derived section for the history parameters string user; int maxCount; this.GetHistoryParameters(vcs, out user, out maxCount); string path = "$/" + context.TeamProjectName; VersionControlExt vc = GetVersionControlExt(this.ServiceProvider); if (vc != null) { vc.History.Show(path, VersionSpec.Latest, 0, RecursionType.Full, user, null, null, int.MaxValue, true); } } } }
public MergeInfo GetMergeInfo(ITeamExplorer teamExplorer, ITeamFoundationContext context, Changeset changeset) { var branchInfos = GetBranches(teamExplorer, context); BranchInfo currentBranch = null; var serverItemPaths = (from Change change in changeset.Changes select change.Item.ServerItem).ToArray(); foreach (var branchInfo in branchInfos) { if (serverItemPaths.All(x => x.StartsWith(branchInfo.BranchServerPath))) { currentBranch = branchInfo; break; } } return(new MergeInfo { ChangesetId = changeset.ChangesetId, VersionSpec = new ChangesetVersionSpec(changeset.ChangesetId), FromPath = currentBranch.BranchServerPath, ToPath = currentBranch.ParentServerPath }); }
public AssociatedWorkitemViewModel(IServiceProvider serviceProvider, ITeamFoundationContext teamFoundationContext, ITagAdminContext tagAdminContext, List <Tag> tagsList) { _serviceProvider = serviceProvider; _teamFoundationContext = teamFoundationContext; _tagAdminContext = tagAdminContext; _tagsList = tagsList; _eventAggregator = _tagAdminContext.EventAggregator; var logPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), string.Format("Tag Admin for Visual Studio 2015\\TagAdminForVisualStudio2015-{0}.log", DateTime.Now.ToString("dd-MM-yyyy"))); _log = new LoggerConfiguration().WriteTo.File(logPath, fileSizeLimitBytes: 5000000) .CreateLogger(); _log.Information("Initializing AssociatedWorkitemViewModel - ServiceProvider: {serviceprovider}, TFSContext: {@tfs}, TagsCount: {tagsCount}", _serviceProvider != null, new { Collection = _teamFoundationContext.TeamProjectCollection.Name, User = _teamFoundationContext.TeamProjectCollection.ConfigurationServer.AuthorizedIdentity.UniqueName, Project = _teamFoundationContext.TeamProjectName, }, tagsList.Count); Subscriptions(); Triggers(); }
private ObservableCollection<MergeInfoViewModel> GetBranches(ITeamFoundationContext context, ChangesetViewModel changesetViewModel) { if (context == null) return new ObservableCollection<MergeInfoViewModel>(); var tfs = context.TeamProjectCollection; var versionControl = tfs.GetService<VersionControlServer>(); var result = new ObservableCollection<MergeInfoViewModel>(); var workspace = _workspace; var changesetService = _changesetService; var changes = changesetService.GetChanges(changesetViewModel.ChangesetId); var sourceTopFolder = CalculateTopFolder(changes); var mergesRelationships = GetMergesRelationships(sourceTopFolder, versionControl); if (mergesRelationships.Count > 0) { var sourceBranchIdentifier = changesetViewModel.Branches.Select(b => new ItemIdentifier(b)).First(); var sourceBranch = sourceBranchIdentifier.Item; var trackMerges = versionControl.TrackMerges(new[] { changesetViewModel.ChangesetId }, new ItemIdentifier(sourceTopFolder), mergesRelationships.ToArray(), null); var changesetVersionSpec = new ChangesetVersionSpec(changesetViewModel.ChangesetId); var branchValidator = new BranchValidator(workspace, trackMerges); var branchFactory = new BranchFactory(sourceBranch, sourceTopFolder, changesetVersionSpec, branchValidator, _eventAggregator, _settings); var sourceBranchInfo = versionControl.QueryBranchObjects(sourceBranchIdentifier, RecursionType.None)[0]; if (sourceBranchInfo.Properties != null && sourceBranchInfo.Properties.ParentBranch != null && !sourceBranchInfo.Properties.ParentBranch.IsDeleted) { var targetBranch = sourceBranchInfo.Properties.ParentBranch; var targetPath = GetTargetPath(mergesRelationships, targetBranch); if (targetPath != null) { var mergeInfo = branchFactory.CreateTargetBranchInfo(targetBranch, targetPath); mergeInfo._checked = mergeInfo.ValidationResult == BranchValidationResult.Success; result.Add(mergeInfo); } } var currentBranchInfo = branchFactory.CreateSourceBranch(); result.Add(currentBranchInfo); if (sourceBranchInfo.ChildBranches != null) { var childBranches = sourceBranchInfo.ChildBranches.Where(b => !b.IsDeleted) .Reverse(); foreach (var childBranch in childBranches) { var targetBranch = childBranch; var targetPath = GetTargetPath(mergesRelationships, targetBranch); if (targetPath != null) { var mergeInfo = branchFactory.CreateTargetBranchInfo(targetBranch, targetPath); result.Add(mergeInfo); } } } // Feature branch if (mergesRelationships.Count > 0) { var changetIds = mergesRelationships.Select(r => r.Version).Cast<ChangesetVersionSpec>().Select(c => c.ChangesetId) .Distinct() .ToArray(); var branches = _changesetService.GetAssociatedBranches(changetIds); foreach (var mergesRelationship in mergesRelationships) { var targetBranch = branches.FirstOrDefault(b => IsTargetPath(mergesRelationship, b)); if (targetBranch != null) { var mergeInfo = branchFactory.CreateTargetBranchInfo(targetBranch, mergesRelationship); result.Add(mergeInfo); } } } } return result; }
/// <summary> /// Retrieves the shelveset list for the current user /// </summary> /// <param name="userName">The user name </param> /// <param name="secondUsername">The second user name </param> /// <param name="context">The Team foundation server context</param> /// <param name="shelveSets">The shelveset list to be returned</param> private static void FetchShevlesets(string userName, string secondUsername, ITeamFoundationContext context, out ObservableCollection<Shelveset> shelveSets) { shelveSets = new ObservableCollection<Shelveset>(); if (context != null && context.HasCollection && context.HasTeamProject) { var vcs = context.TeamProjectCollection.GetService<VersionControlServer>(); if (vcs != null) { string user = string.IsNullOrWhiteSpace(userName) ? vcs.AuthorizedUser : userName; foreach (var shelveSet in vcs.QueryShelvesets(null, user).OrderByDescending(s => s.CreationDate)) { shelveSets.Add(shelveSet); } if (!string.IsNullOrWhiteSpace(secondUsername) && secondUsername != userName) { user = string.IsNullOrWhiteSpace(secondUsername) ? vcs.AuthorizedUser : secondUsername; foreach (var shelveSet in vcs.QueryShelvesets(null, user).OrderByDescending(s => s.CreationDate)) { shelveSets.Add(shelveSet); } } } } }
/// <summary> /// Refresh the changeset data asynchronously. /// </summary> public async Task RefreshAsync() { try { var pc = GetService <IPendingChangesExt>(); var currentlyAssociatedWorkItems = pc.WorkItems; // Set our busy flag and clear the previous data this.IsBusy = true; this.RecentWorkItems.Clear(); var workItems = new ObservableCollection <RecentWorkItem>(); var activeWorkItems = new ObservableCollection <ActiveWorkItem>(); try { var service = GetService <SActiveWiService>() as IActiveWiService; if (service != null) { activeWorkItems = service.GetActiveWorkItems(string.Empty); } } catch { } // Make the server call asynchronously to avoid blocking the UI await Task.Run(() => { ITeamFoundationContext context = this.CurrentContext; if (context != null && context.HasCollection && context.HasTeamProject) { var vcs = context.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs != null) { string path = "$/" + context.TeamProjectName; foreach (Changeset changeset in vcs.QueryHistory(path, VersionSpec.Latest, 0, RecursionType.Full, vcs.AuthorizedUser, null, null, 10, false, true)) { foreach (AssociatedWorkItemInfo wi in changeset.AssociatedWorkItems.Where(i => string.IsNullOrEmpty(this.SearchTerm) || i.State.ToLower().Contains(this.SearchTerm.ToLower()) || i.Id.ToString().ToLower().Contains(this.SearchTerm.ToLower()) || i.Title.ToLower().Contains(this.SearchTerm.ToLower()) || i.AssignedTo.ToLower().Contains(this.SearchTerm.ToLower()) || i.WorkItemType.ToLower().Contains(this.SearchTerm.ToLower()))) { if ( workItems.All(w => w.Id != wi.Id) && currentlyAssociatedWorkItems.All(w => w.WorkItem.Id != wi.Id) && activeWorkItems.All(w => w.Id != wi.Id) ) { workItems.Add(new RecentWorkItem(wi)); } } } } } }); // Now back on the UI thread, update the bound collection and section title this.RecentWorkItems = new ObservableCollection <RecentWorkItem>(workItems.Take(5)); this.Title = this.RecentWorkItems.Count > 0 ? String.Format("{0} ({1})", SectionTitle, this.RecentWorkItems.Count) : SectionTitle; } catch (Exception ex) { ShowNotification(ex.Message, NotificationType.Error); } finally { // Always clear our busy flag when done this.IsBusy = false; } }