private void CommitMerge(CheckInSummaryViewModel vm, TrackProgressParameters externalProgress = null)
{
var associatedWorkItems
= vm
.SourceChangesets
.SelectMany(changeset => changeset.RelatedWorkItems)
.GroupBy(workItem => workItem.WorkItem.Id)
.Select(group => group.First());
int cs = -1;
try
{
Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(progressParams) =>
{
//cs = vm.TemporaryWorkspace.CheckIn(associatedWorkItems, vm.CheckInComment);
cs = 1;
}, externalProgress);
}
catch (OperationCanceledException)
{
}
var newChangeset = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(Repository.Instance.TfsBridgeProvider.GetChangesetById(cs)));
var relatedChangesetListElements =
_changesetList.Where(element => vm.SourceChangesets.Any(changeset => changeset.Changeset.ChangesetId == element.SourceCheckinId));
foreach (var sourceCS in vm.SourceChangesets)
{
_allAssociatedChangesetsIncludingMerges.Add(new MergedChangesetLink()
{
Source = TfsItemCache.GetChangesetFromCache(sourceCS.Changeset.ChangesetId), Target = newChangeset
});
}
foreach (var element in relatedChangesetListElements)
{
element.TargetCheckinDate = newChangeset.TfsChangeset.Changeset.CreationDate;
element.TargetCheckinId = newChangeset.TfsChangeset.Changeset.ChangesetId;
element.TargetExists = true;
element.CanBeMerged = false;
DetermineWarningStatus(element);
}
}
bool PerformMerge(ChangesetListElement item, TrackProgressParameters externalProgress = null)
{
bool returnValue = false;
if (item == null)
{
return(false);
}
var tempWorkspace = Repository.Instance.TfsBridgeProvider.GetTemporaryWorkspace(MergeSource, MergeTarget);
var mergeChangeset = TfsItemCache.GetChangesetFromCache(item.SourceCheckinId).TfsChangeset;
bool finished = Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(progressParams) =>
{
tempWorkspace.Merge(
MergeTarget, PathFilter,
new ITfsChangeset[] { mergeChangeset }.AsEnumerable(),
progressParams.TrackProgress);
}, String.Format("Merging changeset #{0} ...", item.SourceCheckinId), externalProgress);
if (!finished)
{
tempWorkspace.UndoAllPendingChanges();
return(false);
}
var checkInSummary = new CheckInSummaryViewModel();
tempWorkspace.RefreshConflicts();
checkInSummary.Changes =
tempWorkspace.PendingChanges
.Select(
change => new CheckInSummaryViewModel.PendingChangeWithConflict(
change,
tempWorkspace.Conflicts.Where(conflict => conflict.ServerPath == change.ServerPath).FirstOrDefault()))
.ToList();
while (tempWorkspace.Conflicts.Count != 0)
{
int oldConflictsCount = tempWorkspace.Conflicts.Count;
Repository.Instance.TfsUIInteractionProvider.ResolveConflictsPerTF(tempWorkspace.MappedFolder);
tempWorkspace.RefreshConflicts();
if (tempWorkspace.Conflicts.Count == oldConflictsCount)
{
MessageBoxViewModel mbvm = new MessageBoxViewModel("Cancel merge?", "There are conflicts remaining to be solved. Really cancel the merge?", MessageBoxViewModel.MessageBoxButtons.None);
var yesButton = new MessageBoxViewModel.MessageBoxButton("_Yes");
mbvm.ConfirmButtons.Add(yesButton);
mbvm.ConfirmButtons.Add(new MessageBoxViewModel.MessageBoxButton("_No"));
Repository.Instance.ViewManager.ShowModal(mbvm);
if (yesButton.IsChecked)
{
finished = false;
break;
}
}
}
if (finished)
{
checkInSummary.TemporaryWorkspace = tempWorkspace;
checkInSummary.OriginalChangesets = new ITfsChangeset[] { item.Changeset.TfsChangeset }.ToList();
checkInSummary.SourceChangesets = new ITfsChangeset[] { mergeChangeset }.ToList();
checkInSummary.AssociatedWorkItems = item.Changeset.TfsChangeset.RelatedWorkItems;
checkInSummary.CheckInComment = BuildCheckInComment(
item.Changeset.TfsChangeset, mergeChangeset);
if (externalProgress == null)
{
var view = Repository.Instance.ViewManager.CreateViewFor(checkInSummary);
view.Finished += CheckInDialogClosed;
}
else
{
checkInSummary.Cancelled = false;
CommitMerge(checkInSummary, externalProgress);
}
returnValue = true;
}
else
{
tempWorkspace.UndoAllPendingChanges();
}
return(returnValue);
}
private void CommitMerge(CheckInSummaryViewModel vm, TrackProgressParameters externalProgress = null)
{
try
{
var associatedWorkItems
= vm
.SourceChangesets
.SelectMany(changeset => changeset.RelatedWorkItems)
.GroupBy(workItem => workItem.WorkItem.Id)
.Select(group => group.First());
int cs = -1;
try
{
Exception ex = null;
Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(progressParams) =>
{
try
{
cs = vm.TemporaryWorkspace.CheckIn(associatedWorkItems, vm.CheckInComment);
Repository.Instance.BackgroundTaskManager.Post(
() =>
{
TfsItemCache.ChangesetsHaveBeenMerged(vm.SourceChangesets);
return(true);
});
}
catch (Exception e)
{
ex = e;
}
}, externalProgress);
if (ex != null && ex.Message.Contains("TF26006"))
{
MessageBoxViewModel mbvm =
new MessageBoxViewModel(
"TFS Workspace Exception",
"Error TF26006 occurred during check in.\r\n" +
"Unfortunately when this happens, the check in has occurred already but\r\n" +
"the work item association didn't work; please associate the merged changeset\r\n" +
"manually.\r\n\r\n" +
"To avoid this error, please clear the local TFS cache manually by \r\n" +
"deleting all files in the cache folder before continuing merging.", MessageBoxViewModel.MessageBoxButtons.None);
var yesButton = new MessageBoxViewModel.MessageBoxButton("_Show TFS cache");
mbvm.ConfirmButtons.Add(yesButton);
mbvm.ConfirmButtons.Add(new MessageBoxViewModel.MessageBoxButton("_Ignore"));
Repository.Instance.ViewManager.ShowModal(mbvm);
if (yesButton.IsChecked)
{
Process.Start("explorer.exe", Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Microsoft\\TeamFoundation\\4.0\\Cache"));
}
}
}
catch (OperationCanceledException)
{
}
var newChangeset = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(Repository.Instance.TfsBridgeProvider.GetChangesetById(cs)));
var relatedChangesetListElements =
_changesetList.Where(element => vm.SourceChangesets.Any(changeset => changeset.Changeset.ChangesetId == element.SourceCheckinId));
foreach (var element in relatedChangesetListElements)
{
element.TargetCheckinDate = newChangeset.TfsChangeset.Changeset.CreationDate;
element.TargetCheckinId = newChangeset.TfsChangeset.Changeset.ChangesetId;
element.TargetExists = true;
element.CanBeMerged = false;
DetermineWarningStatus(element);
}
if (SelectNewRowAction != null)
{
SelectNewRowAction();
}
NothingToMergeLeft = !IsAnythingToMergeLeft();
}
catch (Exception ex)
{
SimpleLogger.Log(ex, true, true);
throw;
}
}
bool PerformMerge(ChangesetListElement item, TrackProgressParameters externalProgress = null)
{
SimpleLogger.Checkpoint("PerformMerge: Starting");
bool returnValue = false;
bool undoPendingChanges = true;
if (item == null)
{
return(false);
}
SimpleLogger.Checkpoint("PerformMerge: Getting temporary workspace");
var tempWorkspace = Repository.Instance.TfsBridgeProvider.GetTemporaryWorkspace(MergeSource, MergeTarget);
SimpleLogger.Checkpoint("PerformMerge: Undoing pending changes in temporary workspace");
tempWorkspace.UndoAllPendingChanges();
try
{
var mergeChangeset = TfsItemCache.GetChangesetFromCache(item.SourceCheckinId).TfsChangeset;
bool finished = false;
try
{
finished = Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(progressParams) =>
{
tempWorkspace.Merge(
MergeTarget, PathFilter,
new ITfsChangeset[] { mergeChangeset }.AsEnumerable(),
progressParams.TrackProgress);
}, String.Format("Merging changeset #{0} ...", item.SourceCheckinId), externalProgress);
}
catch (AggregateException ex)
{
bool otherExceptions = false;
foreach (var iex in ex.InnerExceptions)
{
if (iex is LocalPathTooLongException)
{
DisplayPathTooLongHelp();
}
else
{
SimpleLogger.Log(ex, false, false);
otherExceptions = true;
}
}
if (otherExceptions)
{
SimpleLogger.Log(ex, true);
}
}
catch (LocalPathTooLongException)
{
DisplayPathTooLongHelp();
return(false);
}
catch (Exception ex)
{
SimpleLogger.Log(ex);
return(false);
}
if (!finished)
{
return(false);
}
SimpleLogger.Checkpoint("PerformMerge: Building check-in summary");
var checkInSummary = new CheckInSummaryViewModel();
SimpleLogger.Checkpoint("PerformMerge: Refreshing conflicts");
tempWorkspace.RefreshConflicts();
SimpleLogger.Checkpoint("PerformMerge: Refreshing pending changes");
tempWorkspace.RefreshPendingChanges();
checkInSummary.SourceBranch = MergeSource;
checkInSummary.TargetBranch = MergeTarget;
checkInSummary.Changes =
tempWorkspace.PendingChanges
.Select(
change => new CheckInSummaryViewModel.PendingChangeWithConflict(
change,
tempWorkspace.Conflicts.Where(conflict => conflict.ServerPath == change.ServerPath).FirstOrDefault()))
.ToList();
// Automerging but conflicts?
if (externalProgress != null && tempWorkspace.Conflicts.Count != 0)
{
return(false);
}
bool hadConflicts = ResolveConflicts(tempWorkspace, ref finished);
if (finished)
{
SimpleLogger.Checkpoint("PerformMerge: Finished");
if (!item.OriginalChangesetLoaded)
{
FindOriginalChangeset(item.SourceCheckinId);
}
checkInSummary.TemporaryWorkspace = tempWorkspace;
var originalCsWrapper = item.OriginalChangesetLoaded ? TfsItemCache.GetChangesetFromCache(item.OriginalChangesetId) : null;
var originalCs = originalCsWrapper != null ? originalCsWrapper.TfsChangeset : null;
checkInSummary.OriginalChangesets = new ITfsChangeset[] { originalCs ?? mergeChangeset }.ToList();
checkInSummary.SourceChangesets = new ITfsChangeset[] { mergeChangeset }.ToList();
checkInSummary.AssociatedWorkItems = item.SourceChangeset.RelatedWorkItems;
checkInSummary.CheckInComment = BuildCheckInComment(
item.SourceChangeset, mergeChangeset);
if (hadConflicts || (externalProgress == null && AutoMergeDirectly == false))
{
SimpleLogger.Checkpoint("PerformMerge: Showing check-in dialog");
if (Repository.Instance.Settings.FetchSettings <bool>(Constants.Settings.PerformNonModalMergeKey))
{
undoPendingChanges = false;
EmbeddedCheckInSummaryViewModel = checkInSummary;
_temporaryWorkspace = tempWorkspace;
EmbeddedCheckInSummaryViewModel.Finished += EmbeddedCheckInSummaryViewModel_Finished;
}
else
{
Repository.Instance.ViewManager.ShowModal(checkInSummary);
}
if (!checkInSummary.Cancelled)
{
CommitMerge(checkInSummary);
}
}
else
{
SimpleLogger.Checkpoint("PerformMerge: Check-in automatically cancelled");
checkInSummary.Cancelled = false;
CommitMerge(checkInSummary, externalProgress);
}
returnValue = !hadConflicts;
}
else
{
SimpleLogger.Checkpoint("PerformMerge: Not finished");
}
}
finally
{
if (undoPendingChanges)
{
SimpleLogger.Checkpoint("PerformMerge: Undoing pending changes");
tempWorkspace.UndoAllPendingChanges();
}
else
{
SimpleLogger.Checkpoint("PerformMerge: NOT undoing pending changes");
}
}
SimpleLogger.Checkpoint("PerformMerge: Returning");
return(returnValue);
}
public void HighlightChangesets(TrackProgressParameters trackProgressParams = null)
{
bool incrementProgress = false;
if (trackProgressParams != null)
{
if (trackProgressParams.ShouldSetMaximumValue())
{
trackProgressParams.TrackProgress.MaxProgress
= WorkItemCache
.Where(workItem => workItem.IsSelected)
.Select(workItem => workItem.RelatedChangesetCount)
.Sum();
}
if (!trackProgressParams.ShouldExecute())
{
return;
}
incrementProgress = trackProgressParams.ShouldIncrement();
}
var changesetsToHighlight = new List <int>();
var workItemsWithWarnings = new Dictionary <int, string>();
var map = _changesetCacheMap;
var warnings = new System.Text.StringBuilder();
foreach (var item in WorkItemCache.Where(workItem => workItem.IsSelected))
{
int countWarnings = 0;
warnings.Clear();
foreach (var changeset in item.RelatedChangesetsAsEnumerable)
{
if (trackProgressParams != null)
{
if (incrementProgress)
{
trackProgressParams.TrackProgress.Increment();
}
trackProgressParams.CancellationToken.ThrowIfCancellationRequested();
}
if (map.ContainsKey(changeset.Changeset.ChangesetId))
{
changesetsToHighlight.Add(changeset.Changeset.ChangesetId);
}
if (!map.ContainsKey(changeset.Changeset.ChangesetId) || !map[changeset.Changeset.ChangesetId].IsVisible)
{
++countWarnings;
warnings.Append(String.Format("Changeset #{0}, Comment: {1}\n", changeset.Changeset.ChangesetId, changeset.Changeset.Comment));
}
}
if (countWarnings > 0)
{
workItemsWithWarnings[item.TfsWorkItem.Id] =
String.Format("The following {0} items were not found in the changeset view:\n", countWarnings)
+ warnings;
}
}
foreach (var item in ChangesetCache)
{
item.IsHighlighted = changesetsToHighlight.Contains(item.TfsChangeset.Changeset.ChangesetId);
}
foreach (var item in WorkItemCache)
{
string warningText = null;
item.HasWarning = workItemsWithWarnings.TryGetValue(item.TfsWorkItem.Id, out warningText);
item.WarningText = item.HasWarning ? warningText : null;
}
}
/// <summary>
/// Highlight work items which are referred to by selected changesets
/// </summary>
/// <param name="trackProgressParams">TrackProgressParameters</param>
public void HighlightWorkItems(TrackProgressParameters trackProgressParams = null)
{
bool incrementProgress = false;
if (trackProgressParams != null)
{
if (trackProgressParams.ShouldSetMaximumValue())
{
trackProgressParams.TrackProgress.MaxProgress
= ChangesetCache
.Count(changeset => changeset.IsSelected);
}
if (!trackProgressParams.ShouldExecute())
{
return;
}
incrementProgress = trackProgressParams.ShouldIncrement();
}
var workItemsToHighlight = new List <int>();
var changesetsWithWarnings = new Dictionary <int, string>();
var map = _workItemCacheMap;
var warnings = new System.Text.StringBuilder();
foreach (var item in ChangesetCache.Where(changeset => changeset.IsSelected))
{
if (trackProgressParams != null)
{
if (incrementProgress)
{
trackProgressParams.TrackProgress.Increment();
}
trackProgressParams.CancellationToken.ThrowIfCancellationRequested();
}
int countWarnings = 0;
warnings.Clear();
item.HasWarning = false;
foreach (var workItem in item.TfsChangeset.RelatedWorkItems)
{
if (trackProgressParams != null)
{
trackProgressParams.CancellationToken.ThrowIfCancellationRequested();
}
if (map.ContainsKey(workItem.Id))
{
workItemsToHighlight.Add(workItem.Id);
}
if (!map.ContainsKey(workItem.Id) || !map[workItem.Id].IsVisible)
{
++countWarnings;
warnings.Append(String.Format("Work Item #{0}, Title: {1}\n", workItem.Id, workItem.Title));
}
}
if (countWarnings > 0)
{
changesetsWithWarnings[item.TfsChangeset.Changeset.ChangesetId] = String.Format("The following {0} items were not found in the work item view:\n", countWarnings)
+ warnings;
}
}
Repository.Instance.BackgroundTaskManager.Send(
() =>
{
foreach (var item in WorkItemCache)
{
item.IsHighlighted = workItemsToHighlight.Contains(item.TfsWorkItem.Id);
}
foreach (var item in ChangesetCache)
{
string warningText = null;
item.HasWarning = changesetsWithWarnings.TryGetValue(item.TfsChangeset.Changeset.ChangesetId, out warningText);
item.WarningText = item.HasWarning ? warningText : null;
}
return(true);
});
}
