/// <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);
}
}
public ShelvesetModel(Shelveset shelveset)
{
Shelveset = shelveset;
}
/// <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;
}
}
public void WorkspaceShelve(Workspace workspace, Shelveset shelveset, PendingChange[] pendingChanges, ShelvingOptions shelvingOptions)
{
workspace.Shelve(shelveset, pendingChanges, shelvingOptions);
}
