public PrepareMergeViewModel(TfsItemCache tfsItemCache, IEnumerable <ITfsWorkItem> workItems)
: base(typeof(PrepareMergeViewModel))
{
try
{
TfsItemCache = tfsItemCache;
MergeSourcesLoading = new LoadingProgressViewModel();
MergeTargetsLoading = new LoadingProgressViewModel();
ChangesetsLoading = new LoadingProgressViewModel();
ChangesetsRefreshing = new LoadingProgressViewModel();
OpenChangesetCommand = new RelayCommand((o) => OpenChangeset((int)o));
FindOriginalChangesetCommand = new RelayCommand((o) => FindOriginalChangeset((int)o));
PerformMergeCommand = new RelayCommand((o) => PerformMerge(o as ChangesetListElement), (o) => o != null);
PickPathFilterCommand = new RelayCommand((o) => PickPathFilter());
AutoMergeCommand = new RelayCommand((o) => AutoMerge(), (o) => IsAnythingToMergeLeft());
OKCommand = new RelayCommand((o) => OK());
var potentialMergeSourceBranches = Enumerable.Empty <ITfsBranch>();
bool finished = Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(progressParams) =>
{
Changesets = new List <ITfsChangeset>();
progressParams.TrackProgress.MaxProgress = workItems.Count();
foreach (var workItem in workItems)
{
progressParams.CancellationToken.ThrowIfCancellationRequested();
foreach (var changeset in workItem.RelatedChangesets)
{
progressParams.CancellationToken.ThrowIfCancellationRequested();
Changesets.Add(changeset);
potentialMergeSourceBranches = potentialMergeSourceBranches.Union(changeset.GetAffectedBranchesForActiveProject());
}
progressParams.TrackProgress.Increment();
}
Changesets = Changesets
.GroupBy(changeset => changeset.Changeset.ChangesetId)
.Select(group => group.First())
.OrderBy(changeset => changeset.Changeset.ChangesetId).ToList();
});
if (!finished)
{
throw new OperationCanceledException();
}
if (!potentialMergeSourceBranches.Any())
{
throw new ArgumentException();
}
PossibleMergeSources = potentialMergeSourceBranches.ToList();
ListenToSettingsChanges();
} catch (Exception ex)
{
SimpleLogger.Log(ex, true, true);
throw;
}
}
protected override void Refresh()
{
base.Refresh();
ItemsLoading.IsLoading = true;
ItemsLoading.ProgressInfo = "Reloading projects, branches and changesets ... please wait";
ResetWorkItems();
SetContent(new ObservableCollection <TfsWorkItemWrapper>());
TfsItemCache.Clear();
Repository.Instance.TfsBridgeProvider.Refresh();
}
private void LoadChangesetList(bool refresh = false)
{
if (_changesetLoadingTaskActive)
{
if (!refresh)
{
return;
}
}
_changesetLoadingTaskActive = true;
Repository.Instance.BackgroundTaskManager.Start(
Constants.Tasks.LoadChangesetListKey,
refresh ? ChangesetsRefreshing : ChangesetsLoading,
(task) =>
{
var results = new List <ChangesetListElement>();
task.TrackProgress.ProgressInfo = "Loading changesets ...";
lock (_changesetLock)
{
int count = 0;
foreach (var changeset in _changesets)
{
task.TrackProgress.ProgressInfo = string.Format("Loading changesets ({0} done) ...", ++count);
var source = FindChangeset(changeset, MergeSource);
var target = FindChangeset(changeset, MergeTarget);
var changesetListElement =
new ChangesetListElement()
{
Changeset = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(changeset)),
CanBeMerged = (target == null),
SourceExists = (source != null),
SourceCheckinDate = (source != null) ? source.Changeset.CreationDate : DateTime.MinValue,
SourceCheckinId = (source != null) ? source.Changeset.ChangesetId : 0,
TargetExists = (target != null),
TargetCheckinDate = (target != null) ? new DateTime?(target.Changeset.CreationDate) : null,
TargetCheckinId = (target != null) ? target.Changeset.ChangesetId : 0
};
DetermineWarningStatus(changesetListElement);
results.Add(changesetListElement);
}
}
Repository.Instance.BackgroundTaskManager.Post(
() =>
{
_changesetLoadingTaskActive = false;
_changesetList = results;
RaisePropertyChanged("ChangesetList");
return(true);
});
});
}
private void HighlightChangesets(TfsWorkItemWrapper sender)
{
_workItemHighlightUpdatePending = false;
if (!Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(trackProgressParameters) => TfsItemCache.HighlightChangesets(trackProgressParameters),
"Please wait while the changeset view is being updated ..."))
{
sender.IsSelected = false;
}
}
private void LoadChangesets(ITfsBranch sourceBranch, ITfsBranch targetBranch, string sourcePathFilter, BackgroundTask task)
{
task.TrackProgress.ProgressInfo = "Loading merge candidates ...";
var changesets = new ObservableCollection <TfsChangesetWrapper>(TfsItemCache.QueryChangesets(sourceBranch, targetBranch, sourcePathFilter));
Repository.Instance.BackgroundTaskManager.Post(
() =>
{
if (!task.Cancelled.IsCancellationRequested)
{
SetContent(changesets);
}
return(true);
});
}
public ChangesetViewModel(TfsItemCache tfsItemCache)
: base("Changeset", typeof(ChangesetViewModel))
{
Repository.Instance.VMergeUIProvider.MergeWindowVisibilityChanged += (o, a) => Enabled = !Repository.Instance.VMergeUIProvider.IsMergeWindowVisible();
Enabled = !Repository.Instance.VMergeUIProvider.IsMergeWindowVisible();
_applyFilterTimer = new DispatcherTimer();
_applyFilterTimer.Interval = new TimeSpan(0, 0, 0, 0, 350);
_applyFilterTimer.Tick += (o, a) => PerformApplyFilter();
TfsItemCache = tfsItemCache;
ViewSelectionViewModel = new ViewSelectionViewModel();
Changesets = new ObservableCollection <TfsChangesetWrapper>();
FilteredChangesets = new ObservableCollection <TfsChangesetWrapper>();
_changesetsToResetOnCancel = new List <Tuple <TfsChangesetWrapper, bool> >();
ChangesetList =
new FieldMapperGridViewModel <TfsChangesetWrapper>(
new ChangesetPropertyAccessor(),
FilteredChangesets,
Columns);
ChangesetList.ColumnSettingsChanged += (o, a) => DataWasModified();
ViewSelectionViewModel.ViewSelectionChanged += OnViewSelectionChanged;
ItemSelectedCommand = new RelayCommand((o) => ItemSelected(o), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
ShowWorkItemViewCommand = new RelayCommand((o) => ShowWorkItemView(), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
SelectMarkedItemsCommand = new RelayCommand((o) => SelectMarkedItems(), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
ViewChangesetCommand = new RelayCommand((o) => ViewChangeset(o), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
TrackChangesetCommand = new RelayCommand((o) => TrackChangeset(o), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
MergeCommand = new RelayCommand((o) => Merge(o), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
ShowMergeViewCommand = new RelayCommand((o) => ShowMergeView(), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
SelectAllCommand = new RelayCommand((o) => SelectAll(), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
SaveMergeProfileCommand = new RelayCommand((o) => SaveMergeProfile(), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
RefreshCommand = new RelayCommand((o) => Refresh(), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
ShowLogFileWindowCommand = new RelayCommand((o) => ShowLogFileWindow(o), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
AttachToChangesetCache();
AttachToProfileProvider();
Repository.Instance.TfsBridgeProvider.ActiveProjectSelected += (o, a) =>
{
Changesets.Clear();
FilteredChangesets.Clear();
if (Repository.Instance.TfsBridgeProvider.ActiveTeamProject != null)
{
Repository.Instance.BackgroundTaskManager.DelayedPost(() => { ProfileProvider_DefaultProfileChanged(null, null); return(true); });
}
};
}
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);
}
}
public WorkItemViewModel(TfsItemCache tfsItemCache)
: base("Work Item", typeof(WorkItemViewModel))
{
try
{
Repository.Instance.VMergeUIProvider.MergeWindowVisibilityChanged += (o, a) => Enabled = !Repository.Instance.VMergeUIProvider.IsMergeWindowVisible();
Enabled = !Repository.Instance.VMergeUIProvider.IsMergeWindowVisible();
TfsItemCache = tfsItemCache;
ViewSelectionViewModel = new ViewSelectionViewModel();
WorkItems = new ObservableCollection <TfsWorkItemWrapper>();
WorkItemList =
new FieldMapperGridViewModel <TfsWorkItemWrapper>(
new WorkItemPropertyAccessor(),
WorkItems,
Columns);
WorkItemList.ColumnSettingsChanged += (o, a) => DataWasModified();
ItemSelectedCommand = new RelayCommand((o) => ItemSelected(o));
ShowChangesetViewCommand = new RelayCommand((o) => ShowChangesetView());
SelectMarkedItemsCommand = new RelayCommand((o) => SelectMarkedItems());
ViewWorkItemCommand = new RelayCommand((o) => ViewWorkItem(o));
TrackWorkItemCommand = new RelayCommand((o) => TrackWorkItem(o));
MergeCommand = new RelayCommand((o) => Merge(o));
ShowMergeViewCommand = new RelayCommand((o) => ShowMergeView());
RefreshCommand = new RelayCommand((o) => Refresh(), (o) => Repository.Instance.TfsBridgeProvider.TfsTeamProjectCollection != null);
ViewSelectionViewModel.ViewSelectionChanged += OnViewSelectionChanged;
AttachToWorkItemCache();
AttachToProfileProvider();
Repository.Instance.TfsBridgeProvider.ActiveProjectSelected += (o, a) =>
{
WorkItems.Clear();
if (Repository.Instance.TfsBridgeProvider.ActiveTeamProject != null)
{
Repository.Instance.BackgroundTaskManager.DelayedPost(() => { ProfileProvider_DefaultProfileChanged(null, null); return(true); });
}
};
} catch (Exception ex)
{
SimpleLogger.Log(ex, false, false);
throw;
}
}
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.";
}
}
}
public PrepareMergeViewModel(TfsItemCache tfsItemCache, IEnumerable <ITfsChangeset> changesets)
: base(typeof(PrepareMergeViewModel))
{
TfsItemCache = tfsItemCache;
Changesets = changesets.Where(changeset => changeset.Changeset.CreationDate >= (DateTime.Now - new TimeSpan(30, 0, 0, 0))).ToList();
MergeSourcesLoading = new LoadingProgressViewModel();
MergeTargetsLoading = new LoadingProgressViewModel();
ChangesetsLoading = new LoadingProgressViewModel();
ChangesetsRefreshing = new LoadingProgressViewModel();
OpenChangesetCommand = new RelayCommand((o) => OpenChangeset((int)o));
PerformMergeCommand = new RelayCommand((o) => PerformMerge(o as ChangesetListElement));
PickPathFilterCommand = new RelayCommand((o) => PickPathFilter());
AutoMergeCommand = new RelayCommand((o) => AutoMerge(), (o) => IsAnythingToMergeLeft());
OKCommand = new RelayCommand((o) => OK());
var potentialMergeSourceBranches = Enumerable.Empty <ITfsBranch>();
bool finished = Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(progressParams) =>
{
WorkItems = new List <ITfsWorkItem>();
progressParams.TrackProgress.MaxProgress = Changesets.Count();
foreach (var changeset in Changesets)
{
progressParams.CancellationToken.ThrowIfCancellationRequested();
foreach (var workItem in changeset.RelatedWorkItems)
{
progressParams.CancellationToken.ThrowIfCancellationRequested();
WorkItems.Add(workItem);
}
potentialMergeSourceBranches = potentialMergeSourceBranches.Union(changeset.GetAffectedBranchesForActiveProject());
progressParams.TrackProgress.Increment();
}
});
if (!finished)
{
throw new OperationCanceledException();
}
_potentialMergeSourceBranches = potentialMergeSourceBranches.ToList();
}
private void FindMergesForChangesetAndBranch(List <MergedChangesetLink> results, ITfsChangeset changeset, ITfsBranch rootBranch)
{
var merges
= changeset.FindMergesForActiveProject(rootBranch, _potentialMergeSourceBranches)
.Select(
item => new MergedChangesetLink()
{
Source = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(item.Source)),
Target = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(item.Target))
});
results.Add(
new MergedChangesetLink()
{
Source = null,
Target = TfsItemCache.UpdateChangesetFromCache(new TfsChangesetWrapper(changeset))
});
results.AddRange(merges);
}
protected override void Refresh()
{
try
{
SimpleLogger.Log(SimpleLogLevel.Info, "Reload called (Changeset)");
base.Refresh();
ItemsLoading.IsLoading = true;
ItemsLoading.ProgressInfo = "Reloading projects, branches and changesets ... please wait";
ResetChangesets();
SetContent(new ObservableCollection <TfsChangesetWrapper>());
SimpleLogger.Log(SimpleLogLevel.Info, "Reload clear list (Changeset)");
TfsItemCache.Clear();
SimpleLogger.Log(SimpleLogLevel.Info, "Reload call TFS Bridge (Changeset)");
Repository.Instance.TfsBridgeProvider.Refresh();
SimpleLogger.Log(SimpleLogLevel.Info, "Reload finished (Changeset)");
} catch (Exception ex)
{
SimpleLogger.Log(ex, true, false);
}
}
public PrepareMergeViewModel(TfsItemCache tfsItemCache, IEnumerable <ITfsChangeset> changesets)
: base(typeof(PrepareMergeViewModel))
{
TfsItemCache = tfsItemCache;
Changesets = changesets.OrderBy(changeset => changeset.Changeset.ChangesetId).ToList();
MergeSourcesLoading = new LoadingProgressViewModel();
MergeTargetsLoading = new LoadingProgressViewModel();
ChangesetsLoading = new LoadingProgressViewModel();
ChangesetsRefreshing = new LoadingProgressViewModel();
OpenChangesetCommand = new RelayCommand((o) => OpenChangeset((int)o));
FindOriginalChangesetCommand = new RelayCommand((o) => FindOriginalChangeset((int)o));
PerformMergeCommand = new RelayCommand((o) => PerformMerge(o as ChangesetListElement));
PickPathFilterCommand = new RelayCommand((o) => PickPathFilter());
AutoMergeCommand = new RelayCommand((o) => AutoMerge(), (o) => IsAnythingToMergeLeft());
OKCommand = new RelayCommand((o) => OK());
var potentialMergeSourceBranches = Enumerable.Empty <ITfsBranch>();
bool finished = Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(progressParams) =>
{
progressParams.TrackProgress.MaxProgress = Changesets.Count();
foreach (var changeset in Changesets)
{
progressParams.CancellationToken.ThrowIfCancellationRequested();
var list = changeset.GetAffectedBranchesForActiveProject().ToArray();
potentialMergeSourceBranches = potentialMergeSourceBranches.Union(list);
progressParams.TrackProgress.Increment();
}
});
if (!finished)
{
throw new OperationCanceledException();
}
PossibleMergeSources = potentialMergeSourceBranches.ToList();
ListenToSettingsChanges();
}
private void LoadWorkItems(ITfsBranch sourceBranch, ITfsBranch targetBranch, string pathFilter, BackgroundTask task)
{
task.TrackProgress.ProgressInfo = "Loading merge candidates ...";
var changesets = new List <TfsChangesetWrapper>(TfsItemCache.QueryChangesets(sourceBranch, targetBranch, pathFilter));
task.TrackProgress.ProgressInfo = "Loading work items ...";
task.TrackProgress.MaxProgress = changesets.Count;
var workItems
= new ObservableCollection <TfsWorkItemWrapper>(
TfsItemCache.QueryWorkItems(changesets, task.TrackProgress, task.Cancelled.Token));
Repository.Instance.BackgroundTaskManager.Post(
() =>
{
if (!task.Cancelled.IsCancellationRequested)
{
SetContent(workItems);
}
return(true);
});
}
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;
}
}
private void LoadChangesets(ITfsQuery query, BackgroundTask task)
{
task.TrackProgress.ProgressInfo = "Loading work items ...";
var workItems = new List <TfsWorkItemWrapper>(
TfsItemCache.QueryWorkItems(query));
task.TrackProgress.ProgressInfo = "Loading changesets ...";
task.TrackProgress.MaxProgress = workItems.Count;
var changesets
= new ObservableCollection <TfsChangesetWrapper>(
TfsItemCache.QueryChangesets(workItems, task.TrackProgress, task.Cancelled.Token));
Repository.Instance.BackgroundTaskManager.Post(
() =>
{
if (!task.Cancelled.IsCancellationRequested)
{
SetContent(changesets);
}
return(true);
});
}
private void LoadWorkItems(ITfsQuery query, BackgroundTask task)
{
task.TrackProgress.ProgressInfo = "Loading work items ...";
var workItems = new ObservableCollection <TfsWorkItemWrapper>(
TfsItemCache.QueryWorkItems(query));
Repository.Instance.BackgroundTaskManager.Post(
() =>
{
try
{
if (!task.Cancelled.IsCancellationRequested)
{
SetContent(workItems);
}
}
catch (Exception)
{
return(true);
}
return(true);
});
}
private void HighlightWorkItems()
{
_changesetHighlightUpdatePending = false;
if (!Repository.Instance.BackgroundTaskManager.RunWithCancelDialog(
(trackProgressParameters) =>
{
TfsItemCache.HighlightWorkItems(trackProgressParameters);
}))
{
SuppressNotifications();
try
{
foreach (var item in _changesetsToResetOnCancel)
{
item.Item1.IsSelected = item.Item2;
}
}
finally
{
AllowNotifications();
}
}
_changesetsToResetOnCancel.Clear();
}
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);
}
