/// <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 UnshelveDetailsServiceModel(ITeamPilgrimServiceModelProvider teamPilgrimServiceModelProvider, ITeamPilgrimVsService teamPilgrimVsService, ProjectCollectionServiceModel projectCollectionServiceModel, WorkspaceServiceModel workspaceServiceModel, UnshelveServiceModel unshelveServiceModel, Shelveset shelveset) : base(teamPilgrimServiceModelProvider, teamPilgrimVsService) { ProjectCollectionServiceModel = projectCollectionServiceModel; WorkspaceServiceModel = workspaceServiceModel; UnshelveServiceModel = unshelveServiceModel; Shelveset = shelveset; PendingChanges = new ObservableCollection <PendingChangeModel>(); CancelCommand = new RelayCommand(Cancel, CanCancel); UnshelveCommand = new RelayCommand(Unshelve, CanUnshelve); SelectPendingChangesCommand = new RelayCommand <SelectPendingChangesCommandArgument>(SelectPendingChanges, CanSelectPendingChanges); SelectWorkItemsCommand = new RelayCommand <SelectWorkItemsCommandArgument>(SelectWorkItems, CanSelectWorkItems); PendingSet[] pendingSets; if (teamPilgrimServiceModelProvider.TryWorkspaceQueryShelvedChanges(WorkspaceServiceModel.Workspace, out pendingSets, shelveset.Name, shelveset.OwnerName, null)) { PendingSet = pendingSets.First(); foreach (var pendingChange in PendingSet.PendingChanges) { PendingChanges.Add(new PendingChangeModel(pendingChange) { IncludeChange = true }); } } PopulateSelectedPendingChangesSummary(); }
public UnshelveDetailsServiceModel(ITeamPilgrimServiceModelProvider teamPilgrimServiceModelProvider, ITeamPilgrimVsService teamPilgrimVsService, ProjectCollectionServiceModel projectCollectionServiceModel, WorkspaceServiceModel workspaceServiceModel, UnshelveServiceModel unshelveServiceModel, Shelveset shelveset) : base(teamPilgrimServiceModelProvider, teamPilgrimVsService) { ProjectCollectionServiceModel = projectCollectionServiceModel; WorkspaceServiceModel = workspaceServiceModel; UnshelveServiceModel = unshelveServiceModel; Shelveset = shelveset; PendingChanges = new ObservableCollection<PendingChangeModel>(); CancelCommand = new RelayCommand(Cancel, CanCancel); UnshelveCommand = new RelayCommand(Unshelve, CanUnshelve); SelectPendingChangesCommand = new RelayCommand<SelectPendingChangesCommandArgument>(SelectPendingChanges, CanSelectPendingChanges); SelectWorkItemsCommand = new RelayCommand<SelectWorkItemsCommandArgument>(SelectWorkItems, CanSelectWorkItems); PendingSet[] pendingSets; if (teamPilgrimServiceModelProvider.TryWorkspaceQueryShelvedChanges(WorkspaceServiceModel.Workspace, out pendingSets, shelveset.Name, shelveset.OwnerName, null)) { PendingSet = pendingSets.First(); foreach (var pendingChange in PendingSet.PendingChanges) { PendingChanges.Add(new PendingChangeModel(pendingChange) { IncludeChange = true }); } } PopulateSelectedPendingChangesSummary(); }
/// <summary> /// Create Shelveset if she doesn't exist else create a new one /// </summary> /// <param name="name">Name of the Shelvet</param> /// <returns>Return the shelveset</returns> public static Shelveset CreateShelveset(string name) { if (tfsColl == null) { tfsColl = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(tfsExt.ActiveProjectContext.DomainUri)); } if (vcs == null) { vcs = (VersionControlServer)tfsColl.GetService <VersionControlServer>(); } string nameShelveset = name.Replace(" ", ""); Shelveset[] shelves = vcs.QueryShelvesets(nameShelveset, null); int countShelveset = shelves.Count <Shelveset>(); if (countShelveset > 0) { shelveset = shelves[0]; shelvesetExist = true; return(shelveset); } else { shelveset = new Shelveset(vcs, name, workspace.OwnerName); shelveset.Comment = tfsExt.ActiveProjectContext.ProjectName; return(shelveset); } }
public Unshelveable(Shelveset shelveset, PendingSet pendingSet, IVersionControlServer versionControlServer, TfsApiBridge bridge) { _shelveset = shelveset; _versionControlServer = versionControlServer; _bridge = bridge; _pendingSet = pendingSet; _changes = _pendingSet.PendingChanges.Select(x => new UnshelveChange(x, _bridge, versionControlServer)).Cast <IChange>().ToArray(); }
public void ViewShelvesetDetails(Shelveset shelveset) { ITeamExplorer teamExplorer = this.GetService<ITeamExplorer>(); if (teamExplorer != null) { teamExplorer.NavigateToPage(new Guid(TeamExplorerPageIds.ShelvesetDetails), shelveset); } }
private static void ShelveChanges(Workspace workspace, string shelvesetName, Commit commit) { var shelveset = new Shelveset(workspace.VersionControlServer, shelvesetName, workspace.OwnerName); shelveset.Comment = string.Format("TFS shelve of Git Commit {0}{1}{2}", commit.Sha, Environment.NewLine, commit.Message); workspace.Shelve(shelveset, workspace.GetPendingChanges(), ShelvingOptions.None); }
public void ViewShelvesetDetails(Shelveset shelveset) { ITeamExplorer teamExplorer = this.GetService <ITeamExplorer>(); if (teamExplorer != null) { teamExplorer.NavigateToPage(new Guid(TeamExplorerPageIds.ShelvesetDetails), shelveset); } }
/// <summary>The get shelveset changes.</summary> /// <param name="shelveset">The shelveset.</param> /// <returns>A collection of shelveset changes.</returns> internal static PendingSet[] GetShelvesetChanges(Shelveset shelveset) { if (!isInitialized) { throw new Exception("The connection to TFS must be initialized before it can be used."); } return(versionControlcServer.QueryShelvedChanges(shelveset)); }
public void BriefOutput(Shelveset[] shelvesets) { int maxName = 9, maxOwner = 5; foreach (Shelveset shelveset in shelvesets) { if (shelveset.Name.Length > maxName) maxName = shelveset.Name.Length; // domain is stripped on output int ownerNameLen = shelveset.OwnerName.Length; int slash = shelveset.OwnerName.IndexOf('\\'); if (-1 != slash) ownerNameLen = shelveset.OwnerName.Length - slash; if (ownerNameLen > maxOwner) { maxOwner = ownerNameLen; } } int maxComment = WindowWidth - maxName - maxOwner - 2; if (maxComment < 0) maxComment = 0; string line = String.Format("{0} {1} {2}", "Shelveset".PadRight(maxName), "Owner".PadRight(maxOwner), "Comment"); Console.WriteLine(line); line = String.Format("{0} {1} {2}", "-".PadRight(maxName, '-'), "-".PadRight(maxOwner, '-'), "-".PadRight(maxComment, '-')); Console.WriteLine(line); foreach (Shelveset shelveset in shelvesets) { string comment; if (shelveset.Comment.Length > maxComment) comment = shelveset.Comment.Remove(maxComment); else comment = shelveset.Comment; // domain is stripped on output string ownerName = shelveset.OwnerName; int slash = shelveset.OwnerName.IndexOf('\\'); if (-1 != slash) { ownerName = shelveset.OwnerName.Substring(slash+1); } line = String.Format("{0} {1} {2}", shelveset.Name.PadRight(maxName), ownerName.PadRight(maxOwner), comment); Console.WriteLine(line); } }
/// <summary> /// Confirm to the host that we want to to check in the changes as currently staged. /// </summary> private bool ConfirmCheckin(Commit commit, string checkinMessage) { var shelvesetName = string.Format("gitToTfs-{0}", commit.Sha); var shelveset = new Shelveset(_workspace.VersionControlServer, shelvesetName, _workspace.OwnerName); shelveset.Comment = checkinMessage; _workspace.Shelve(shelveset, _workspace.GetPendingChanges(), ShelvingOptions.Replace); return(_host.ConfirmCheckin(shelvesetName)); }
private void ViewShelvesetDetails() { if (ListViewShelvesets.SelectedItems.Count == 1) { Shelveset shelveset = ListViewShelvesets.SelectedItems[0] as Shelveset; if (shelveset != null) { this.ParentSection.ViewShelvesetDetails(shelveset); } } }
public bool TryShelve(Workspace workspace, Shelveset shelveset, PendingChange[] pendingChanges, ShelvingOptions shelvingOptions) { try { _teamPilgrimTfsService.WorkspaceShelve(workspace, shelveset, pendingChanges, shelvingOptions); return(true); } catch (Exception ex) { this.Logger().DebugException(ex); LastException = ex; } return(false); }
public void Shelve(string shelvesetName) { var pendingChanges = _workspace.GetPendingChanges(); if (pendingChanges.Length == 0) { _stdout.WriteLine(" nothing to shelve"); } else { var shelveset = new Shelveset(_workspace.VersionControlServer, shelvesetName, _workspace.OwnerName); shelveset.Comment = _checkinOptions.CheckinComment; shelveset.WorkItemInfo = GetWorkItemInfos(); _workspace.Shelve(shelveset, pendingChanges, _checkinOptions.Force ? ShelvingOptions.Replace : ShelvingOptions.None); } }
public bool TryWorkspaceUnshelve(Workspace workspace, out Shelveset shelveset, string shelvesetName, string shelvesetOwner, ItemSpec[] items = null) { try { shelveset = _teamPilgrimTfsService.WorkspaceUnshelve(workspace, shelvesetName, shelvesetOwner, items); return(true); } catch (Exception ex) { this.Logger().DebugException(ex); LastException = ex; } shelveset = null; return(false); }
private string GetShelveSetName() { string retVal; Shelveset shelveset = m_ShelveComboBox.SelectedItem as Shelveset; if (shelveset != null) { retVal = string.Format("\"{0}\"", shelveset.Name); } else { retVal = string.Format("\"{0}\"", m_ShelveComboBox.Text); } return(retVal); }
private void ShelveComboBox_SelectedIndexChanged(object sender, EventArgs e) { Shelveset shelveset = m_ShelveComboBox.SelectedItem as Shelveset; if (shelveset != null && Vcs != null) { IList <PendingSet> pendingSet = Vcs.QueryShelvedChanges(shelveset); if (pendingSet.Count > 0 && pendingSet[0].PendingChanges[0] != null) { string serverItem = pendingSet[0].PendingChanges[0].ServerItem; m_SourceTextBox.Text = serverItem.Substring(0, serverItem.IndexOf("/src/")); } } GetCommandLine(); }
public DetailsWindow(Shelveset selectedShelveSet) { InitializeComponent(); this.DataContext = this; shelveSet = selectedShelveSet; PendingSet[] pendingSets = selectedShelveSet.VersionControlServer.QueryShelvedChanges(selectedShelveSet); PendingChange[] pendingChanges = pendingSets[0].PendingChanges; foreach (PendingChange change in pendingChanges) { changeItem item = new changeItem(change); shelvedChanges.Add(item); } shelvesetName.Text = shelveSet.Name; owner.Text = shelveSet.OwnerName; date.Text = shelveSet.CreationDate.ToString(); comment.Text = shelveSet.Comment; }
public static void InsertData(Shelveset Shelveset, MySqlConnection myConnection) { try { string query = "INSERT IGNORE INTO shelveset (ShelvesetName, ShelvesetOwner, CreatedDate, Comment, CodeReviewRequestID)"; query += " VALUES (@ShelvesetName, @ShelvesetOwner, @CreatedDate, @Comment, @CodeReviewRequestID)"; MySqlCommand myCommand = new MySqlCommand(query, myConnection); myCommand.Parameters.AddWithValue("@ShelvesetName", Shelveset.ShelvesetName); myCommand.Parameters.AddWithValue("@ShelvesetOwner", Shelveset.ShelvesetOwner); myCommand.Parameters.AddWithValue("@CreatedDate", Shelveset.CreatedDate); myCommand.Parameters.AddWithValue("@Comment", Shelveset.Comment); myCommand.Parameters.AddWithValue("@CodeReviewRequestID", Shelveset.CodeReviewRequestID); int row = myCommand.ExecuteNonQuery(); } catch (Exception e) { string error = "Exception Occre while Inserting in table shelveset :" + e.Message + "\t" + e.GetType(); } }
public bool TryQueryShelvesets(TfsTeamProjectCollection tfsTeamProjectCollection, out Shelveset[] shelvesets, string shelvesetName = null, string shelvesetOwner = null) { try { shelvesets = _teamPilgrimTfsService.QueryShelvesets(tfsTeamProjectCollection: tfsTeamProjectCollection, shelvesetName: shelvesetName, shelvesetOwner: shelvesetOwner); return true; } catch (Exception ex) { this.Logger().DebugException(ex); LastException = ex; } shelvesets = null; return false; }
public bool TryShelve(Workspace workspace, Shelveset shelveset, PendingChange[] pendingChanges, ShelvingOptions shelvingOptions) { try { _teamPilgrimTfsService.WorkspaceShelve(workspace, shelveset, pendingChanges, shelvingOptions); return true; } catch (Exception ex) { this.Logger().DebugException(ex); LastException = ex; } return false; }
public void SaveShelveset() { try { if (TfsExt == null) { return; } // decode the url: some repo's have spaces in them, which are url encoded to %20. var domainUri = WebUtility.UrlDecode(_tfsExt.ActiveProjectContext.DomainUri); var teamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(domainUri)); teamProjectCollection.Credentials = CredentialCache.DefaultNetworkCredentials; teamProjectCollection.EnsureAuthenticated(); var service = (VersionControlServer)teamProjectCollection.GetService(typeof(VersionControlServer)); var allLocalWorkspaceInfo = Workstation.Current.GetAllLocalWorkspaceInfo(); foreach (var workspaceInfo in allLocalWorkspaceInfo) { // Replace(/,"") before comparing domainUri to prevent: "TFS Auto Shelve shelved 0 pending changes. Shelveset Name: " if (workspaceInfo.MappedPaths.Length <= 0 || workspaceInfo.ServerUri.ToString().Replace("/", string.Empty) != domainUri.Replace("/", string.Empty)) { continue; } var workspace = service.GetWorkspace(workspaceInfo); var pendingChanges = workspace.GetPendingChanges(); var numPending = pendingChanges.Count(); if (numPending <= 0) { continue; } var autoShelveEventArg = new ShelvesetCreatedEventArgs(); var setname = string.Format(ShelvesetName, workspaceInfo.Name, workspaceInfo.OwnerName, DateTime.Now); setname = CleanShelvesetName(setname); var shelveset = new Shelveset(service, setname, workspaceInfo.OwnerName); autoShelveEventArg.ShelvesetChangeCount += numPending; autoShelveEventArg.ShelvesetName = setname; shelveset.Comment = string.Format("Shelved by {0}. Items in shelve set: {1}", _extensionName, numPending); workspace.Shelve(shelveset, pendingChanges, ShelvingOptions.Replace); if (MaximumShelvesets > 0) { var autoShelvesets = service.QueryShelvesets(null, workspaceInfo.OwnerName).Where(s => s.Comment != null && s.Comment.Contains(_extensionName)); if (IsWorkspaceSpecificShelvesetName) { var info = workspaceInfo; autoShelvesets = autoShelvesets.Where(s => s.Name.Contains(info.Name)); } foreach (var set in autoShelvesets.OrderByDescending(s => s.CreationDate).Skip(MaximumShelvesets)) { service.DeleteShelveset(set); autoShelveEventArg.ShelvesetsPurgeCount++; } } if (OnShelvesetCreated != null) { OnShelvesetCreated(this, autoShelveEventArg); } } } catch (Exception ex) { if (OnShelvesetCreated != null) { var autoShelveEventArg = new ShelvesetCreatedEventArgs { ExecutionException = ex }; OnShelvesetCreated(this, autoShelveEventArg); } } }
private void Shelve() { var pendingChanges = PendingChanges .Where(model => model.IncludeChange) .Select(model => model.Change) .ToArray(); if (EvaluatePoliciesAndCheckinNotes) { var missingCheckinNotes = CheckinNotes .Where(model => model.CheckinNoteFieldDefinition.Required && string.IsNullOrWhiteSpace(model.Value)) .Select(model => model.CheckinNoteFieldDefinition.Name).ToArray(); if (missingCheckinNotes.Any()) { OnShowPendingChangesItem(ShowPendingChangesTabItemEnum.CheckinNotes); MessageBox.Show( string.Format("Check-in Validation\r\n\r\nEnter a value for {0}", string.Join(", ", missingCheckinNotes)), "Team Pilgrim", MessageBoxButton.OK, MessageBoxImage.Error); return; } } var workItemInfo = WorkItems .Where(model => model.IsSelected) .Select(model => new WorkItemCheckinInfo(model.WorkItem, model.WorkItemCheckinAction.ToWorkItemCheckinAction())) .ToArray(); var checkinNoteFieldValues = CheckinNotes .Where(model => !string.IsNullOrWhiteSpace(model.Value)) .Select(model => new CheckinNoteFieldValue(model.CheckinNoteFieldDefinition.Name, model.Value)) .ToArray(); var checkinNote = new CheckinNote(checkinNoteFieldValues); string policyOverrideComment = null; if (EvaluatePoliciesAndCheckinNotes) { CheckinEvaluationResult checkinEvaluationResult; if (teamPilgrimServiceModelProvider.TryEvaluateCheckin(out checkinEvaluationResult, _workspaceServiceModel.Workspace, pendingChanges, Comment, checkinNote, workItemInfo)) { if (!checkinEvaluationResult.IsValid()) { OnShowPendingChangesItem(ShowPendingChangesTabItemEnum.PolicyWarnings); var policyFailureModel = new PolicyFailureModel(); var policyFailureDialog = new PolicyFailureDialog() { DataContext = policyFailureModel }; var dialogResult = policyFailureDialog.ShowDialog(); if (!dialogResult.HasValue || !dialogResult.Value || !policyFailureModel.Override) { CheckinEvaluationResult = checkinEvaluationResult; return; } policyOverrideComment = policyFailureModel.Reason; } } else { return; } } var versionControlServer = _projectCollectionServiceModel.TfsTeamProjectCollection.GetVersionControlServer(); var shelveset = new Shelveset(versionControlServer, ShelvesetName, _projectCollectionServiceModel.TfsTeamProjectCollection.AuthorizedIdentity.UniqueName) { Comment = Comment, ChangesExcluded = PendingChanges.Count() != pendingChanges.Count(), WorkItemInfo = workItemInfo, CheckinNote = checkinNote, PolicyOverrideComment = policyOverrideComment }; PendingSet[] pendingSets; if (teamPilgrimServiceModelProvider.TryWorkspaceQueryShelvedChanges(_workspaceServiceModel.Workspace, out pendingSets, ShelvesetName, _projectCollectionServiceModel.TfsTeamProjectCollection.AuthorizedIdentity.UniqueName, null)) { bool overwrite = false; if (pendingSets != null && pendingSets.Any()) { if (MessageBox.Show(string.Format("Replace shelveset\r\n\r\nThe shelveset {0} already exists. Replace?", ShelvesetName), "Team Pilgrim", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes) { overwrite = true; } else { return; } } var shelvingOptions = ShelvingOptions.None; if (!PreservePendingChangesLocally) { shelvingOptions |= ShelvingOptions.Move; } if (overwrite) { shelvingOptions |= ShelvingOptions.Replace; } if (teamPilgrimServiceModelProvider.TryShelve(_workspaceServiceModel.Workspace, shelveset, pendingChanges, shelvingOptions)) { } } OnDismiss(true); }
/// <summary> /// Get email reviewer name. /// </summary> private string GetReviewer(Shelveset shelveset) { foreach (CheckinNoteFieldValue value1 in shelveset.CheckinNote.Values) { if (value1.Name == "Code Reviewer") { return value1.Value; } } return null; }
public void WorkspaceShelve(Workspace workspace, Shelveset shelveset, PendingChange[] pendingChanges, ShelvingOptions shelvingOptions) { workspace.Shelve(shelveset, pendingChanges, shelvingOptions); }
public AdapterShelveset(Shelveset shelveset, PendingChange[] pendingChanges, string[] workspaceBranches) { _shelveset = shelveset; Changes = pendingChanges.Select(c => new AdapterShelvesetChange(c, workspaceBranches)).ToList(); }
public void DeleteShelveset(Shelveset shelveset) { DeleteShelveset(shelveset.Name, shelveset.OwnerName); }
/// <summary> /// /// </summary> /// <param name="service"></param> /// <param name="infos"></param> /// <param name="workspaceInfo"></param> /// <param name="force">True when the user manually initiates a ShelveSet via the Team menu or mapped shortcut key.</param> private static ShelvesetCreatedEventArgs CreateShelvesetInternal(VersionControlServer service, WorkspaceInfo workspaceInfo, AutoShelveInfos infos, bool force) { var shelvesetName = default(string); var shelvesetChangeCount = 0; var shelvesetPurgeCount = 0; var error = default(Exception); try { var workspace = service.GetWorkspace(workspaceInfo); // Build a new, valid shelve set name shelvesetName = string.Format(infos.ShelvesetName, workspace.Name, workspace.OwnerName, DateTime.Now, workspace.OwnerName.GetDomain(), workspace.OwnerName.GetLogin()); shelvesetName = shelvesetName.CleanShelvesetName(); // If there are no pending changes that have changed since the last shelveset then there is nothing to do var hasChanges = force; var pendingChanges = workspace.GetPendingChanges(); var numPending = pendingChanges.Length; if (numPending > 0) { var pastShelvesets = GetPastShelvesets(service, workspace, infos.ShelvesetName); if (!force) { var lastShelveset = pastShelvesets.FirstOrDefault(); if (lastShelveset == null) { // If there are pending changes and no shelveset yet exists, then create shelveset. hasChanges = true; } else { // Compare numPending to shelvedChanges.Count(); Force shelveset if they differ // Otherwise, resort to comparing file HashValues var shelvedChanges = service.QueryShelvedChanges(lastShelveset).FirstOrDefault(); hasChanges = (shelvedChanges == null || numPending != shelvedChanges.PendingChanges.Length) || pendingChanges.DifferFrom(shelvedChanges.PendingChanges); } } if (hasChanges) { shelvesetChangeCount = numPending; // Actually create a new Shelveset var shelveset = new Shelveset(service, shelvesetName, workspace.OwnerName) { Comment = string.Format(Resources.ShelvesetComment, VsExtAutoShelvePackage.ExtensionName, numPending) }; workspace.Shelve(shelveset, pendingChanges, ShelvingOptions.Replace); // Clean up past Shelvesets if (infos.MaximumShelvesets > 0) { foreach (var set in pastShelvesets.Skip(infos.MaximumShelvesets)) { service.DeleteShelveset(set); shelvesetPurgeCount++; } } } } } catch (Exception ex) { error = ex; } // Build event args for notification create shelveset result return(new ShelvesetCreatedEventArgs( shelvesetName: shelvesetName, shelvesetChangeCount: shelvesetChangeCount, shelvesetPurgeCount: shelvesetPurgeCount, error: error)); }
private void Shelve() { Shelveset shelveset = new Shelveset(activeWorkspace.VersionControlServer, shelvewindow.shelvesetName.Text, activeWorkspace.OwnerName); shelveset.Comment = shelvewindow.comment.Text; PendingChange[] toShelve = getSelectedChanges(shelveCollection); activeWorkspace.Shelve(shelveset, toShelve, ShelvingOptions.None); // have to "UNDO" on the pending changes that were shelved in order to unshelve the set activeWorkspace.Undo(toShelve); removeFromCollection.Clear(); foreach (PendingChange change in toShelve) { removeFromCollection.Add(change.FileName); } // removes all the pendingchanges tht are in removefromcollection updatePendingChangesList(); }
public override void Run() { string name = String.Empty; string owner = OwnerFromString(OptionOwner); if (Arguments.Length < 1) { Console.WriteLine("Usage: tf shelve [name] [path]"); Environment.Exit((int)ExitCode.Failure); } if (Arguments.Length > 0) { int semicolon = Arguments[0].IndexOf(";"); if (semicolon == -1) name = Arguments[0]; else { name = Arguments[0].Substring(0, semicolon); owner = Arguments[0].Substring(semicolon+1); } } if (OptionDelete) { VersionControlServer.DeleteShelveset(name, owner); Console.WriteLine("Deleted shelveset {0}", name); Environment.Exit((int)ExitCode.Success); } // must be creating or replacing a shelveset Workspace workspace = GetWorkspaceFromCache(); PendingChange[] pendingChanges; if (Arguments.Length < 2) pendingChanges = workspace.GetPendingChanges(); else { List<string> paths = new List<string>(); for (int i = 1; i < Arguments.Length; i++) paths.Add(Path.GetFullPath(Arguments[i])); // process command options RecursionType rtype = OptionRecursive ? RecursionType.Full : RecursionType.None; pendingChanges = workspace.GetPendingChanges(paths.ToArray(), rtype); } if (pendingChanges.Length == 0) { Console.WriteLine("No changes to shelve."); return; } Shelveset shelve = new Shelveset(VersionControlServer, name, owner); ShelvingOptions options = (OptionReplace)? ShelvingOptions.Replace : ShelvingOptions.None; workspace.Shelve(shelve, pendingChanges, options); Console.WriteLine("Created shelveset {0}", name); BriefOutput(pendingChanges, " "); }
internal void UpdateWithShelve(Shelveset shelve, HistoryItem startHistoryItem) { historyControl.UpdateWithShelve(shelve.CreationDate, startHistoryItem.DateTime); }
public void Shelve(Workspace workspace, Shelveset shelveset, string[] serverItems, ShelvingOptions options) { Message msg = new Message(GetWebRequest (new Uri(Url)), "Shelve"); msg.Body.WriteElementString("workspaceName", workspace.Name); msg.Body.WriteElementString("workspaceOwner", workspace.OwnerName); msg.Body.WriteStartElement("serverItems"); foreach (string serverItem in serverItems) msg.Body.WriteElementString("string", serverItem); msg.Body.WriteEndElement(); shelveset.ToXml(msg.Body, "shelveset"); bool replace = (options & ShelvingOptions.Replace) == ShelvingOptions.Replace; msg.Body.WriteElementString("replace", replace.ToString().ToLower()); using (HttpWebResponse response = Invoke(msg)) { msg.ResponseReader(response); } }
public bool TryWorkspaceUnshelve(Workspace workspace, out Shelveset shelveset, string shelvesetName, string shelvesetOwner, ItemSpec[] items = null) { try { shelveset = _teamPilgrimTfsService.WorkspaceUnshelve(workspace, shelvesetName, shelvesetOwner, items); return true; } catch (Exception ex) { this.Logger().DebugException(ex); LastException = ex; } shelveset = null; return false; }
public override void Run() { string name = String.Empty; string owner = OwnerFromString(OptionOwner); if (Arguments.Length < 1) { Console.WriteLine("Usage: tf shelve [name] [path]"); Environment.Exit((int)ExitCode.Failure); } if (Arguments.Length > 0) { int semicolon = Arguments[0].IndexOf(";"); if (semicolon == -1) { name = Arguments[0]; } else { name = Arguments[0].Substring(0, semicolon); owner = Arguments[0].Substring(semicolon + 1); } } if (OptionDelete) { VersionControlServer.DeleteShelveset(name, owner); Console.WriteLine("Deleted shelveset {0}", name); Environment.Exit((int)ExitCode.Success); } // must be creating or replacing a shelveset Workspace workspace = GetWorkspaceFromCache(); PendingChange[] pendingChanges; if (Arguments.Length < 2) { pendingChanges = workspace.GetPendingChanges(); } else { List <string> paths = new List <string>(); for (int i = 1; i < Arguments.Length; i++) { paths.Add(Path.GetFullPath(Arguments[i])); } // process command options RecursionType rtype = OptionRecursive ? RecursionType.Full : RecursionType.None; pendingChanges = workspace.GetPendingChanges(paths.ToArray(), rtype); } if (pendingChanges.Length == 0) { Console.WriteLine("No changes to shelve."); return; } Shelveset shelve = new Shelveset(VersionControlServer, name, owner); ShelvingOptions options = (OptionReplace)? ShelvingOptions.Replace : ShelvingOptions.None; workspace.Shelve(shelve, pendingChanges, options); Console.WriteLine("Created shelveset {0}", name); BriefOutput(pendingChanges, " "); }
private void Shelve() { //need to add exception if the name already exists Shelveset shelveset = new Shelveset(activeWorkspace.VersionControlServer, shelvewindow.shelvesetName.Text, activeWorkspace.OwnerName); shelveset.Comment = shelvewindow.comment.Text; PendingChange[] toShelve = getSelectedChanges(shelveCollection); activeWorkspace.Shelve(shelveset, toShelve, ShelvingOptions.None); // have to "UNDO" on the pending changes that were shelved in order to unshelve the set activeWorkspace.Undo(toShelve); // TODO is there a better way to update the list? this next thing just removes the pending changes from // the collection that i dont want to be there removeFromCollection.Clear(); foreach (PendingChange change in toShelve) { removeFromCollection.Add(change.FileName); } updatePendingChangesList(); // DEBUG //string message = "This is what would have been shelved...\n"; //foreach (PendingChange change in getSelectedChanges(shelveCollection)) //{ // message += change.FileName + "\n"; //} //message += "."; //MessageBox.Show(message); }
public ShelvesetModel(Shelveset shelveset) { Shelveset = shelveset; }
/// <summary> /// Generate the email body. /// </summary> /// <param name="shelve">Shelveset</param> /// <returns>Formatted HTML email body.</returns> private string GenerateMailBody(Shelveset shelveset) { // HACKHACK: We are converting tfs server url http://foo:8080 to http://foo:8090 blindly string tfsWebUIServer = shelveset.VersionControlServer.TeamFoundationServer.Uri.ToString().Replace(":8080", this.webViewPortStr); StringBuilder strBuilder = new StringBuilder(0x400); // Start the table strBuilder.AppendLine("<p"); strBuilder.AppendLine("<table style=\"font-family:verdana;font-size:10pt;\" border=1 cellspacing=0 cellpadding=0>"); // Reviewers row strBuilder.AppendFormat("<tr><td valign=top><b>{0}</b></td>\n", Resources.EmailReviewer); string textReviewer = this.GetReviewer(shelveset); if (string.IsNullOrEmpty(textReviewer)) textReviewer = Resources.EmailReviewerNotPresent; if (!string.IsNullOrEmpty(textReviewer)) { strBuilder.AppendFormat("<td valign=top>{0}</td></tr>\n", textReviewer); } // TFS Server details Row strBuilder.AppendFormat("<tr><td valign=top><b>TFS Server</b></td><td valign=top>{0}</td></tr>", shelveset.VersionControlServer.TeamFoundationServer.Uri); strBuilder.AppendFormat("<tr><td valign=top><b>Shelveset</b></td><td valign=top><a href=\"{0}/ss.aspx?ss={1};{2}\">{1};{2}</a></td></tr>", tfsWebUIServer, shelveset.Name, shelveset.OwnerName ); // Description/Comment Row strBuilder.AppendFormat("<tr><td valign=top><b>{0}</b></td><td valign=top>{1}</td></tr>\n", Resources.EmailDescription, this.HtmlEncode(shelveset.Comment)); // Bugs Row strBuilder.AppendFormat("<tr><td valign=top><b>{0}</b></td><td valign=top>\n", Resources.EmailBugs); foreach (WorkItemCheckinInfo info in shelveset.WorkItemInfo) { strBuilder.AppendFormat("<a href={0}WorkItemTracking/Workitem.aspx?artifactMoniker={1}>{1}</a> {2}<br>\n", shelveset.VersionControlServer.TeamFoundationServer.Uri, info.WorkItem.Id, info.WorkItem.Title); } strBuilder.AppendLine("</td></tr>"); // Files row strBuilder.AppendLine("<tr><td valign=top><b>File(s)</b></td>"); strBuilder.AppendLine("<td style=\"font-family:courier new;font-size:10pt;\" valign=top>"); PendingSet[] pendingSets = this.versionControl.QueryShelvedChanges(shelveset); foreach (PendingSet pendingSet in pendingSets) { foreach (PendingChange changes in pendingSet.PendingChanges) { strBuilder.Append(changes.ChangeTypeName); if ((changes.ChangeType & ChangeType.Edit) == ChangeType.Edit) { strBuilder.AppendFormat(" <a href={0}/history.aspx?item={1}>H</a> ", tfsWebUIServer, changes.ItemId); strBuilder.AppendFormat(" <a href={0}/ann.aspx?item={1}>B</a> ", tfsWebUIServer, changes.ItemId); string diffUrl = string.Format("{0}/UI/Pages/Scc/Difference.aspx?oitem={1}&ocs=-1&mpcid={2}", tfsWebUIServer, changes.ItemId, changes.PendingChangeId); strBuilder.AppendLine(string.Format("<a href={0}>{1}</a> <br>", diffUrl, changes.ServerItem)); } else if ((changes.ChangeType & ChangeType.Add) == ChangeType.Add) { strBuilder.AppendFormat(" H B "); string newUrl = string.Format("{0}/UI/Pages/Scc/ViewSource.aspx?pcid={1}", tfsWebUIServer, changes.PendingChangeId); strBuilder.AppendLine(string.Format("<a href={0}>{1}</a> <br>", newUrl, changes.ServerItem)); } else if ((changes.ChangeType & ChangeType.Delete) == ChangeType.Delete) { strBuilder.AppendFormat(" <a href={0}/history.aspx?item={1}>H</a> ", tfsWebUIServer, changes.ItemId); strBuilder.AppendFormat(" <a href={0}/ann.aspx?item={1}>B</a> ", tfsWebUIServer, changes.ItemId); string newUrl = string.Format("{0}/UI/Pages/Scc/ViewSource.aspx?pcid={1}", tfsWebUIServer, changes.PendingChangeId); strBuilder.AppendLine(string.Format("<a href={0}>{1}</a> <br>", newUrl, changes.ServerItem)); } else { strBuilder.AppendFormat(" H B "); strBuilder.AppendLine(string.Format("{0} <br>", changes.ServerItem)); } } } strBuilder.AppendLine("</td></tr>"); // Test rows to be hand filled by the user strBuilder.AppendLine("<tr><td valign=top><b>Tests Run</b></td><td valign=top></td></tr>"); strBuilder.AppendLine("<tr><td valign=top><b>Tests Added/Fixed</b></td><td valign=top></td></tr>"); // close the table strBuilder.AppendLine("</table>"); return strBuilder.ToString(); }
public void DetailedOutput(Shelveset[] shelvesets) { foreach (Shelveset shelveset in shelvesets) { Console.WriteLine(shelveset); } }
public void Shelve(Shelveset shelveset, PendingChange[] changes, ShelvingOptions options) { List<string> serverItems = new List<string>(); foreach (PendingChange change in changes) { // upload new or changed files only if ((change.ItemType == ItemType.File) && (change.IsAdd || change.IsEdit )) { Repository.ShelveFile(Name, OwnerName, change); } serverItems.Add(change.ServerItem); } Repository.Shelve(this, shelveset, serverItems.ToArray(), options); }
/// <summary> /// /// </summary> /// <param name="service"></param> /// <param name="workspace"></param> /// <param name="force">True when the user manually initiates a ShelveSet via the Team menu or mapped shortcut key.</param> private void CreateShelveset(VersionControlServer service, Workspace workspace, bool force) { // Build event args for notification create shelveset result var autoShelveEventArg = new ShelvesetCreatedEventArgs(); autoShelveEventArg.ShelvesetChangeCount = 0; // Shouldn't be necessary, but forcing it to be safe. try { // If there are no pending changes that have changed since the last shelveset then there is nothing to do bool isDelta = false; var pendingChanges = workspace.GetPendingChanges(); int numPending = pendingChanges.Count(); if (numPending > 0) { if (!force) { var lastShelveset = GetPastShelvesets(service, workspace).FirstOrDefault(); if (lastShelveset == null) { // If there are pending changes and no shelveset yet exists, then create shelveset. isDelta = true; } else { // Compare numPending to shelvedChanges.Count(); Force shelveset if they differ // Otherwise, resort to comparing file HashValues var shelvedChanges = service.QueryShelvedChanges(lastShelveset).FirstOrDefault(); isDelta = (shelvedChanges == null || numPending != shelvedChanges.PendingChanges.Count()) || pendingChanges.DifferFrom(shelvedChanges.PendingChanges); } } if (force || isDelta) { autoShelveEventArg.ShelvesetChangeCount = numPending; // Build a new, valid shelve set name var setname = string.Format(ShelvesetName, workspace.Name, workspace.OwnerName, DateTime.Now, workspace.OwnerName.GetDomain(), workspace.OwnerName.GetLogin()); setname = CleanShelvesetName(setname); // Actually create a new Shelveset var shelveset = new Shelveset(service, setname, workspace.OwnerName); autoShelveEventArg.ShelvesetName = setname; shelveset.Comment = string.Format("Shelved by {0}. {1} items", _extensionName, numPending); workspace.Shelve(shelveset, pendingChanges, ShelvingOptions.Replace); // Clean up past Shelvesets if (MaximumShelvesets > 0) { foreach (var set in GetPastShelvesets(service, workspace).Skip(MaximumShelvesets)) { service.DeleteShelveset(set); autoShelveEventArg.ShelvesetsPurgeCount++; } } } } } catch (Exception ex) { _tfsExt = null; // Force re-init on next attempt autoShelveEventArg.ExecutionException = ex; } // Fire event for each VS instance to report results if (OnShelvesetCreated != null) { OnShelvesetCreated(this, autoShelveEventArg); } }
public ShelvesetViewModel(Shelveset shelveset) : this(shelveset.Name, shelveset.CreationDate, shelveset.OwnerDisplayName) { Shelveset = shelveset; }
/// <summary> /// /// </summary> /// <param name="service"></param> /// <param name="workspace"></param> /// <param name="force">True when the user manually initiates a ShelveSet via the Team menu or mapped shortcut key.</param> private void CreateShelveset(VersionControlServer service, Workspace workspace, bool force) { // Build event args for notification create shelveset result var autoShelveEventArg = new ShelvesetCreatedEventArgs(); try { // If there are no pending changes that have changed since the last shelveset then there is nothing to do bool isDelta = false; var pendingChanges = workspace.GetPendingChanges(); int numPending = pendingChanges.Count(); if (!force && numPending > 0) { // Compare numPending to numItemsShelved; Force shelveset if they differ // Otherwise, resort to comparing file HashValues var lastShelveset = GetPastShelvesets(service, workspace).FirstOrDefault(); var shelvedChanges = service.QueryShelvedChanges(lastShelveset)[0].PendingChanges; int numItemsShelved = lastShelveset == null ? 0 : shelvedChanges.Count(); isDelta = (numPending != numItemsShelved) || pendingChanges.DifferFrom(shelvedChanges); } autoShelveEventArg.ShelvesetChangeCount = (force || isDelta) ? numPending : 0; if (force || isDelta) { // Build a new, valid shelve set name var setname = string.Format(ShelvesetName, workspace.Name, workspace.OwnerName, DateTime.Now, workspace.OwnerName.GetDomain(), workspace.OwnerName.GetLogin()); setname = CleanShelvesetName(setname); // Actually create a new Shelveset var shelveset = new Shelveset(service, setname, workspace.OwnerName); autoShelveEventArg.ShelvesetName = setname; shelveset.Comment = string.Format("Shelved by {0}. {1} items", _extensionName, numPending); workspace.Shelve(shelveset, pendingChanges, ShelvingOptions.Replace); // Clean up past Shelvesets if (MaximumShelvesets > 0) { foreach (var set in GetPastShelvesets(service, workspace).Skip(MaximumShelvesets)) { service.DeleteShelveset(set); autoShelveEventArg.ShelvesetsPurgeCount++; } } } } catch (Exception ex) { _tfsExt = null; // Force re-init on next attempt autoShelveEventArg.ExecutionException = ex; } // Fire event for each VS instance to report results if (OnShelvesetCreated != null) { OnShelvesetCreated(this, autoShelveEventArg); } }
/// <summary> /// Create the email item and fill up to/cc/subject fields. /// </summary> /// <param name="shelveset">Shelveset.</param> /// <returns>MailITem with Subject, To and Cc filled</returns> private MailItem GenerateMailItem(Shelveset shelveset) { Console.WriteLine(Resources.InfoGeneratingEmail); Application application = new ApplicationClass(); MailItem mailItem = (MailItem) new Outlook.Application().CreateItem(OlItemType.olMailItem); mailItem.Subject = string.Format(CultureInfo.InvariantCulture, "CR: <area> {0};{1}", shelveset.Name, shelveset.OwnerName); mailItem.BodyFormat = OlBodyFormat.olFormatHTML; mailItem.To = this.GetReviewer(shelveset); mailItem.CC = this.crAlias; return mailItem; }
private void Shelve() { var pendingChanges = PendingChanges .Where(model => model.IncludeChange) .Select(model => model.Change) .ToArray(); if (EvaluatePoliciesAndCheckinNotes) { var missingCheckinNotes = CheckinNotes .Where(model => model.CheckinNoteFieldDefinition.Required && string.IsNullOrWhiteSpace(model.Value)) .Select(model => model.CheckinNoteFieldDefinition.Name).ToArray(); if (missingCheckinNotes.Any()) { OnShowPendingChangesItem(ShowPendingChangesTabItemEnum.CheckinNotes); MessageBox.Show( string.Format("Check-in Validation\r\n\r\nEnter a value for {0}", string.Join(", ", missingCheckinNotes)), "Team Pilgrim", MessageBoxButton.OK, MessageBoxImage.Error); return; } } var workItemInfo = WorkItems .Where(model => model.IsSelected) .Select(model => new WorkItemCheckinInfo(model.WorkItem, model.WorkItemCheckinAction.ToWorkItemCheckinAction())) .ToArray(); var checkinNoteFieldValues = CheckinNotes .Where(model => !string.IsNullOrWhiteSpace(model.Value)) .Select(model => new CheckinNoteFieldValue(model.CheckinNoteFieldDefinition.Name, model.Value)) .ToArray(); var checkinNote = new CheckinNote(checkinNoteFieldValues); string policyOverrideComment = null; if (EvaluatePoliciesAndCheckinNotes) { CheckinEvaluationResult checkinEvaluationResult; if (teamPilgrimServiceModelProvider.TryEvaluateCheckin(out checkinEvaluationResult, _workspaceServiceModel.Workspace, pendingChanges, Comment, checkinNote, workItemInfo)) { if (!checkinEvaluationResult.IsValid()) { OnShowPendingChangesItem(ShowPendingChangesTabItemEnum.PolicyWarnings); var policyFailureModel = new PolicyFailureModel(); var policyFailureDialog = new PolicyFailureDialog() { DataContext = policyFailureModel }; var dialogResult = policyFailureDialog.ShowDialog(); if (!dialogResult.HasValue || !dialogResult.Value || !policyFailureModel.Override) { CheckinEvaluationResult = checkinEvaluationResult; return; } policyOverrideComment = policyFailureModel.Reason; } } else { return; } } var versionControlServer = _projectCollectionServiceModel.TfsTeamProjectCollection.GetVersionControlServer(); var shelveset = new Shelveset(versionControlServer, ShelvesetName, _projectCollectionServiceModel.TfsTeamProjectCollection.AuthorizedIdentity.UniqueName) { Comment = Comment, ChangesExcluded = PendingChanges.Count() != pendingChanges.Count(), WorkItemInfo = workItemInfo, CheckinNote = checkinNote, PolicyOverrideComment = policyOverrideComment }; PendingSet[] pendingSets; if (teamPilgrimServiceModelProvider.TryWorkspaceQueryShelvedChanges(_workspaceServiceModel.Workspace, out pendingSets, ShelvesetName, _projectCollectionServiceModel.TfsTeamProjectCollection.AuthorizedIdentity.UniqueName, null)) { bool overwrite = false; if (pendingSets != null && pendingSets.Any()) { if (MessageBox.Show(string.Format("Replace shelveset\r\n\r\nThe shelveset {0} already exists. Replace?", ShelvesetName), "Team Pilgrim", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes) { overwrite = true; } else { return; } } var shelvingOptions = ShelvingOptions.None; if (!PreservePendingChangesLocally) shelvingOptions |= ShelvingOptions.Move; if (overwrite) shelvingOptions |= ShelvingOptions.Replace; if (teamPilgrimServiceModelProvider.TryShelve(_workspaceServiceModel.Workspace, shelveset, pendingChanges, shelvingOptions)) { } } OnDismiss(true); }
public IShelveset Wrap(Shelveset shelveset) { return new WrapperForShelveset(this, shelveset); }
public IShelveset CreateShelveset(IWorkspace workspace, string shelvesetName) { var shelveset = new Shelveset(_bridge.Unwrap <Workspace>(workspace).VersionControlServer, shelvesetName, workspace.OwnerName); return(_bridge.Wrap <WrapperForShelveset, Shelveset>(shelveset)); }
public IShelveset CreateShelveset(IWorkspace workspace, string shelvesetName) { var shelveset = new Shelveset(_bridge.Unwrap<Workspace>(workspace).VersionControlServer, shelvesetName, workspace.OwnerName); return _bridge.Wrap<WrapperForShelveset, Shelveset>(shelveset); }
/// <summary> /// Initializes the Shelveset Comparison View Model /// </summary> /// <param name="firstShelveset">The first shelveset.</param> /// <param name="secondShelveset">The second shelveset</param> public void Initialize(Shelveset firstShelveset, Shelveset secondShelveset) { if (firstShelveset == null) { throw new ArgumentNullException("firstShelveset"); } if (secondShelveset == null) { throw new ArgumentNullException("secondShelveset"); } var tfcontextManager = this.GetService <ITeamFoundationContextManager>(); var vcs = tfcontextManager.CurrentContext.TeamProjectCollection.GetService <VersionControlServer>(); if (vcs == null) { this.SummaryText = Resources.ConnectionErrorMessage; return; } this.FirstShelvesetName = firstShelveset.Name; this.SecondShelvesetName = secondShelveset.Name; this.files.Clear(); var firstShelvesetChanges = vcs.QueryShelvedChanges(firstShelveset)[0].PendingChanges; var secondShelvesetChanges = vcs.QueryShelvedChanges(secondShelveset)[0].PendingChanges; var orderedCollection = new SortedList <string, FileComparisonViewModel>(); int sameContentFileCount = 0; int commonFilesCount = 0; foreach (var pendingChange in firstShelvesetChanges) { var matchingFile = secondShelvesetChanges.FirstOrDefault(s => s.ItemId == pendingChange.ItemId); if (matchingFile == null) { matchingFile = secondShelvesetChanges.FirstOrDefault(s => s.LocalOrServerItem == pendingChange.LocalOrServerItem); } bool sameContent = matchingFile != null?AreFilesInPendingChangesSame(pendingChange, matchingFile) : false; FileComparisonViewModel comparisonItem = new FileComparisonViewModel() { FirstFile = pendingChange, SecondFile = matchingFile, Color = sameContent ? ColorMatchingFiles : (matchingFile != null) ? ColorDifferentFiles : ColorNoMatchingFile }; orderedCollection.Add(pendingChange.LocalOrServerFolder + "/" + pendingChange.FileName, comparisonItem); if (sameContent) { sameContentFileCount++; } if (matchingFile != null) { commonFilesCount++; } } foreach (var pendingChange in secondShelvesetChanges) { if (!orderedCollection.ContainsKey(pendingChange.LocalOrServerFolder + "/" + pendingChange.FileName)) { var isThereAreNamedFile = FindItemWithSameItemId(orderedCollection, pendingChange.ItemId); if (isThereAreNamedFile == null) { FileComparisonViewModel comparisonItem = new FileComparisonViewModel() { SecondFile = pendingChange, Color = ColorNoMatchingFile }; orderedCollection.Add(pendingChange.LocalOrServerFolder + "/" + pendingChange.FileName, comparisonItem); } } } foreach (var item in orderedCollection.Keys) { this.files.Add(orderedCollection[item]); } if (firstShelveset.Name == secondShelveset.Name && firstShelveset.OwnerName == secondShelveset.OwnerName) { this.SummaryText = Resources.SameShelvesetMessage; this.TotalNumberOfFiles = firstShelvesetChanges.Count(); this.NumberOfDifferentFiles = 0; this.NumberOfMatchingFiles = firstShelvesetChanges.Count(); } else { this.SummaryText = string.Format(CultureInfo.CurrentCulture, Resources.SummaryMessage, commonFilesCount, sameContentFileCount, orderedCollection.Count - sameContentFileCount); this.TotalNumberOfFiles = commonFilesCount; this.NumberOfMatchingFiles = sameContentFileCount; this.NumberOfDifferentFiles = orderedCollection.Count - sameContentFileCount; } }