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);
}
}
private void DetermineWarningStatus(ChangesetListElement changesetListElement)
{
if (changesetListElement.TargetCheckinId != 0)
{
return;
}
if (changesetListElement.SourceCheckinId == 0)
{
changesetListElement.HasWarning = true;
changesetListElement.WarningText =
"This changeset has not yet been merged to the selected source branch.";
changesetListElement.CanBeMerged = false;
return;
}
TfsChangesetWrapper sourceCS =
TfsItemCache.GetChangesetFromCache(changesetListElement.SourceCheckinId);
bool anyChangeNotInFilter
= PathFilter == null ? false :
sourceCS.TfsChangeset.GetAllChanges()
.Any(change => !change.Change.Item.ServerItem.StartsWith(PathFilter));
bool allChangesNotInFilter
= PathFilter == null ? false :
sourceCS.TfsChangeset.GetAllChanges()
.All(change => !change.Change.Item.ServerItem.StartsWith(PathFilter));
if (anyChangeNotInFilter || allChangesNotInFilter)
{
changesetListElement.HasWarning = true;
if (allChangesNotInFilter)
{
changesetListElement.WarningText =
"No change in this changeset is part of the merge due to the path filter selection.";
changesetListElement.CanBeMerged = false;
}
else if (anyChangeNotInFilter)
{
changesetListElement.WarningText =
"Some changes in this changeset are not part of the merge due to the path filter selection.";
}
}
}
void FindOriginalChangeset(int id)
{
var listElement = ChangesetList.Where(item => item.SourceCheckinId == id).FirstOrDefault();
if (listElement == null)
{
throw new ArgumentException("Changeset Id not found in list");
}
var changeset = TfsItemCache.GetChangesetFromCache(id);
if (changeset == null)
{
throw new ArgumentException("Changeset not found");
}
var sourceChangesets = new Dictionary <int, MergedChangeset>();
var targetChangesets = new Dictionary <int, MergedChangeset>();
foreach (var merge in changeset.TfsChangeset.FindMergesForActiveProject(MergeSource, PossibleMergeTargets))
{
sourceChangesets[merge.Source.Changeset.ChangesetId] = merge;
targetChangesets[merge.Target.Changeset.ChangesetId] = merge;
}
var relevantId = sourceChangesets.Keys.Except(targetChangesets.Keys).ToArray();
if (relevantId.Length > 1)
{
listElement.OriginalChangesetId = id;
listElement.OriginalChangesetLoaded = true;
listElement.HasWarning = true;
listElement.WarningText = "Could not determine original changeset.";
}
else
{
listElement.OriginalChangesetId = relevantId.Length > 0 ? relevantId[0] : id;
listElement.OriginalChangesetLoaded = true;
}
}
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);
}
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);
}