public async Task <IActionResult> Index(string sortColumn, string sortDirection, int pageSize = 0, int pageNumber = 0, string filters = null)
{
var scope = AuthenticationService.GetScope(User);
var queryOptions = new CommissionQueryOptions(scope, sortColumn, sortDirection, pageSize, pageNumber, filters);
var commissions = await CommissionService.GetCommissions(queryOptions);
return(Ok(commissions));
}
public async Task Index()
{
var commission = new OneAdvisor.Model.Commission.Model.Commission.Commission()
{
Id = Guid.NewGuid(),
AmountIncludingVAT = 100,
VAT = 20,
CommissionStatementId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
PolicyNumber = "123456",
UserId = Guid.NewGuid()
};
var pagedItems = new PagedCommissions()
{
TotalItems = 1,
SumAmountIncludingVAT = 300,
SumVAT = 400,
Items = new List <OneAdvisor.Model.Commission.Model.Commission.Commission>()
{
commission
}
};
var service = new Mock <ICommissionService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
CommissionQueryOptions queryOptions = null;
service.Setup(c => c.GetCommissions(It.IsAny <CommissionQueryOptions>()))
.Callback((CommissionQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new CommissionsController(service.Object, authService.Object);
var result = await controller.Index("policyNumber", "desc", 15, 2, $"commissionTypeId={commission.CommissionTypeId}");
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal("policyNumber", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Descending, queryOptions.SortOptions.Direction);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
Assert.Equal(commission.CommissionTypeId, queryOptions.CommissionTypeId.Single());
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedCommissions>(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task GetCommissions()
{
var options = TestHelper.GetDbContext("GetCommissions");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var client1 = TestHelper.InsertClient(options, user1.Organisation);
var client2 = TestHelper.InsertClient(options, user1.Organisation);
var user3 = TestHelper.InsertUserDetailed(options);
var client3 = TestHelper.InsertClient(options, user3.Organisation);
var statement1 = TestHelper.InsertCommissionStatement(options, user1.Organisation);
var statement2 = TestHelper.InsertCommissionStatement(options, user1.Organisation);
var policy1 = new PolicyEntity
{
Id = Guid.NewGuid(),
Number = Guid.NewGuid().ToString(),
CompanyId = statement1.CompanyId,
ClientId = client1.Client.Id,
UserId = user1.User.Id
};
var policy2 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = statement1.CompanyId,
ClientId = client2.Client.Id,
UserId = user2.User.Id
};
var policy3 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = statement1.CompanyId,
ClientId = client3.Client.Id,
UserId = user3.User.Id
};
//Given
var commission1 = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = policy1.Id,
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 100,
VAT = 10,
CommissionStatementId = statement1.Id,
UserId = user1.User.Id,
};
var commission2 = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = policy2.Id,
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 200,
VAT = 20,
CommissionStatementId = statement1.Id,
UserId = user2.User.Id,
};
var commission3 = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = policy2.Id,
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 300,
VAT = 30,
CommissionStatementId = statement1.Id,
UserId = user2.User.Id,
};
var commission4 = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = policy3.Id,
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 40,
VAT = 400,
CommissionStatementId = statement2.Id,
UserId = user3.User.Id,
};
using (var context = new DataContext(options))
{
context.Policy.Add(policy1);
context.Policy.Add(policy2);
context.Policy.Add(policy3);
context.Commission.Add(commission1);
context.Commission.Add(commission2);
context.Commission.Add(commission3);
context.Commission.Add(commission4);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var queryOptions = new CommissionQueryOptions(scope, "", "", 0, 0);
var commissions = await service.GetCommissions(queryOptions);
//Then
Assert.Equal(3, commissions.TotalItems);
Assert.Equal(3, commissions.Items.Count());
Assert.Equal(600, commissions.SumAmountIncludingVAT);
Assert.Equal(60, commissions.SumVAT);
var items = commissions.Items.ToList();
var actual = items[0];
Assert.Equal(commission1.Id, actual.Id);
Assert.Equal(commission1.PolicyId, actual.PolicyId);
Assert.Equal(commission1.CommissionTypeId, actual.CommissionTypeId);
Assert.Equal(commission1.AmountIncludingVAT, actual.AmountIncludingVAT);
Assert.Equal(commission1.VAT, actual.VAT);
Assert.Equal(commission1.CommissionStatementId, actual.CommissionStatementId);
Assert.Equal(policy1.Number, actual.PolicyNumber);
Assert.Equal(statement1.Date, actual.CommissionStatementDate);
Assert.Equal(client1.Client.LastName, actual.PolicyClientLastName);
Assert.Equal(client1.Client.Initials, actual.PolicyClientInitials);
Assert.Equal(client1.Client.DateOfBirth, actual.PolicyClientDateOfBirth);
Assert.Equal(statement1.CompanyId, actual.PolicyCompanyId);
actual = items[1];
Assert.Equal(commission2.Id, actual.Id);
actual = items[2];
Assert.Equal(commission3.Id, actual.Id);
//Check scope
scope = TestHelper.GetScopeOptions(user1, Scope.User);
queryOptions = new CommissionQueryOptions(scope, "", "", 0, 0);
commissions = await service.GetCommissions(queryOptions);
Assert.Single(commissions.Items);
actual = commissions.Items.First();
Assert.Equal(commission1.Id, actual.Id);
}
}
public async Task <PagedCommissions> GetCommissions(CommissionQueryOptions queryOptions)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, queryOptions.Scope);
var query = from commission in _context.Commission
join user in userQuery
on commission.UserId equals user.Id
join policy in _context.Policy
on commission.PolicyId equals policy.Id
join client in _context.Client
on policy.ClientId equals client.Id
join statement in _context.CommissionStatement
on commission.CommissionStatementId equals statement.Id
select new OneAdvisor.Model.Commission.Model.Commission.Commission()
{
Id = commission.Id,
CommissionStatementId = commission.CommissionStatementId,
PolicyId = commission.PolicyId,
CommissionTypeId = commission.CommissionTypeId,
AmountIncludingVAT = commission.AmountIncludingVAT,
VAT = commission.VAT,
UserId = commission.UserId,
BranchId = user.BranchId,
PolicyNumber = policy.Number,
CommissionStatementDate = statement.Date,
PolicyCompanyId = policy.CompanyId,
PolicyClientLastName = client.LastName,
PolicyClientInitials = client.Initials,
PolicyClientDateOfBirth = client.DateOfBirth,
SplitGroupId = commission.SplitGroupId,
PolicyTypeId = policy.PolicyTypeId,
};
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.CommissionStatementId.HasValue)
{
query = query.Where(c => c.CommissionStatementId == queryOptions.CommissionStatementId);
}
if (queryOptions.UserId.Any())
{
query = query.Where(c => queryOptions.UserId.Contains(c.UserId));
}
if (queryOptions.BranchId.Any())
{
query = query.Where(c => queryOptions.BranchId.Contains(c.BranchId));
}
if (queryOptions.CommissionTypeId.Any())
{
query = query.Where(c => queryOptions.CommissionTypeId.Contains(c.CommissionTypeId));
}
if (queryOptions.PolicyCompanyId.Any())
{
query = query.Where(c => queryOptions.PolicyCompanyId.Contains(c.PolicyCompanyId));
}
if (!string.IsNullOrWhiteSpace(queryOptions.PolicyNumber))
{
query = query.Where(m => EF.Functions.Like(m.PolicyNumber, queryOptions.PolicyNumber));
}
if (!string.IsNullOrWhiteSpace(queryOptions.PolicyClientLastName))
{
query = query.Where(m => EF.Functions.Like(m.PolicyClientLastName, queryOptions.PolicyClientLastName));
}
if (queryOptions.StartDate.HasValue)
{
query = query.Where(c => c.CommissionStatementDate >= queryOptions.StartDate.Value.Date);
}
if (queryOptions.EndDate.HasValue)
{
query = query.Where(c => c.CommissionStatementDate <= queryOptions.EndDate.Value.Date);
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedCommissions();
//Get total items
pagedItems.TotalItems = await query.CountAsync();
//Aggregations
var aggQuery = from commission in query
select new
{
SumAmountIncludingVAT = query.Select(c => (decimal?)c.AmountIncludingVAT).Sum(),
SumVAT = query.Select(c => (decimal?)c.VAT).Sum(),
};
var aggregates = await aggQuery.FirstOrDefaultAsync();
if (aggregates != null)
{
pagedItems.SumAmountIncludingVAT = aggregates.SumAmountIncludingVAT.Value;
pagedItems.SumVAT = aggregates.SumVAT.Value;
}
//Ordering
query = query.OrderBy(queryOptions.SortOptions.Column, queryOptions.SortOptions.Direction);
//Paging
pagedItems.Items = await query.TakePage(queryOptions.PageOptions.Number, queryOptions.PageOptions.Size).ToListAsync();
return(pagedItems);
}
