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 PolicyQueryOptions(scope, sortColumn, sortDirection, pageSize, pageNumber, filters);
var pagedItems = await PolicyService.GetPolicies(queryOptions);
return(Ok(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 <ImportResult> ImportCommissions(ScopeOptions scope, Guid commissionStatementId, IEnumerable <ImportCommission> importData)
{
var importResult = new ImportResult();
CommissionsToInsert = new List <CommissionEntity>();
CommissionErrorsToInsert = new List <CommissionErrorEntity>();
//Scope check
var queryOptions = new CommissionStatementQueryOptions(scope, "", "", 0, 0);
queryOptions.CommissionStatementId = commissionStatementId;
var statements = await _commissionStatementService.GetCommissionStatements(queryOptions);
if (!statements.Items.Any())
{
return(importResult);
}
var statement = statements.Items.Single();
var commissionTypes = await _commissionLookupService.GetCommissionTypes();
var commissionTypesDictionary = BuildCommissionTypesDictionary(commissionTypes);
var company = await _lookupService.GetCompany(statement.CompanyId);
var policyQueryOptions = new PolicyQueryOptions(scope, "", "", 0, 0);
policyQueryOptions.CompanyId.Add(statement.CompanyId);
var policies = (await _policyService.GetPolicies(policyQueryOptions)).Items.ToList();
var policyDictionary = BuildPolicyDictionary(policies, company.CommissionPolicyNumberPrefixes.ToList());
var commissionSplitRulesQueryOptions = new CommissionSplitRuleQueryOptions(scope, "", "", 0, 0);
var commissionSplitRules = (await _commissionSplitService.GetCommissionSplitRules(commissionSplitRulesQueryOptions)).Items.ToList();
var commissionSplitRulePolicyQueryOptions = new CommissionSplitRulePolicyQueryOptions(scope, "", "", 0, 0);
var commissionSplitRulePolicies = (await _commissionSplitRulePolicyService.GetCommissionSplitRulePolicies(commissionSplitRulePolicyQueryOptions)).Items.ToList();
foreach (var data in importData)
{
var result = ImportCommission(scope, statement, data, policyDictionary, commissionTypesDictionary, commissionSplitRules, commissionSplitRulePolicies);
importResult.Results.Add(result);
if (data.CommissionTypeCode == CommissionType.COMMISSION_TYPE_UNKNOWN_CODE)
{
importResult.AddUnknownCommissionTypeValue(data.CommissionTypeValue);
}
}
if (CommissionsToInsert.Any())
{
await _bulkActions.BulkInsertCommissionsAsync(_context, CommissionsToInsert);
}
if (CommissionErrorsToInsert.Any())
{
await _bulkActions.BulkInsertCommissionErrorsAsync(_context, CommissionErrorsToInsert);
}
await _auditService.InsertAuditLog(scope, "Import", "Commission", statement.Id,
new
{
commissionStatementId = commissionStatementId,
importCount = importResult.ImportCount,
errorCount = importResult.ErrorCount,
errors = importResult.Results.Where(r => !r.Success).ToList()
}
);
return(importResult);
}
public async Task GetPolicies()
{
var options = TestHelper.GetDbContext("GetPolicies");
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 company1 = TestHelper.InsertCompany(options);
//Given
var policy1 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = company1.Id,
ClientId = client1.Client.Id,
UserId = user1.User.Id,
Number = "123465",
StartDate = DateTime.Now,
Premium = 500,
PolicyTypeId = Guid.NewGuid(),
PolicyProductTypeId = Guid.NewGuid(),
PolicyProductId = Guid.NewGuid(),
IsActive = true,
};
var policy2 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = company1.Id,
ClientId = client2.Client.Id,
UserId = user2.User.Id,
Number = "654321",
PolicyTypeId = Guid.NewGuid(),
PolicyProductTypeId = Guid.NewGuid(),
PolicyProductId = Guid.NewGuid(),
IsActive = false,
};
var policy3 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = company1.Id,
ClientId = client3.Client.Id,
UserId = user3.User.Id,
Number = "987654"
};
using (var context = new DataContext(options))
{
context.Policy.Add(policy1);
context.Policy.Add(policy2);
context.Policy.Add(policy3);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new PolicyService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var queryOptions = new PolicyQueryOptions(scope, "", "", 0, 0);
var policies = await service.GetPolicies(queryOptions);
//Then
Assert.Equal(2, policies.TotalItems);
Assert.Equal(2, policies.Items.Count());
var actual = policies.Items.First();
Assert.Equal(policy1.Id, actual.Id);
Assert.Equal(policy1.ClientId, actual.ClientId);
Assert.Equal(policy1.CompanyId, actual.CompanyId);
Assert.Equal(policy1.Number, actual.Number);
Assert.Equal(policy1.StartDate, actual.StartDate);
Assert.Equal(policy1.Premium, actual.Premium);
Assert.Equal(policy1.PolicyTypeId, actual.PolicyTypeId);
Assert.Equal(policy1.PolicyProductTypeId, actual.PolicyProductTypeId);
Assert.Equal(policy1.PolicyProductId, actual.PolicyProductId);
Assert.Equal(policy1.IsActive, actual.IsActive);
actual = policies.Items.Last();
Assert.Equal(policy2.Id, actual.Id);
Assert.Equal(policy2.IsActive, actual.IsActive);
//Check scope
scope = TestHelper.GetScopeOptions(user1, Scope.User);
queryOptions = new PolicyQueryOptions(scope, "", "", 0, 0);
policies = await service.GetPolicies(queryOptions);
Assert.Single(policies.Items);
actual = policies.Items.First();
Assert.Equal(policy1.Id, actual.Id);
}
}
public async Task <Result> ResolveMappingError(ScopeOptions scope, CommissionErrorEdit error)
{
var validator = new CommissionErrorValidator();
var result = validator.Validate(error).GetResult();
if (!result.Success)
{
return(result);
}
var commission = new CommissionEdit();
commission.PolicyId = error.PolicyId;
commission.CommissionStatementId = error.CommissionStatementId;
commission.CommissionTypeId = error.CommissionTypeId;
commission.AmountIncludingVAT = Convert.ToDecimal(error.Data.AmountIncludingVAT);
commission.VAT = Convert.ToDecimal(error.Data.VAT);
commission.SourceData = error.Data;
var policyQueryOptions = new PolicyQueryOptions(scope, "", "", 0, 0);
policyQueryOptions.Id = error.PolicyId;
var policy = (await _policyService.GetPolicies(policyQueryOptions)).Items.Single();
var commissionSplitRulesOptions = new CommissionSplitRuleQueryOptions(scope, "", "", 0, 0);
var commissionSplitRules = (await _commissionSplitService.GetCommissionSplitRules(commissionSplitRulesOptions)).Items.ToList();
var commissionSplitRulePolicyQueryOptions = new CommissionSplitRulePolicyQueryOptions(scope, "", "", 0, 0);
var commissionSplitRulePolicies = (await _commissionSplitRulePolicyService.GetCommissionSplitRulePolicies(commissionSplitRulePolicyQueryOptions)).Items.ToList();
var commissions = _commissionSplitService.SplitCommission(commission, policy, error.Data, commissionSplitRules, commissionSplitRulePolicies);
foreach (var c in commissions)
{
result = await _commissionService.InsertCommission(scope, c);
}
//Update client details (if none exist)
try
{
var client = await _clientService.GetClient(scope, error.ClientId.Value);
client.FirstName = string.IsNullOrEmpty(client.FirstName) ? error.Data.FirstName ?? "" : client.FirstName;
client.LastName = string.IsNullOrEmpty(client.LastName) ? error.Data.FullName ?? "" : client.LastName;
client.LastName = string.IsNullOrEmpty(client.LastName) ? error.Data.LastName ?? "" : client.LastName;
client.Initials = string.IsNullOrEmpty(client.Initials) ? error.Data.Initials ?? "" : client.Initials;
client.DateOfBirth = !client.DateOfBirth.HasValue ? DateTime.Parse(error.Data.DateOfBirth) : client.DateOfBirth;
if (!string.IsNullOrEmpty(error.Data.IdNumber))
{
var idNumber = new IdNumber(error.Data.IdNumber);
if (idNumber.IsValid)
{
client.IdNumber = string.IsNullOrEmpty(client.IdNumber) ? error.Data.IdNumber : client.IdNumber;
}
else
{
client.AlternateIdNumber = string.IsNullOrEmpty(client.AlternateIdNumber) ? error.Data.IdNumber ?? "" : client.AlternateIdNumber;
}
}
await _clientService.UpdateClient(scope, client);
//Add policy alias if policy number doesnt match policy id
if (!policy.Number.IgnoreCaseEquals(error.Data.PolicyNumber))
{
//First check if its not already and alias
if (!policy.NumberAliases.Any(n => n.IgnoreCaseEquals(error.Data.PolicyNumber)))
{
var policyEdit = await _policyService.GetPolicy(scope, policy.Id);
policyEdit.NumberAliases.Add(error.Data.PolicyNumber);
await _policyService.UpdatePolicy(scope, policyEdit);
}
}
}
catch { }
if (!result.Success)
{
return(result);
}
await DeleteError(scope, error.Id);
result.Tag = commission;
return(result);
}
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);
}
