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 ClientQueryOptions(scope, sortColumn, sortDirection, pageSize, pageNumber, filters);
var clients = await ClientService.GetClients(queryOptions);
return(Ok(clients));
}
public async Task Index()
{
var client = new OneAdvisor.Model.Client.Model.Client.Client()
{
Id = Guid.NewGuid(),
FirstName = "1",
LastName = "2",
DateOfBirth = DateTime.Now,
IdNumber = "3",
Initials = "4",
MaidenName = "5",
MarriageDate = DateTime.Now,
MarritalStatusId = Guid.NewGuid(),
AlternateIdNumber = "6",
PreferredName = "7",
TaxNumber = "8",
ClientTypeId = Guid.NewGuid()
};
var pagedItems = new PagedItems <OneAdvisor.Model.Client.Model.Client.Client>()
{
TotalItems = 1,
Items = new List <OneAdvisor.Model.Client.Model.Client.Client>()
{
client
}
};
var service = new Mock <IClientService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
ClientQueryOptions queryOptions = null;
service.Setup(c => c.GetClients(It.IsAny <ClientQueryOptions>()))
.Callback((ClientQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new ClientsController(service.Object, authService.Object);
var result = await controller.Index("firstName", "desc", 15, 2, "lastName=%van%");
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal("firstName", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Descending, queryOptions.SortOptions.Direction);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
Assert.Equal("%van%", queryOptions.LastName);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <OneAdvisor.Model.Client.Model.Client.Client> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task GetClients_OrganisationLevel()
{
var options = TestHelper.GetDbContext("GetClients_OrganisationLevel");
var orgId1 = Guid.NewGuid();
var orgId2 = Guid.NewGuid();
//Given
var client1 = new ClientEntity {
Id = Guid.NewGuid(), OrganisationId = orgId1
};
var client2 = new ClientEntity {
Id = Guid.NewGuid(), OrganisationId = orgId1
};
var client3 = new ClientEntity {
Id = Guid.NewGuid(), OrganisationId = orgId2
};
using (var context = new DataContext(options))
{
context.Client.Add(client1);
context.Client.Add(client2);
context.Client.Add(client3);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new ClientService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(orgId1);
var queryOptions = new ClientQueryOptions(scope, "", "", 0, 0);
var clients = await service.GetClients(queryOptions);
//Then
Assert.Equal(2, clients.TotalItems);
Assert.Equal(2, clients.Items.Count());
var actual = clients.Items.First();
Assert.Equal(client1.Id, actual.Id);
actual = clients.Items.Last();
Assert.Equal(client2.Id, actual.Id);
}
}
public async Task GetClients_Filter()
{
var options = TestHelper.GetDbContext("GetClients_Filter");
//Given
var orgId1 = Guid.NewGuid();
var client1 = new ClientEntity
{
Id = Guid.NewGuid(),
LastName = "van Niekerk",
OrganisationId = orgId1
};
var client2 = new ClientEntity
{
Id = Guid.NewGuid(),
LastName = "Jones",
OrganisationId = orgId1
};
using (var context = new DataContext(options))
{
context.Client.Add(client1);
context.Client.Add(client2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new ClientService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(orgId1);
var queryOptions = new ClientQueryOptions(scope, "", "", 0, 0, "lastName=%nie%");
var clients = await service.GetClients(queryOptions);
//Then
Assert.Equal(1, clients.TotalItems);
Assert.Single(clients.Items);
var actual = clients.Items.First();
Assert.Equal(client1.Id, actual.Id);
}
}
public async Task <PagedItems <Model.Client.Model.Client.Client> > GetClients(ClientQueryOptions queryOptions)
{
var query = from client in GetClientEntityQuery(queryOptions.Scope)
select new Model.Client.Model.Client.Client()
{
Id = client.Id,
ClientTypeId = client.ClientTypeId,
FirstName = client.FirstName,
LastName = client.LastName,
MaidenName = client.MaidenName,
IdNumber = client.IdNumber,
AlternateIdNumber = client.AlternateIdNumber,
Initials = client.Initials,
PreferredName = client.PreferredName,
DateOfBirth = client.DateOfBirth,
TaxNumber = client.TaxNumber,
MarritalStatusId = client.MarritalStatusId,
MarriageDate = client.MarriageDate,
};
//Apply filters ----------------------------------------------------------------------------------------
if (!string.IsNullOrWhiteSpace(queryOptions.FirstName))
{
query = query.Where(m => EF.Functions.Like(m.FirstName, queryOptions.FirstName));
}
if (!string.IsNullOrWhiteSpace(queryOptions.LastName))
{
query = query.Where(m => EF.Functions.Like(m.LastName, queryOptions.LastName));
}
if (!string.IsNullOrWhiteSpace(queryOptions.IdNumber))
{
query = query.Where(m => EF.Functions.Like(m.IdNumber, queryOptions.IdNumber));
}
if (queryOptions.ClientId.Any())
{
query = query.Where(m => queryOptions.ClientId.Contains(m.Id));
}
if (queryOptions.ClientTypeId.Any())
{
query = query.Where(m => queryOptions.ClientTypeId.Contains(m.ClientTypeId));
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <Model.Client.Model.Client.Client>();
//Get total items
pagedItems.TotalItems = await query.CountAsync();
//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);
}
public async Task GetClients()
{
var options = TestHelper.GetDbContext("GetClients");
var orgId1 = Guid.NewGuid();
//Given
var client1 = new ClientEntity
{
Id = Guid.NewGuid(),
ClientTypeId = Guid.NewGuid(),
FirstName = "FN 1",
LastName = "LN 1",
MaidenName = "MN 1",
Initials = "INI 1",
PreferredName = "PN 1",
IdNumber = "321654",
DateOfBirth = new DateTime(1982, 10, 3),
OrganisationId = orgId1,
TaxNumber = "889977",
MarritalStatusId = Guid.NewGuid(),
MarriageDate = new DateTime(2009, 11, 13),
};
var client2 = new ClientEntity
{
Id = Guid.NewGuid(),
OrganisationId = orgId1
};
var client3 = new ClientEntity
{
Id = Guid.NewGuid(),
IsDeleted = true,
OrganisationId = orgId1
};
using (var context = new DataContext(options))
{
context.Client.Add(client1);
context.Client.Add(client2);
context.Client.Add(client3);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new ClientService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(orgId1);
var queryOptions = new ClientQueryOptions(scope, "", "", 0, 0);
var clients = await service.GetClients(queryOptions);
//Then
Assert.Equal(2, clients.TotalItems);
Assert.Equal(2, clients.Items.Count());
var actual = clients.Items.First();
Assert.Equal(client1.Id, actual.Id);
Assert.Equal(client1.FirstName, actual.FirstName);
Assert.Equal(client1.ClientTypeId, actual.ClientTypeId);
Assert.Equal(client1.LastName, actual.LastName);
Assert.Equal(client1.MaidenName, actual.MaidenName);
Assert.Equal(client1.Initials, actual.Initials);
Assert.Equal(client1.PreferredName, actual.PreferredName);
Assert.Equal(client1.IdNumber, actual.IdNumber);
Assert.Equal(client1.DateOfBirth, actual.DateOfBirth);
Assert.Equal(client1.TaxNumber, actual.TaxNumber);
Assert.Equal(client1.MarritalStatusId, actual.MarritalStatusId);
Assert.Equal(client1.MarriageDate, actual.MarriageDate);
}
}
public async Task GetClients_SortAndPage()
{
var options = TestHelper.GetDbContext("GetClients_SortAndPage");
//Given
var orgId1 = Guid.NewGuid();
var mem1 = new ClientEntity {
Id = Guid.NewGuid(), LastName = "A Name 1", OrganisationId = orgId1
};
var mem2 = new ClientEntity {
Id = Guid.NewGuid(), LastName = "B Name 2", OrganisationId = orgId1
};
var mem3 = new ClientEntity {
Id = Guid.NewGuid(), LastName = "C Name 3", OrganisationId = orgId1
};
var mem4 = new ClientEntity {
Id = Guid.NewGuid(), LastName = "D Name 4", OrganisationId = orgId1
};
var mem5 = new ClientEntity {
Id = Guid.NewGuid(), LastName = "E Name 5", OrganisationId = orgId1
};
var mem6 = new ClientEntity {
Id = Guid.NewGuid(), LastName = "F Name 6", OrganisationId = orgId1
};
using (var context = new DataContext(options))
{
//Jumbled order
context.Client.Add(mem1);
context.Client.Add(mem2);
context.Client.Add(mem6);
context.Client.Add(mem4);
context.Client.Add(mem5);
context.Client.Add(mem3);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new ClientService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(orgId1);
var queryOptions = new ClientQueryOptions(scope, "LastName", "desc", 2, 2);
var actual = await service.GetClients(queryOptions);
//Then
Assert.Equal(6, actual.TotalItems);
var clients = actual.Items.ToArray();
Assert.Equal(2, clients.Count());
var actual1 = clients[0];
Assert.Equal(mem4.Id, actual1.Id);
var actual2 = clients[1];
Assert.Equal(mem3.Id, actual2.Id);
}
}
