public async Task <IActionResult> CompleteMerge(MergeViewModel mergeViewModel)
{
await PerformExtraValidationsAsync(mergeViewModel);
if (ModelState.IsValid)
{
var rekeningen = await _rekeningenService.GetRawListByIdsAsync(mergeViewModel.RekeningIds);
if (rekeningen.Count != mergeViewModel.RekeningIds.Count)
{
//Niet alle aangegeven rekeningen konden gevonden worden
return(NotFound());
}
//Alles naar de eerste toe zetten
var uiteindelijkeRekening = rekeningen.First();
var overigeRekeningen = rekeningen.Skip(1).ToList();
_mapper.Map(mergeViewModel, uiteindelijkeRekening);
foreach (var overigeRekening in overigeRekeningen)
{
//Transactie verplaatsen meteen awaiten.
//Anders zou een transactie met een boeking naar zichzelf mogelijk kunnen worden
//Vb: RekA, RekB, RekC allen naar RekA toe. Transactie tussen RekB en RekC zou asynchroon de boeking-naar-zichzelf-check kunnen missen
await MoveTranssactiesAsync(uiteindelijkeRekening, overigeRekening);
_rekeningenService.Remove(overigeRekening);
}
await _rekeningenService.SaveChangesAsync();
return(RedirectToAction(nameof(Details), new { id = uiteindelijkeRekening.RekeningId }));
}
await SetSelectListsAsync(mergeViewModel);
return(View(nameof(Merge), mergeViewModel));
}
public JsonNetResult Merge(MergeViewModel vm)
{
if (ModelState.IsValid)
{
AdminUser user = this.userTasks.GetAdminUser(User.Identity.Name);
if (user != null)
{
if (this.orgTasks.MergeUnits(vm.ToKeepId, vm.ToDeleteId, user.UserID, ((PrfPrincipal)User).HasPermission(AdminPermission.CanViewPersonResponsibilities)) == 1)
{
return(JsonNet(null));
}
else
{
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(JsonNet(new { merge = "There was a database error merging the units." }));
}
}
else
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(JsonNet(new { user = "******" }));
}
}
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(JsonNet(GetErrorsForJson()));
}
public async Task <IActionResult> Merge(IList <RekeningViewModel> rekeningViewModels)
{
var rekeningIds = rekeningViewModels.Where(r => r.Selected).Select(r => r.RekeningId).ToList();
if (rekeningIds.Count < 2)
{
//Kan niet mergen met minder dat 2 rekeningen
return(RedirectToAction(nameof(Index)));
}
var rekeningen = await _rekeningenService.GetRawListByIdsAsync(rekeningIds);
if (rekeningen.Count != rekeningIds.Count)
{
//Niet alle aangegeven rekeningen konden gevonden worden
return(NotFound());
}
var categorieIds = rekeningen.Where(r => r.StandaardCategorieId.HasValue).Select(r => r.StandaardCategorieId.Value).Distinct().ToList();
var mergeViewModel = new MergeViewModel
{
RekeningIds = rekeningIds,
Naam = string.Join(", ", rekeningen.Select(r => r.Naam)),
Rekeningnummer = string.Join(", ", rekeningen.Select(r => r.Rekeningnummer).Where(s => !string.IsNullOrEmpty(s))),
IsEigenRekening = rekeningen.Any(r => r.IsEigenRekening), //Als één van de rekeningen eigen is, is de gemergede standaard eigen
StandaardCategorieId = categorieIds.Count == 1 ? categorieIds.First() : (int?)null, //Als er één categorie is, deze voorvullen
CategorieIds = categorieIds
};
await Task.WhenAll(
SetSelectListsAsync(mergeViewModel),
SetSaldoAsync(mergeViewModel));
return(View(mergeViewModel));
}
public void MergeViewModel_DoDeactivate_CanSave_MessageBoxYes()
{
//------------Setup for test--------------------------
_firstResource = CreateResource(ResourceType.WorkflowService);
var mockWorkSurfaceViewModel = new Mock <IMergePreviewWorkflowDesignerViewModel>();
mockWorkSurfaceViewModel.Setup(model => model.Server).Returns(_environmentModel.Object);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(_firstResource.Object);
var currentTree = new List <ConflictTreeNode>();
var diffTree = new List <ConflictTreeNode>();
_mockParseServiceForDifferences.Setup(parser =>
parser.GetDifferences(It.IsAny <IContextualResourceModel>(), It.IsAny <IContextualResourceModel>(),
false)).Returns((currentTree, diffTree));
//------------Execute Test---------------------------
var popupController = new Mock <IPopupController>();
popupController.Setup(controller => controller.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButton>(), MessageBoxImage.Information, "", false, false, true, false, false, false)).Returns(MessageBoxResult.Yes);
CustomContainer.Register(popupController.Object);
var mockConflictRow = new Mock <IToolConflictRow>();
mockConflictRow.Setup(cr => cr.HasConflict).Returns(true);
var conflicts = new List <IToolConflictRow>();
conflicts.Add(mockConflictRow.Object);
var viewModel = new Mock <IMergeWorkflowViewModel>();
viewModel.Setup(model => model.MergePreviewWorkflowDesignerViewModel).Returns(mockWorkSurfaceViewModel.Object);
var vm = new MergeViewModel(_eventAggregator.Object, viewModel.Object, popupController.Object, new Mock <IView>().Object);
Assert.IsNotNull(vm);
Assert.IsFalse(vm.HasVariables);
Assert.IsFalse(vm.HasDebugOutput);
Assert.IsNull(vm.DisplayName);
Assert.AreEqual("MergeConflicts", vm.ResourceType);
Assert.IsNull(vm.HelpText);
Assert.IsFalse(vm.IsDirty);
var mergeWorkflowViewModel = new MergeWorkflowViewModel(_firstResource.Object, _firstResource.Object, false);
mergeWorkflowViewModel.Conflicts = conflicts;
mergeWorkflowViewModel.HasMergeStarted = true;
mergeWorkflowViewModel.DisplayName = "Merge";
vm.ViewModel = mergeWorkflowViewModel;
vm.DoDeactivate(true);
//------------Assert Results-------------------------
Assert.IsTrue(vm.IsDirty);
Assert.IsNull(vm.HelpText);
}
private void UpdateMerges(
IEnumerable <Branch> sourceBranches,
RepositoryViewModel repositoryViewModel)
{
var branches = repositoryViewModel.Branches;
var commits = repositoryViewModel.Commits;
var commitsById = repositoryViewModel.CommitsById;
var merges = repositoryViewModel.Merges;
var mergePoints = commits
.Where(c => c.IsMergePoint && c.Commit.HasSecondParent && sourceBranches.Contains(c.Commit.SecondParent.Branch))
.ToList();
var branchStarts = branches.Where(b =>
b.Branch.HasParentBranch && sourceBranches.Contains(b.Branch.ParentCommit.Branch))
.Select(b => b.Branch.FirstCommit)
.ToList();
bool isMergeInProgress =
repositoryMgr.Repository.Status.IsMerging &&
branches.Any(b => b.Branch == repositoryMgr.Repository.CurrentBranch) &&
repositoryViewModel.MergingBranch != null &&
branches.Any(b => b.Branch.Id == repositoryViewModel.MergingBranch.Id) &&
repositoryMgr.Repository.UnComitted != null;
int mergeCount = mergePoints.Count + branchStarts.Count + (isMergeInProgress ? 1 : 0);
SetNumberOfItems(merges, mergeCount, _ => new MergeViewModel());
int index = 0;
foreach (CommitViewModel childCommit in mergePoints)
{
CommitViewModel parentCommit = commitsById[childCommit.Commit.SecondParent.Id];
MergeViewModel merge = merges[index++];
SetMerge(merge, branches, childCommit, parentCommit);
}
foreach (Commit childCommit in branchStarts)
{
CommitViewModel parentCommit = commitsById[childCommit.FirstParent.Id];
MergeViewModel merge = merges[index++];
SetMerge(merge, branches, commitsById[childCommit.Id], parentCommit, false);
}
if (isMergeInProgress)
{
CommitId mergeSourceId = new CommitId(repositoryViewModel.MergingCommitSha);
CommitViewModel parentCommit = commitsById[mergeSourceId];
MergeViewModel merge = merges[index++];
SetMerge(merge, branches, commitsById[parentCommit.Commit.Repository.UnComitted.Id], parentCommit);
}
}
/// <summary>
/// Returns range of item ids, which are visible in the area currently shown
/// </summary>
protected override IEnumerable <int> GetItemIds(Rect viewArea)
{
if (VirtualArea == Rect.Empty || viewArea == Rect.Empty)
{
yield break;
}
if (openRepos.Any())
{
yield return(0 + minOpenRepoIndex);
yield break;
}
// Get the part of the rectangle that is visible
viewArea.Intersect(VirtualArea);
int viewAreaTopIndex = Converters.ToTopRowIndex(viewArea, commits.Count);
int viewAreaBottomIndex = Converters.ToBottomRowIndex(viewArea, commits.Count);
if (viewAreaBottomIndex > viewAreaTopIndex)
{
// Return visible branches
for (int i = 0; i < branches.Count; i++)
{
BranchViewModel branch = branches[i];
if (IsVisible(
viewAreaTopIndex, viewAreaBottomIndex, branch.TipRowIndex, branch.FirstRowIndex))
{
yield return(i + minBranchIndex);
}
}
// Return visible merges
for (int i = 0; i < merges.Count; i++)
{
MergeViewModel merge = merges[i];
if (IsVisible(viewAreaTopIndex, viewAreaBottomIndex, merge.ChildRow, merge.ParentRow))
{
yield return(i + minMergeIndex);
}
}
// Return visible commits
for (int i = viewAreaTopIndex; i <= viewAreaBottomIndex; i++)
{
if (i >= 0 && i < commits.Count)
{
yield return(i + minCommitIndex);
}
}
}
}
/// <summary>
/// Request the Merge Dashboard.
/// </summary>
/// <param name="project"></param>
/// <param name="source"></param>
/// <param name="target"></param>
/// <returns></returns>
public ActionResult Merge(string project, string source, string target)
{
var teamProject = _teamRepository.GetProject(project);
var model = new MergeViewModel
{
ApiPath = Url.Action("GetMergeViewModel", "Source"),
Project = teamProject,
Environment = teamProject.MergeEnvironments
.FirstOrDefault(m => string.Compare(m.Source.ToString(), source, StringComparison.OrdinalIgnoreCase) == 0 && string.Compare(m.Target.ToString(), target, StringComparison.OrdinalIgnoreCase) == 0)
};
return(model.Environment == null?View("Error") : View("Index", model));
}
private async Task SetSaldoAsync(MergeViewModel mergeViewModel)
{
List <Task <decimal> > saldoTasks = new List <Task <decimal> >();
foreach (var rekeningId in mergeViewModel.RekeningIds)
{
var saldoTask = _rekeningenService.GetSaldoAsync(new Rekening {
RekeningId = rekeningId
});
saldoTasks.Add(saldoTask);
}
var saldos = await Task.WhenAll(saldoTasks);
mergeViewModel.Saldo = saldos.Sum();
}
public void MergeViewModel_PropertyChanged_DataListViewModel_IsTrue()
{
//------------Setup for test--------------------------
_firstResource = CreateResource(ResourceType.WorkflowService);
var mockWorkSurfaceViewModel = new Mock <IMergePreviewWorkflowDesignerViewModel>();
mockWorkSurfaceViewModel.Setup(model => model.Server).Returns(_environmentModel.Object);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(_firstResource.Object);
var currentTree = new List <ConflictTreeNode>();
var diffTree = new List <ConflictTreeNode>();
_mockParseServiceForDifferences.Setup(parser =>
parser.GetDifferences(It.IsAny <IContextualResourceModel>(), It.IsAny <IContextualResourceModel>(),
false)).Returns((currentTree, diffTree));
//------------Execute Test---------------------------
var viewModel = new Mock <IMergeWorkflowViewModel>();
viewModel.Setup(model => model.MergePreviewWorkflowDesignerViewModel).Returns(mockWorkSurfaceViewModel.Object);
var vm = new MergeViewModel(_eventAggregator.Object, viewModel.Object, new Mock <IPopupController>().Object, new Mock <IView>().Object);
var mergeWorkflowViewModel = new MergeWorkflowViewModel(_firstResource.Object, _firstResource.Object, false);
mergeWorkflowViewModel.HasMergeStarted = true;
vm.ViewModel = mergeWorkflowViewModel;
bool wasCalled = false;
vm.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == "DataListViewModel")
{
wasCalled = true;
}
};
Assert.IsNotNull(vm);
Assert.IsFalse(vm.HasVariables);
Assert.IsFalse(vm.HasDebugOutput);
Assert.AreEqual(mergeWorkflowViewModel.DisplayName, vm.DisplayName);
Assert.AreEqual("MergeConflicts", vm.ResourceType);
Assert.IsNull(vm.HelpText);
Assert.IsTrue(vm.IsDirty);
}
public void MergeViewModel_DoDeactivate_CanSave_ExpectedFalse()
{
//------------Setup for test--------------------------
_firstResource = CreateResource(ResourceType.WorkflowService);
var mockWorkSurfaceViewModel = new Mock <IMergePreviewWorkflowDesignerViewModel>();
mockWorkSurfaceViewModel.Setup(model => model.Server).Returns(_environmentModel.Object);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(_firstResource.Object);
var currentTree = new List <ConflictTreeNode>();
var diffTree = new List <ConflictTreeNode>();
_mockParseServiceForDifferences.Setup(parser =>
parser.GetDifferences(It.IsAny <IContextualResourceModel>(), It.IsAny <IContextualResourceModel>(),
false)).Returns((currentTree, diffTree));
//------------Execute Test---------------------------
var viewModel = new Mock <IMergeWorkflowViewModel>();
viewModel.Setup(model => model.MergePreviewWorkflowDesignerViewModel).Returns(mockWorkSurfaceViewModel.Object);
var vm = new MergeViewModel(_eventAggregator.Object, viewModel.Object, new Mock <IPopupController>().Object, new Mock <IView>().Object);
Assert.IsNotNull(vm);
Assert.IsFalse(vm.HasVariables);
Assert.IsFalse(vm.HasDebugOutput);
Assert.IsNull(vm.DisplayName);
Assert.AreEqual("MergeConflicts", vm.ResourceType);
Assert.IsNull(vm.HelpText);
Assert.IsFalse(vm.IsDirty);
vm.HelpText = string.Empty;
var mergeWorkflowViewModel = new MergeWorkflowViewModel(_firstResource.Object, _firstResource.Object, false);
vm.ViewModel = mergeWorkflowViewModel;
var expectedValue = vm.DoDeactivate(false);
//------------Assert Results-------------------------
Assert.IsFalse(vm.ViewModel.IsDirty);
Assert.IsTrue(vm.IsDirty);
Assert.AreEqual(string.Empty, vm.HelpText);
Assert.IsTrue(expectedValue);
_shellViewModel.Verify(model => model.HelpViewModel.UpdateHelpText(It.IsAny <string>()));
}
public async Task <IHttpActionResult> MergeSend(MergeViewModel model)
{
return(await CurrentAccountExecuteAsync(async delegate(Account user)
{
var userFrom = await _auth.AccountGetAsync(model.AccountIdFrom);
if (object.Equals(userFrom, null) || userFrom.Id == AccountId)
{
return AccountNotFound();
}
var userPrimaryEmail = model.AccountIdPrimaryEmail == userFrom.Id ? userFrom : user;
await NotificationManager.MergeConfirmationNotification(user, userFrom, userPrimaryEmail);
return Ok();
}));
}
public void MergeViewModel_GetView_ReturnsIView_NotNull()
{
//------------Setup for test--------------------------
_firstResource = CreateResource(ResourceType.WorkflowService);
var mockWorkSurfaceViewModel = new Mock <IMergePreviewWorkflowDesignerViewModel>();
mockWorkSurfaceViewModel.Setup(model => model.Server).Returns(_environmentModel.Object);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(_firstResource.Object);
var currentTree = new List <ConflictTreeNode>();
var diffTree = new List <ConflictTreeNode>();
_mockParseServiceForDifferences.Setup(parser =>
parser.GetDifferences(It.IsAny <IContextualResourceModel>(), It.IsAny <IContextualResourceModel>(),
false)).Returns((currentTree, diffTree));
//------------Execute Test---------------------------
var viewModel = new Mock <IMergeWorkflowViewModel>();
viewModel.Setup(model => model.MergePreviewWorkflowDesignerViewModel).Returns(mockWorkSurfaceViewModel.Object);
var vm = new MergeViewModel(_eventAggregator.Object, viewModel.Object, new Mock <IPopupController>().Object, new Mock <IView>().Object);
Assert.IsNotNull(vm);
Assert.IsFalse(vm.HasVariables);
Assert.IsFalse(vm.HasDebugOutput);
Assert.IsNull(vm.DisplayName);
Assert.AreEqual("MergeConflicts", vm.ResourceType);
Assert.IsNull(vm.HelpText);
Assert.IsFalse(vm.IsDirty);
var view = vm.GetView();
//------------Assert Results-------------------------
Assert.IsNotNull(view);
}
private void SetMerge(
MergeViewModel merge,
IReadOnlyCollection <BranchViewModel> branches,
CommitViewModel childCommit,
CommitViewModel parentCommit,
bool isMerge = true)
{
BranchViewModel childBranch = branches
.First(b => b.Branch == childCommit.Commit.Branch);
BranchViewModel parentBranch = branches
.First(b => b.Branch == parentCommit.Commit.Branch);
if (isMerge)
{
childCommit.BrushInner = themeService.Theme.GetDarkerBrush(childCommit.Brush);
}
int childRow = childCommit.RowIndex;
int parentRow = parentCommit.RowIndex;
int childColumn = childBranch.BranchColumn;
int parentColumn = parentBranch.BranchColumn;
bool isBranchStart = (childCommit.Commit.HasFirstParent &&
childCommit.Commit.FirstParent.Branch != childCommit.Commit.Branch) ||
(childCommit.Commit.Branch.IsLocalPart && parentCommit.Commit.Branch.IsMainPart);
BranchViewModel mainBranch = childColumn >= parentColumn ? childBranch : parentBranch;
int childX = childCommit.X;
int parentX = parentCommit.X;
int x1 = childX <= parentX ? 0 : childX - parentX - 6;
int y1 = 0;
int x2 = parentX <= childX ? 0 : parentX - childX - 6;
int y2 = Converters.ToY(parentRow - childRow) + Converters.HalfRow - 8;
if (isBranchStart && x1 != x2)
{
y1 = y1 + 2;
x1 = x1 + 2;
}
merge.ChildRow = childRow;
merge.ParentRow = parentRow;
double y = (double)Converters.ToY(childRow);
merge.Rect = new Rect(
(double)Math.Min(childX, parentX) + 10,
y + Converters.HalfRow,
Math.Abs(childX - parentX) + 2 + (x1 == x2 ? 2 : 0),
y2 + 2);
merge.Width = merge.Rect.Width;
merge.Line = $"M {x1},{y1} L {x2},{y2}";
merge.Brush = mainBranch.Brush;
merge.Stroke = isBranchStart ? 2 : 1;
merge.StrokeDash =
(childCommit.Commit.Branch.IsLocalPart && parentCommit.Commit.Branch.IsMainPart) ||
(parentCommit.Commit.Branch.IsLocalPart && childCommit.Commit.Branch.IsMainPart)
? "1" : "";
merge.NotifyAll();
}
public MergeView(MergeViewModel vm)
{
InitializeComponent();
DataContext = vm;
}
private async Task PerformExtraValidationsAsync(MergeViewModel mergeViewModel)
{
await Task.WhenAll(
ValidateNaamInUseAsync(mergeViewModel.Naam, mergeViewModel.RekeningIds),
ValidateRekeningnummerInUseAsync(mergeViewModel.Rekeningnummer, mergeViewModel.RekeningIds));
}
private async Task SetSelectListsAsync(MergeViewModel mergeViewModel)
{
ViewData["StandaardCategorieId"] = SelectListUtil.GetSelectList(await _categorieenService.GetSelectListForIdsAsync(mergeViewModel.CategorieIds), mergeViewModel.StandaardCategorieId);
}
