public async Task <Result> UpdateCommissionAllocation(ScopeOptions scope, CommissionAllocationEdit commissionAllocation)
{
var validator = new CommissionAllocationValidator(_context, scope, false);
var result = validator.Validate(commissionAllocation).GetResult();
if (!result.Success)
{
return(result);
}
var entity = await GetCommissionAllocationEntityQuery(scope).FirstOrDefaultAsync(c => c.Id == commissionAllocation.Id);
if (entity == null)
{
return(new Result());
}
var allocationEntity = MapModelToEntity(commissionAllocation, entity);
await _context.SaveChangesAsync();
await DeleteCommissionAllocationPolicies(commissionAllocation.Id.Value);
await InsertCommissionAllocationPolicies(commissionAllocation);
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "CommissionAllocation", entity.Id, commissionAllocation);
return(result);
}
public async Task Get()
{
var allocation = new CommissionAllocationEdit()
{
Id = Guid.NewGuid(),
FromClientId = Guid.NewGuid(),
ToClientId = Guid.NewGuid(),
PolicyIds = new List <Guid>()
{
Guid.NewGuid()
}
};
var service = new Mock <ICommissionAllocationService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
service.Setup(c => c.GetCommissionAllocation(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == allocation.Id.Value)))
.ReturnsAsync(allocation);
var controller = new CommissionAllocationsController(service.Object, authService.Object);
var result = await controller.Get(allocation.Id.Value);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <CommissionAllocationEdit>(okResult.Value);
Assert.Same(allocation, returnValue);
}
private async Task InsertCommissionAllocationPolicies(CommissionAllocationEdit commissionAllocation)
{
foreach (var policyId in commissionAllocation.PolicyIds)
{
var allocationPolicy = BuildCommissionAllocationPolicyEntity(commissionAllocation.Id.Value, policyId);
await _context.CommissionAllocationPolicy.AddAsync(allocationPolicy);
}
await _context.SaveChangesAsync();
}
private CommissionAllocationEntity MapModelToEntity(CommissionAllocationEdit model, CommissionAllocationEntity entity = null)
{
if (entity == null)
{
entity = new CommissionAllocationEntity();
}
entity.FromClientId = model.FromClientId.Value;
entity.ToClientId = model.ToClientId.Value;
return(entity);
}
public async Task <IActionResult> Insert([FromBody] CommissionAllocationEdit commissionAllocation)
{
var scope = AuthenticationService.GetScope(User);
var result = await CommissionAllocationService.InsertCommissionAllocation(scope, commissionAllocation);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
return(Ok(result));
}
public async Task Update()
{
var allocation = new CommissionAllocationEdit()
{
Id = Guid.NewGuid(),
FromClientId = Guid.NewGuid(),
ToClientId = Guid.NewGuid(),
PolicyIds = new List <Guid>()
{
Guid.NewGuid()
}
};
var service = new Mock <ICommissionAllocationService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
CommissionAllocationEdit updated = null;
service.Setup(c => c.UpdateCommissionAllocation(It.IsAny <ScopeOptions>(), It.IsAny <CommissionAllocationEdit>()))
.Callback((ScopeOptions o, CommissionAllocationEdit i) =>
{
updated = i;
options = o;
})
.ReturnsAsync(result);
var controller = new CommissionAllocationsController(service.Object, authService.Object);
var actual = await controller.Update(allocation.Id.Value, allocation);
Assert.Same(allocation, updated);
Assert.Equal(Scope.Branch, options.Scope);
var okResult = Assert.IsType <OkObjectResult>(actual);
var returnValue = Assert.IsType <Result>(okResult.Value);
Assert.Same(result, returnValue);
}
public async Task <Result> InsertCommissionAllocation(ScopeOptions scope, CommissionAllocationEdit commissionAllocation)
{
var validator = new CommissionAllocationValidator(_context, scope, true);
var result = validator.Validate(commissionAllocation).GetResult();
if (!result.Success)
{
return(result);
}
var entity = MapModelToEntity(commissionAllocation);
await _context.CommissionAllocation.AddAsync(entity);
await _context.SaveChangesAsync();
commissionAllocation.Id = entity.Id;
result.Tag = commissionAllocation;
await InsertCommissionAllocationPolicies(commissionAllocation);
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_INSERT, "CommissionAllocation", entity.Id, commissionAllocation);
return(result);
}
public async Task UpdateCommissionAllocation()
{
var options = TestHelper.GetDbContext("UpdateCommissionAllocation");
var user1 = TestHelper.InsertUserDetailed(options);
var client1 = TestHelper.InsertClient(options, user1.Organisation);
var client2 = TestHelper.InsertClient(options, user1.Organisation);
var client3 = TestHelper.InsertClient(options, user1.Organisation);
var client4 = TestHelper.InsertClient(options, user1.Organisation);
var user2 = TestHelper.InsertUserDetailed(options);
var policy1 = new PolicyEntity
{
Id = Guid.NewGuid(),
ClientId = client1.Client.Id,
UserId = user1.User.Id
};
var policy2 = new PolicyEntity
{
Id = Guid.NewGuid(),
ClientId = client2.Client.Id,
UserId = user1.User.Id
};
var policy3 = new PolicyEntity
{
Id = Guid.NewGuid(),
ClientId = client2.Client.Id,
UserId = user1.User.Id
};
var ca1 = new CommissionAllocationEntity
{
Id = Guid.NewGuid(),
FromClientId = client1.Client.Id,
ToClientId = client2.Client.Id
};
var cap1 = new CommissionAllocationPolicyEntity
{
Id = Guid.NewGuid(),
CommissionAllocationId = ca1.Id,
PolicyId = Guid.NewGuid()
};
var ca2 = new CommissionAllocationEntity
{
Id = Guid.NewGuid(),
FromClientId = client1.Client.Id,
ToClientId = client3.Client.Id
};
var cap2 = new CommissionAllocationPolicyEntity
{
Id = Guid.NewGuid(),
CommissionAllocationId = ca2.Id,
PolicyId = policy1.Id
};
using (var context = new DataContext(options))
{
context.Policy.Add(policy1);
context.Policy.Add(policy2);
context.Policy.Add(policy3);
context.CommissionAllocation.Add(ca1);
context.CommissionAllocation.Add(ca2);
context.CommissionAllocationPolicy.Add(cap2);
context.CommissionAllocationPolicy.Add(cap1);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var ca2Updated = new CommissionAllocationEdit
{
Id = ca2.Id,
FromClientId = client2.Client.Id,
ToClientId = client4.Client.Id,
PolicyIds = new List <Guid>()
{
policy2.Id, policy3.Id
}
};
var auditService = new AuditServiceMock();
var service = new CommissionAllocationService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.UpdateCommissionAllocation(scope, ca2Updated);
//Then
Assert.True(result.Success);
var actual = await context.CommissionAllocation.FindAsync(ca2Updated.Id);
Assert.Equal(ca2Updated.Id, actual.Id);
Assert.Equal(ca2Updated.FromClientId, actual.FromClientId);
Assert.Equal(ca2Updated.ToClientId, actual.ToClientId);
var policyIds = await context.CommissionAllocationPolicy.Where(p => p.CommissionAllocationId == actual.Id).Select(p => p.PolicyId).ToListAsync();
Assert.Equal(ca2Updated.PolicyIds, policyIds);
//Out of scope
scope = TestHelper.GetScopeOptions(user2, Scope.User);
result = await service.UpdateCommissionAllocation(scope, ca2Updated);
Assert.False(result.Success);
Assert.Equal("'Client' does not exist.", result.ValidationFailures.First().ErrorMessage);
}
}
