public async Task Index()
{
var user = new User()
{
Id = Guid.NewGuid(),
FirstName = "1",
LastName = "2",
Email = "3",
UserName = "******",
OrganisationId = Guid.NewGuid(),
OrganisationName = "5",
BranchId = Guid.NewGuid(),
BranchName = "6",
Scope = Scope.Branch,
UserTypeId = Guid.NewGuid(),
};
var pagedItems = new PagedItems <User>()
{
TotalItems = 1,
Items = new List <User>()
{
user
}
};
var service = new Mock <IUserService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
UserQueryOptions queryOptions = null;
service.Setup(c => c.GetUsers(It.IsAny <UserQueryOptions>()))
.Callback((UserQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new UsersController(service.Object, authService.Object);
controller.ControllerContext = TestHelper.GetControllerContext(new ClaimsPrincipal());
var result = await controller.Index(2, 15);
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <User> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task <PagedItems <ClientRevenueData> > GetClientRevenueData(ClientRevenueQueryOptions options)
{
//Apply scope ------------------------------------------------------------
if (options.Scope.Scope == Scope.User)
{
options.UserId = new List <Guid>()
{
options.Scope.UserId
}
}
;
if (options.Scope.Scope == Scope.Branch)
{
options.BranchId = new List <Guid>()
{
options.Scope.BranchId
}
}
;
//-------------------------------------------------------------------------
var orderbyClause = "ORDER BY MonthlyAnnuityMonth DESC";
if (!string.IsNullOrEmpty(options.SortOptions.Column))
{
var direction = options.SortOptions.Direction == SortDirection.Ascending ? "ASC" : "DESC";
orderbyClause = $"ORDER BY {options.SortOptions.Column} {direction}";
}
var pagingClause = "";
if (options.PageOptions.Size > 0)
{
var start = (options.PageOptions.Size * (options.PageOptions.Number - 1)) + 1;
pagingClause = $"WHERE RowNumber BETWEEN {start} AND {start + options.PageOptions.Size - 1}";
}
var pagedItems = new PagedItems <ClientRevenueData>();
var builder = GetClientRevenueCountQuery(options);
pagedItems.TotalItems = (await _context.FromSqlAsync <int>(builder.Query, builder.SqlParameters)).FirstOrDefault();
builder = GetClientRevenueQuery(options, "*", orderbyClause, pagingClause);
pagedItems.Items = await _context.FromSqlAsync <ClientRevenueData>(builder.Query, builder.SqlParameters);
return(pagedItems);
}
public async Task Index()
{
var policy = new Policy()
{
Id = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
Number = "123456",
StartDate = DateTime.Now,
Premium = 500,
PolicyTypeId = Guid.NewGuid()
};
var pagedItems = new PagedItems <Policy>()
{
TotalItems = 1,
Items = new List <Policy>()
{
policy
}
};
var service = new Mock <IPolicyService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
PolicyQueryOptions queryOptions = null;
service.Setup(c => c.GetPolicies(It.IsAny <PolicyQueryOptions>()))
.Callback((PolicyQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new PoliciesController(service.Object, authService.Object);
var result = await controller.Index("StartDate", "desc", 15, 2, "Number=%123%");
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal("StartDate", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Descending, queryOptions.SortOptions.Direction);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
Assert.Equal("%123%", queryOptions.Number);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <Policy> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task <PagedItems <CommissionSplitRulePolicyInfo> > GetCommissionSplitRulePolicyInfoList(CommissionSplitRulePolicyInfoQueryOptions queryOptions)
{
var query = GetCommissionSplitRulePolicyInfoQuery(queryOptions.Scope);
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.PolicyUserId.Any())
{
query = query.Where(c => queryOptions.PolicyUserId.Contains(c.PolicyUserId));
}
if (queryOptions.PolicyCompanyId.Any())
{
query = query.Where(c => queryOptions.PolicyCompanyId.Contains(c.PolicyCompanyId));
}
if (queryOptions.PolicyClientId.Any())
{
query = query.Where(c => queryOptions.PolicyClientId.Contains(c.PolicyClientId));
}
if (!string.IsNullOrWhiteSpace(queryOptions.PolicyNumber))
{
query = query.Where(c => EF.Functions.Like(c.PolicyNumber, queryOptions.PolicyNumber));
}
if (!string.IsNullOrWhiteSpace(queryOptions.PolicyClientFirstName))
{
query = query.Where(c => EF.Functions.Like(c.PolicyClientFirstName, queryOptions.PolicyClientFirstName));
}
if (!string.IsNullOrWhiteSpace(queryOptions.PolicyClientLastName))
{
query = query.Where(c => EF.Functions.Like(c.PolicyClientLastName, queryOptions.PolicyClientLastName));
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <CommissionSplitRulePolicyInfo>();
//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 <PagedItems <UserSimple> > GetUsersSimple(ScopeOptions scope)
{
var query = GetUserSimpleQuery(scope);
var pagedItems = new PagedItems <UserSimple>();
//Get total items
pagedItems.TotalItems = await query.CountAsync();
//Ordering
query = query.OrderBy("LastName", SortDirection.Ascending);
pagedItems.Items = await query.ToListAsync();
return(pagedItems);
}
public async Task <IActionResult> ItemsAsync([FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0)
{
// Get a count of all posts
var totalItems = await this.Context.Posts.LongCountAsync();
// Get paged items
var itemsOnPage = await this.Context.Posts
.OrderByDescending(c => c.PubDate)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
var items = new PagedItems <Post>(pageIndex, pageSize, totalItems, itemsOnPage);
return(new JsonResult(items));
}
public async Task Index()
{
var allocation = new CommissionAllocation()
{
Id = Guid.NewGuid(),
FromClientId = Guid.NewGuid(),
ToClientId = Guid.NewGuid(),
PolicyIdCount = 1,
FromClientFirstName = "FN1",
FromClientLastName = "LN1",
};
var pagedItems = new PagedItems <CommissionAllocation>()
{
TotalItems = 1,
Items = new List <CommissionAllocation>()
{
allocation
}
};
var service = new Mock <ICommissionAllocationService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
CommissionAllocationQueryOptions queryOptions = null;
service.Setup(c => c.GetCommissionAllocations(It.IsAny <CommissionAllocationQueryOptions>()))
.Callback((CommissionAllocationQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new CommissionAllocationsController(service.Object, authService.Object);
var result = await controller.Index("toClientId", "desc", 15, 2, $"fromClientId={allocation.FromClientId}");
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal("toClientId", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Descending, queryOptions.SortOptions.Direction);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
Assert.Equal(allocation.FromClientId, queryOptions.FromClientId.Single());
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <CommissionAllocation> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task Index()
{
var rule = new CommissionSplitRule()
{
Id = Guid.NewGuid(),
Name = Guid.NewGuid().ToString(),
UserId = Guid.NewGuid(),
IsDefault = true,
Split = new List <CommissionSplit>(),
};
var pagedItems = new PagedItems <CommissionSplitRule>()
{
TotalItems = 1,
Items = new List <CommissionSplitRule>()
{
rule
}
};
var service = new Mock <ICommissionSplitService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
CommissionSplitRuleQueryOptions queryOptions = null;
service.Setup(c => c.GetCommissionSplitRules(It.IsAny <CommissionSplitRuleQueryOptions>()))
.Callback((CommissionSplitRuleQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new CommissionSplitRulesController(service.Object, authService.Object);
var result = await controller.Index("Name", "desc", 15, 2, $"UserId={rule.UserId}");
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal("Name", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Descending, queryOptions.SortOptions.Direction);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
Assert.Equal(rule.UserId, queryOptions.UserId.Single());
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <CommissionSplitRule> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task Index()
{
var branch = new Branch()
{
Id = Guid.NewGuid(),
OrganisationId = Guid.NewGuid(),
Name = "Branch1"
};
var pagedItems = new PagedItems <Branch>()
{
TotalItems = 1,
Items = new List <Branch>()
{
branch
}
};
var service = new Mock <IBranchService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
BranchQueryOptions queryOptions = null;
service.Setup(c => c.GetBranches(It.IsAny <BranchQueryOptions>()))
.Callback((BranchQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new BranchesController(service.Object, authService.Object);
controller.ControllerContext = TestHelper.GetControllerContext(new ClaimsPrincipal());
var result = await controller.Index($"organisationId={branch.OrganisationId}");
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal("Name", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Ascending, queryOptions.SortOptions.Direction);
Assert.Equal(0, queryOptions.PageOptions.Size);
Assert.Equal(0, queryOptions.PageOptions.Number);
Assert.Equal(branch.OrganisationId, queryOptions.OrganisationId);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <Branch> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task Index()
{
var contact = new Contact()
{
Id = Guid.NewGuid(),
ContactTypeId = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
Value = "*****@*****.**"
};
var pagedItems = new PagedItems <Contact>()
{
TotalItems = 1,
Items = new List <Contact>()
{
contact
}
};
var service = new Mock <IContactService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
ContactQueryOptions queryOptions = null;
service.Setup(c => c.GetContacts(It.IsAny <ContactQueryOptions>()))
.Callback((ContactQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new ContactsController(service.Object, authService.Object);
var result = await controller.Index($"clientId={contact.ClientId}");
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal("Value", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Ascending, queryOptions.SortOptions.Direction);
Assert.Equal(0, queryOptions.PageOptions.Size);
Assert.Equal(0, queryOptions.PageOptions.Number);
Assert.Equal(contact.ClientId, queryOptions.ClientId);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <Contact> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task <PagedItems <CommissionAllocation> > GetCommissionAllocations(CommissionAllocationQueryOptions queryOptions)
{
var clientQuery = ScopeQuery.GetClientEntityQuery(_context, queryOptions.Scope);
var query = from commissionAllocation in _context.CommissionAllocation
join fromClient in clientQuery
on commissionAllocation.FromClientId equals fromClient.Id
join toClient in clientQuery
on commissionAllocation.ToClientId equals toClient.Id
select new CommissionAllocation()
{
Id = commissionAllocation.Id,
FromClientId = commissionAllocation.FromClientId,
ToClientId = commissionAllocation.ToClientId,
PolicyIdCount = commissionAllocation.CommissionAllocationPolicies.Count(),
FromClientFirstName = fromClient.FirstName,
FromClientLastName = fromClient.LastName
};
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.FromClientId.Any())
{
query = query.Where(c => queryOptions.FromClientId.Contains(c.FromClientId));
}
if (queryOptions.ToClientId.Any())
{
query = query.Where(c => queryOptions.ToClientId.Contains(c.ToClientId));
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <CommissionAllocation>();
//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 Index()
{
var organisation = new Organisation()
{
Id = Guid.NewGuid(),
Name = "organisation_1"
};
var items = new PagedItems <Organisation>()
{
TotalItems = 1,
Items = new List <Organisation>()
{
organisation
}
};
var service = new Mock <IOrganisationService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
OrganisationQueryOptions queryOptions = null;
service.Setup(c => c.GetOrganisations(It.IsAny <OrganisationQueryOptions>()))
.Callback((OrganisationQueryOptions options) => queryOptions = options)
.ReturnsAsync(items);
var controller = new OrganisationsController(authService.Object, service.Object, null);
controller.ControllerContext = TestHelper.GetControllerContext(new ClaimsPrincipal());
var result = await controller.Index();
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal("Name", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Ascending, queryOptions.SortOptions.Direction);
Assert.Equal(0, queryOptions.PageOptions.Size);
Assert.Equal(0, queryOptions.PageOptions.Number);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <Organisation> >(okResult.Value);
Assert.Same(items, returnValue);
}
public ActionResult Orders(int?pageNumber = 1)
{
var pagedOrders = _orderLogic.GetAll(pageNumber.Value, _pageSize);
var totalPages = (int)Math.Ceiling((double)pagedOrders.Count / _pageSize);
var pagedItems = new PagedItems <OrderListItemVm>
{
Data = Mapper.Map <IEnumerable <Order>, IEnumerable <OrderListItemVm> >(pagedOrders.Data),
PageInfo = new PageInfo
{
CurrentPage = pageNumber.Value,
StartIndex = GetStartIndex(pageNumber.Value, totalPages),
PageLinksCount = (totalPages < _maxPageSelectors) ? totalPages : _maxPageSelectors,
TotalPages = totalPages
}
};
return(View(pagedItems));
}
public async Task Index()
{
var template = new CommissionStatementTemplate()
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 1"
};
var pagedItems = new PagedItems <CommissionStatementTemplate>()
{
TotalItems = 1,
Items = new List <CommissionStatementTemplate>()
{
template
}
};
var service = new Mock <ICommissionStatementTemplateService>();
CommissionStatementTemplateQueryOptions queryOptions = null;
service.Setup(c => c.GetTemplates(It.IsAny <CommissionStatementTemplateQueryOptions>()))
.Callback((CommissionStatementTemplateQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new CommissionStatementTemplateController(service.Object);
var result = await controller.Index("Name", "desc", 15, 2, $"CompanyId={template.CompanyId}");
Assert.Equal("Name", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Descending, queryOptions.SortOptions.Direction);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
Assert.Equal(template.CompanyId, queryOptions.CompanyId.Single());
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <CommissionStatementTemplate> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task <PagedItems <CommissionSplitRulePolicy> > GetCommissionSplitRulePolicies(CommissionSplitRulePolicyQueryOptions queryOptions)
{
var query = GetCommissionSplitRulePolicyQuery(queryOptions.Scope);
//Apply filters ----------------------------------------------------------------------------------------
//none so far..
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <CommissionSplitRulePolicy>();
//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 GetUsersSimple()
{
var user = new UserSimple()
{
Id = Guid.NewGuid(),
FirstName = "1",
LastName = "2",
};
var pagedItems = new PagedItems <UserSimple>()
{
TotalItems = 1,
Items = new List <UserSimple>()
{
user
}
};
var service = new Mock <IUserService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
ScopeOptions queryOptions = null;
service.Setup(c => c.GetUsersSimple(It.IsAny <ScopeOptions>()))
.Callback((ScopeOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new UsersController(service.Object, authService.Object);
controller.ControllerContext = TestHelper.GetControllerContext(new ClaimsPrincipal());
var result = await controller.GetUsersSimple();
Assert.Equal(Scope.Branch, queryOptions.Scope);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <UserSimple> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task <PagedItems <CommissionStatementTemplate> > GetTemplates(CommissionStatementTemplateQueryOptions queryOptions)
{
var query = from template in _context.CommissionStatementTemplate
select new CommissionStatementTemplate()
{
Id = template.Id,
CompanyId = template.CompanyId,
Name = template.Name,
StartDate = template.StartDate,
EndDate = template.EndDate,
BrokerSpecific = template.BrokerSpecific,
};
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.CompanyId.Any())
{
query = query.Where(c => queryOptions.CompanyId.Contains(c.CompanyId));
}
if (queryOptions.Date.HasValue)
{
query = query.Where(c => c.StartDate <= queryOptions.Date.Value.Date || c.StartDate == null);
query = query.Where(c => c.EndDate >= queryOptions.Date.Value.Date || c.EndDate == null);
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <CommissionStatementTemplate>();
//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 <PagedItems <CommissionSplitRule> > GetCommissionSplitRules(CommissionSplitRuleQueryOptions queryOptions)
{
var query = GetCommissionSplitRuleQuery(queryOptions.Scope);
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.UserId.Any())
{
query = query.Where(c => queryOptions.UserId.Contains(c.UserId.Value));
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <CommissionSplitRule>();
//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 ActionResult UserList(int?pageNumber = 1)
{
var pagedUsers = _userLogic.GetAll(pageNumber.Value, _pageSize);
var allRoles = _userRoleLogic.GetAll().Select(r => r.Name);
var userListItems = Mapper.Map <IEnumerable <UserEntity>, IEnumerable <UserListItemVm> >(
pagedUsers.Data.Where(u => !string.Equals(u.Name, User.Identity.Name, StringComparison.InvariantCultureIgnoreCase)));
var totalPages = (int)Math.Ceiling((double)pagedUsers.Count / _pageSize);
var pagedItems = new PagedItems <UserListItemVm>
{
Data = FillRolesIntoUser(userListItems, allRoles),
PageInfo = new PageInfo
{
CurrentPage = pageNumber.Value,
StartIndex = GetStartIndex(pageNumber.Value, totalPages),
PageLinksCount = (totalPages < _maxPageSelectors) ? totalPages : _maxPageSelectors,
TotalPages = totalPages
}
};
return(View(pagedItems));
}
public async Task <PagedItems <Contact> > GetContacts(ContactQueryOptions queryOptions)
{
var query = GetContactQuery(queryOptions.Scope);
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.ClientId.HasValue)
{
query = query.Where(b => b.ClientId == queryOptions.ClientId);
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <Contact>();
//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 <PagedItems <ChangeLog> > GetChangeLogs(ChangeLogQueryOptions queryOptions)
{
var query = GetChangeLogQuery();
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.Published.HasValue)
{
query = query.Where(l => l.Published == queryOptions.Published);
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <ChangeLog>();
//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 <PagedItems <User> > GetUsers(UserQueryOptions queryOptions)
{
var query = from user in ScopeQuery.GetUserEntityQuery(_context, queryOptions.Scope)
join branch in _context.Branch
on user.BranchId equals branch.Id
join organisation in _context.Organisation
on branch.OrganisationId equals organisation.Id
select new User()
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
UserName = user.UserName,
BranchId = user.BranchId,
BranchName = branch.Name,
OrganisationId = organisation.Id,
OrganisationName = organisation.Name,
Scope = user.Scope,
EmailConfirmed = user.EmailConfirmed,
LockoutEnd = user.LockoutEnd,
UserTypeId = user.UserTypeId,
Config = user.Config,
};
//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.Email))
{
query = query.Where(m => EF.Functions.Like(m.Email, queryOptions.Email));
}
if (queryOptions.EmailConfirmed.HasValue)
{
query = query.Where(m => m.EmailConfirmed == queryOptions.EmailConfirmed);
}
if (queryOptions.OrganisationId.Any())
{
query = query.Where(m => queryOptions.OrganisationId.Contains(m.OrganisationId));
}
if (queryOptions.BranchId.Any())
{
query = query.Where(m => queryOptions.BranchId.Contains(m.BranchId));
}
if (queryOptions.UserTypeId.Any())
{
query = query.Where(m => queryOptions.UserTypeId.Contains(m.UserTypeId));
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <User>();
//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 <PagedItems <Policy> > GetPolicies(PolicyQueryOptions queryOptions)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, queryOptions.Scope);
var policyQuery = from policy in _context.Policy
select policy;
//Apply filters ----------------------------------------------------------------------------------------
if (!string.IsNullOrWhiteSpace(queryOptions.Number))
{
policyQuery = policyQuery.WherePolicyNumberEquals(queryOptions.Number);
}
//------------------------------------------------------------------------------------------------------
var query = from user in userQuery
join policy in policyQuery
on user.Id equals policy.UserId
join client in _context.Client
on policy.ClientId equals client.Id
join company in _context.Company
on policy.CompanyId equals company.Id
select new Policy()
{
Id = policy.Id,
ClientId = policy.ClientId,
Number = policy.Number,
CompanyId = policy.CompanyId,
UserId = policy.UserId,
Premium = policy.Premium,
StartDate = policy.StartDate,
PolicyTypeId = policy.PolicyTypeId,
PolicyProductTypeId = policy.PolicyProductTypeId,
PolicyProductId = policy.PolicyProductId,
ClientLastName = client.LastName,
ClientInitials = client.Initials,
ClientDateOfBirth = client.DateOfBirth,
IsActive = policy.IsActive,
NumberAliases = policy.NumberAliases,
CompanyName = company.Name,
};
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.Id.HasValue)
{
query = query.Where(m => m.Id == queryOptions.Id.Value);
}
if (queryOptions.ClientId.HasValue)
{
query = query.Where(m => m.ClientId == queryOptions.ClientId.Value);
}
if (queryOptions.CompanyId.Any())
{
query = query.Where(m => queryOptions.CompanyId.Contains(m.CompanyId));
}
if (queryOptions.PolicyTypeId.Any())
{
query = query.Where(m => queryOptions.PolicyTypeId.Contains(m.PolicyTypeId.Value));
}
if (queryOptions.UserId.Any())
{
query = query.Where(m => queryOptions.UserId.Contains(m.UserId));
}
if (!string.IsNullOrWhiteSpace(queryOptions.ClientLastName))
{
query = query.Where(m => EF.Functions.Like(m.ClientLastName, queryOptions.ClientLastName));
}
if (queryOptions.IsActive.HasValue)
{
query = query.Where(m => m.IsActive == queryOptions.IsActive.Value);
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <Policy>();
//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 <PagedItems <CommissionLapseData> > GetCommissionLapseData(CommissionLapseQueryOptions queryOptions)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, queryOptions.Scope);
var thisMonth = queryOptions.Date.Month;
var thisYear = queryOptions.Date.Year;
var thisMonthPolicies = from statement in _context.CommissionStatement
join commission in _context.Commission
on statement.Id equals commission.CommissionStatementId
join user in userQuery
on commission.UserId equals user.Id
where statement.DateMonth == thisMonth &&
statement.DateYear == thisYear
select commission.PolicyId;
var lastMonthDate = queryOptions.Date.AddMonths(-1);
var lastMonth = lastMonthDate.Month;
var lastYear = lastMonthDate.Year;
var query = from statement in _context.CommissionStatement
join commission in _context.Commission
on statement.Id equals commission.CommissionStatementId
join company in _context.Company
on statement.CompanyId equals company.Id
join policy in _context.Policy
on commission.PolicyId equals policy.Id
join client in _context.Client
on policy.ClientId equals client.Id
join user in userQuery
on commission.UserId equals user.Id
where statement.DateMonth == lastMonth &&
statement.DateYear == lastYear &&
thisMonthPolicies.Contains(commission.PolicyId) == false
select new CommissionLapseData()
{
PolicyId = policy.Id,
ClientId = policy.ClientId,
Number = policy.Number,
CompanyId = policy.CompanyId,
UserId = policy.UserId,
Premium = policy.Premium,
StartDate = policy.StartDate,
PolicyTypeId = policy.PolicyTypeId,
ClientLastName = client.LastName,
ClientInitials = client.Initials,
IsActive = policy.IsActive,
CompanyName = company.Name,
};
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.CompanyId.Any())
{
query = query.Where(d => queryOptions.CompanyId.Contains(d.CompanyId));
}
if (queryOptions.UserId.Any())
{
query = query.Where(d => queryOptions.UserId.Contains(d.UserId));
}
if (queryOptions.PolicyTypeId.Any())
{
query = query.Where(d => queryOptions.PolicyTypeId.Contains(d.PolicyTypeId.Value));
}
if (!string.IsNullOrWhiteSpace(queryOptions.Number))
{
query = query.Where(m => EF.Functions.Like(m.Number, queryOptions.Number));
}
if (!string.IsNullOrWhiteSpace(queryOptions.ClientLastName))
{
query = query.Where(m => EF.Functions.Like(m.ClientLastName, queryOptions.ClientLastName));
}
if (queryOptions.IsActive.HasValue)
{
query = query.Where(m => m.IsActive == queryOptions.IsActive.Value);
}
//------------------------------------------------------------------------------------------------------
query = query.Distinct();
var pagedItems = new PagedItems <CommissionLapseData>();
//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 IEnumerator <T> GetEnumerator()
{
return(PagedItems.GetEnumerator());
}
IEnumerator IEnumerable.GetEnumerator() => PagedItems.GetEnumerator();
