public static IRuleBuilderOptions <T, Guid?> CommissionSplitRuleMustBeInScope <T>(this IRuleBuilder <T, Guid?> ruleBuilder, DataContext dataContext, ScopeOptions scope)
{
return(ruleBuilder.MustAsync(async(root, commissionSplitRuleId, context) =>
{
if (!commissionSplitRuleId.HasValue)
{
return false;
}
var rule = await dataContext.CommissionSplitRule.FindAsync(commissionSplitRuleId);
if (rule == null)
{
return false;
}
return await ScopeQuery.IsUserInScope(dataContext, scope, rule.UserId);
})
.WithMessage((root, commissionSplitRuleId) =>
{
if (!commissionSplitRuleId.HasValue)
{
return NOT_EMPTY_MESSAGE;
}
return DOESNT_EXIST_MESSAGE;
})
.WithName("Commission Split Rule"));
}
public static IRuleBuilderOptions <T, Guid?> PolicyMustBeInScope <T>(this IRuleBuilder <T, Guid?> ruleBuilder, DataContext dataContext, ScopeOptions scope)
{
return(ruleBuilder.MustAsync(async(root, policyId, context) =>
{
if (!policyId.HasValue)
{
return false;
}
var policy = await dataContext.Policy.FindAsync(policyId);
if (policy == null)
{
return false;
}
return await ScopeQuery.IsUserInScope(dataContext, scope, policy.UserId);
})
.WithMessage((root, id) =>
{
if (!id.HasValue)
{
return NOT_EMPTY_MESSAGE;
}
return DOESNT_EXIST_MESSAGE;
})
.WithName("Policy"));
}
private IQueryable <OrganisationEntity> GetOrganisationEnitiyQuery(ScopeOptions scope)
{
var query = from organisation in ScopeQuery.GetOrganisationEntityQuery(_context, scope)
select organisation;
return(query);
}
public async Task <IEnumerable <UserCompanyMonthlyCommissionData> > GetUserCompanyMonthlyCommissionData(UserCompanyMonthlyCommissionQueryOptions queryOptions)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, queryOptions.Scope);
var query = from commission in _context.Commission
join statement in _context.CommissionStatement
on commission.CommissionStatementId equals statement.Id
join policy in _context.Policy
on commission.PolicyId equals policy.Id
join user in userQuery
on commission.UserId equals user.Id
select new
{
UserId = user.Id,
BranchId = user.BranchId,
Date = statement.Date,
CompanyId = policy.CompanyId,
AmountIncludingVAT = commission.AmountIncludingVAT,
VAT = commission.VAT
};
//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.BranchId.Any())
{
query = query.Where(d => queryOptions.BranchId.Contains(d.BranchId));
}
if (queryOptions.StartDate.HasValue)
{
query = query.Where(d => queryOptions.StartDate.Value.Date <= d.Date);
}
if (queryOptions.EndDate.HasValue)
{
query = query.Where(d => queryOptions.EndDate.Value.Date >= d.Date);
}
//------------------------------------------------------------------------------------------------------
var groupQuery = from data in query
group new { data.AmountIncludingVAT, data.VAT } by new { data.CompanyId } into g
select new UserCompanyMonthlyCommissionData()
{
CompanyId = g.Key.CompanyId,
AmountExcludingVAT = g.Sum(c => (c.AmountIncludingVAT - c.VAT)),
};
groupQuery = groupQuery.OrderBy(queryOptions.SortOptions.Column, queryOptions.SortOptions.Direction);
return(await groupQuery.ToListAsync());
}
public async Task <PagedItems <Organisation> > GetOrganisations(OrganisationQueryOptions queryOptions)
{
var query = from organisation in ScopeQuery.GetOrganisationEntityQuery(_context, queryOptions.Scope)
select new Organisation()
{
Id = organisation.Id,
Name = organisation.Name,
ApplicationIds = organisation.ApplicationIds,
Config = organisation.Config,
};
var pagedItems = new PagedItems <Organisation>();
if (queryOptions.BranchId.HasValue)
{
var branch = await _context.Branch.FirstOrDefaultAsync(b => b.Id == queryOptions.BranchId.Value);
if (branch != null)
{
query = query.Where(o => o.Id == branch.OrganisationId);
}
}
//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 Policies(IExportRenderer <ClientPolicy> renderer, Stream stream, ScopeOptions scope)
{
var query = from client in ScopeQuery.GetClientEntityQuery(_context, scope)
join policy in _context.Policy on client.Id equals policy.ClientId into policyGroup
from policy in policyGroup.DefaultIfEmpty()
join user in _context.Users on policy.UserId equals user.Id into userGroup
from user in userGroup.DefaultIfEmpty()
select new ClientPolicy()
{
IdNumber = (client.IdNumber == "" || client.IdNumber == null) ? client.AlternateIdNumber : client.IdNumber,
FirstName = client.FirstName,
LastName = client.LastName,
Email = client.ClientContacts.Where(c => c.ContactTypeId == ContactType.CONTACT_TYPE_EMAIL).Select(c => c.Value).FirstOrDefault(),
CellPhone = client.ClientContacts.Where(c => c.ContactTypeId == ContactType.CONTACT_TYPE_CELLPHONE).Select(c => c.Value).FirstOrDefault(),
DateOfBirth = client.DateOfBirth,
TaxNumber = client.TaxNumber,
PolicyNumber = policy.Number,
PolicyBroker = user.FirstName + " " + user.LastName,
PolicyPremium = policy.Premium,
PolicyTypeCode = policy.PolicyType.Code,
PolicyStartDate = policy.StartDate,
PolicyCompany = policy.Company.Name
};
var items = await query.ToListAsync();
await renderer.Render(stream, items);
}
public async Task <Result> UpdateOrganisation(ScopeOptions scope, OrganisationEdit organisation)
{
var validator = new OrganisationValidator(_context, false, organisation.Id);
var result = validator.Validate(organisation).GetResult();
if (!result.Success)
{
return(result);
}
//Only organisation scope
if (scope.Scope == Scope.Branch || scope.Scope == Scope.User)
{
return(new Result());
}
var entity = await ScopeQuery
.GetOrganisationEntityQuery(_context, scope)
.FirstOrDefaultAsync(o => o.Id == organisation.Id);
if (entity == null)
{
return(new Result());
}
entity = MapModelToEntity(organisation, entity);
await _context.SaveChangesAsync();
return(result);
}
private IQueryable <CommissionSplitRulePolicyInfo> GetCommissionSplitRulePolicyInfoQuery(ScopeOptions scope)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, scope);
var query = from policy in _context.Policy
join user in userQuery
on policy.UserId equals user.Id
join client in _context.Client
on policy.ClientId equals client.Id
join commissionSplitRulePolicy in _context.CommissionSplitRulePolicy
on policy.Id equals commissionSplitRulePolicy.PolicyId into groupCommissionSplitRulePolicy
from subCommissionSplitRulePolicy in groupCommissionSplitRulePolicy.DefaultIfEmpty()
join commissionSplitRule in _context.CommissionSplitRule
on new { Key1 = policy.UserId, Key2 = true } equals new { Key1 = commissionSplitRule.UserId, Key2 = commissionSplitRule.IsDefault } into groupCommissionSplitRule
from subCommissionSplitRule in groupCommissionSplitRule.DefaultIfEmpty()
select new CommissionSplitRulePolicyInfo()
{
PolicyId = policy.Id,
PolicyUserId = policy.UserId,
PolicyCompanyId = policy.CompanyId,
PolicyNumber = policy.Number,
PolicyClientFirstName = client.FirstName,
PolicyClientLastName = client.LastName,
PolicyClientId = client.Id,
CommissionSplitRuleId = subCommissionSplitRulePolicy.CommissionSplitRuleId,
CommissionSplitRuleName = subCommissionSplitRulePolicy.CommissionSplitRule.Name,
DefaultCommissionSplitRuleId = subCommissionSplitRule.Id,
DefaultCommissionSplitRuleName = subCommissionSplitRule.Name
};
return(query);
}
public async Task AutoResolveMappingErrors(ScopeOptions scope, Guid commissionStatementId, Guid policyId)
{
var policy = await _context.Policy.FindAsync(policyId);
var organisationQuery = ScopeQuery.GetOrganisationEntityQuery(_context, scope);
var query = from commissionError in GetCommissionErrorEditQuery(scope)
where commissionError.CommissionStatementId == commissionStatementId
select commissionError;
var errors = await query.ToListAsync();
foreach (var error in errors)
{
var policyNumbers = policy.NumberAliases.ToList();
policyNumbers.Add(policy.Number);
if (!policyNumbers.Any(p => p.IgnoreCaseEquals(error.Data.PolicyNumber)))
{
continue;
}
error.ClientId = policy.ClientId;
error.PolicyId = policyId;
await ResolveMappingError(scope, error);
}
}
private IQueryable <ContactEntity> GetContactEntityQuery(ScopeOptions scope)
{
var query = from client in ScopeQuery.GetClientEntityQuery(_context, scope)
join contact in _context.Contact
on client.Id equals contact.ClientId
select contact;
return(query);
}
public static IRuleBuilderOptions <T, Guid> UserMustBeInScope <T>(this IRuleBuilder <T, Guid> ruleBuilder, DataContext dataContext, ScopeOptions scope)
{
return(ruleBuilder.MustAsync(async(root, userId, context) =>
{
return await ScopeQuery.IsUserInScope(dataContext, scope, userId);
})
.WithMessage(DOESNT_EXIST_MESSAGE)
.WithName("User"));
}
private void SourceClientIdsInScope(MergeClients merge, CustomContext context)
{
var clients = ScopeQuery.GetClientEntityQuery(_context, _scope).Where(m => merge.SourceClientIds.Contains(m.Id)).ToList();
if (clients.Count != merge.SourceClientIds.Count)
{
var failure = new ValidationFailure("SourceClientIds", "Invalid Source Client Ids");
context.AddFailure(failure);
}
}
private IQueryable <CommissionStatementEntity> GetCommissionStatementEntityQuery(ScopeOptions scope)
{
var organisationQuery = ScopeQuery.GetOrganisationEntityQuery(_context, scope);
var query = from organisation in organisationQuery
join commissionStatement in _context.CommissionStatement
on organisation.Id equals commissionStatement.OrganisationId
select commissionStatement;
return(query);
}
private IQueryable <PolicyEntity> GetPolicyEntityQuery(ScopeOptions scope)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, scope);
var query = from user in userQuery
join policy in _context.Policy
on user.Id equals policy.UserId
select policy;
return(query);
}
private IQueryable <CommissionSplitRuleEntity> GetCommissionSplitRuleEntityQuery(ScopeOptions scope)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, scope);
var query = from commissionSplitRule in _context.CommissionSplitRule
join user in userQuery
on commissionSplitRule.UserId equals user.Id
select commissionSplitRule;
return(query);
}
public async Task <List <BranchSimple> > GetBranchesSimple(ScopeOptions scope)
{
var query = from branch in ScopeQuery.GetBranchEntityQuery(_context, scope)
orderby branch.Name
select new BranchSimple()
{
Id = branch.Id,
Name = branch.Name
};
return(await query.ToListAsync());
}
private IQueryable <Branch> GetBranchQuery(ScopeOptions scope)
{
var query = from branch in ScopeQuery.GetBranchEntityQuery(_context, scope)
select new Branch()
{
Id = branch.Id,
OrganisationId = branch.OrganisationId,
Name = branch.Name
};
return(query);
}
private IQueryable <CommissionAllocationEntity> GetCommissionAllocationEntityQuery(ScopeOptions scope)
{
var clientQuery = ScopeQuery.GetClientEntityQuery(_context, 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 commissionAllocation;
return(query);
}
private IQueryable <CommissionSplitRulePolicyEntity> GetCommissionSplitRulePolicyEntityQuery(ScopeOptions scope)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, scope);
var query = from commissionSplitRulePolicy in _context.CommissionSplitRulePolicy
join policy in _context.Policy
on commissionSplitRulePolicy.PolicyId equals policy.Id
join user in userQuery
on policy.UserId equals user.Id
select commissionSplitRulePolicy;
return(query);
}
private IQueryable <UserSimple> GetUserSimpleQuery(ScopeOptions scope)
{
var query = from user in ScopeQuery.GetUserEntityQuery(_context, scope)
select new UserSimple()
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
BranchId = user.BranchId,
UserTypeId = user.UserTypeId,
};
return(query);
}
public static IRuleBuilderOptions <T, Guid?> OrganisationMustBeInScope <T>(this IRuleBuilder <T, Guid?> ruleBuilder, DataContext dataContext, ScopeOptions scope)
{
return(ruleBuilder.Must((root, organisationId, context) =>
{
if (!organisationId.HasValue)
{
return false;
}
return ScopeQuery.IsOrganisationInScope(scope, organisationId.Value);
})
.WithMessage(DOESNT_EXIST_MESSAGE)
.WithName("Organisation"));
}
public async Task <UserEdit> GetUser(ScopeOptions scope, string userName)
{
var query = from entity in ScopeQuery.GetUserEntityQuery(_context, scope)
where entity.UserName == userName
select entity;
var user = await query.FirstOrDefaultAsync();
if (user == null)
{
return(null);
}
return(await LoadUserEditModel(user));
}
private void SourcePolicyIdsInScope(MergePolicies merge, CustomContext context)
{
var userQuery = ScopeQuery.GetUserEntityQuery(_context, _scope);
var policyQuery = from policy in _context.Policy
select policy;
var policies = policyQuery.Where(m => merge.SourcePolicyIds.Contains(m.Id)).ToList();
if (policies.Count != merge.SourcePolicyIds.Count)
{
var failure = new ValidationFailure("SourcePolicyIds", "Invalid Source Policy Ids");
context.AddFailure(failure);
}
}
private IQueryable <CommissionStatementEdit> GetCommissionStatementEditQuery(ScopeOptions scope)
{
var organisationQuery = ScopeQuery.GetOrganisationEntityQuery(_context, scope);
var query = from commissionStatement in GetCommissionStatementEntityQuery(scope)
select new CommissionStatementEdit()
{
Id = commissionStatement.Id,
CompanyId = commissionStatement.CompanyId,
AmountIncludingVAT = commissionStatement.AmountIncludingVAT,
VAT = commissionStatement.VAT,
Date = commissionStatement.Date,
Processed = commissionStatement.Processed,
Notes = commissionStatement.Notes,
};
return(query);
}
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 PolicyAggregates(IExportRenderer <ClientPolicyAggregate> renderer, Stream stream, ScopeOptions scope)
{
var query = from client in ScopeQuery.GetClientEntityQuery(_context, scope)
select new ClientPolicyAggregate()
{
IdNumber = client.IdNumber,
FirstName = client.FirstName,
LastName = client.LastName,
Email = client.ClientContacts.Where(c => c.ContactTypeId == ContactType.CONTACT_TYPE_EMAIL).Select(c => c.Value).FirstOrDefault(),
PolicyInvestmentCount = client.ClientPolicies.Count(p => p.PolicyTypeId == PolicyType.POLICY_TYPE_INVESTMENT),
PolicyLifeInsuranceCount = client.ClientPolicies.Count(p => p.PolicyTypeId == PolicyType.POLICY_TYPE_LIFE_INSURANCE),
PolicyMedicalCoverCount = client.ClientPolicies.Count(p => p.PolicyTypeId == PolicyType.POLICY_TYPE_MEDICAL_COVER),
PolicyShortTermCount = client.ClientPolicies.Count(p => p.PolicyTypeId == PolicyType.POLICY_TYPE_SHORT_TERM),
};
var items = await query.ToListAsync();
await renderer.Render(stream, items);
}
public static IRuleBuilderOptions <T, Guid?> ClientMustBeInScope <T>(this IRuleBuilder <T, Guid?> ruleBuilder, DataContext dataContext, ScopeOptions scope)
{
return(ruleBuilder.MustAsync(async(root, clientId, context) =>
{
if (!clientId.HasValue)
{
return false;
}
return await ScopeQuery.IsClientInOrganisation(dataContext, scope, clientId.Value);
})
.WithMessage((root, clientId) =>
{
if (!clientId.HasValue)
{
return NOT_EMPTY_MESSAGE;
}
return DOESNT_EXIST_MESSAGE;
})
.WithName("Client"));
}
public static IRuleBuilderOptions <T, Guid?> BranchMustBeInScope <T>(this IRuleBuilder <T, Guid?> ruleBuilder, DataContext dataContext, ScopeOptions scope)
{
return(ruleBuilder.MustAsync(async(root, branchId, context) =>
{
if (!branchId.HasValue)
{
return false;
}
var branch = await ScopeQuery.GetBranchEntityQuery(dataContext, scope).FirstOrDefaultAsync(b => b.Id == branchId);
return branch != null;
})
.WithMessage((root, branchId) =>
{
if (!branchId.HasValue)
{
return NOT_EMPTY_MESSAGE;
}
return DOESNT_EXIST_MESSAGE;
})
.WithName("Branch"));
}
public async Task <Result> UpdateUser(ScopeOptions scope, UserEdit user)
{
var validator = new UserValidator(_context, scope, false);
var result = validator.Validate(user).GetResult();
if (!result.Success)
{
return(result);
}
var entity = await ScopeQuery.GetUserEntityQuery(_context, scope).FirstOrDefaultAsync(m => m.Id == user.Id);
if (entity == null)
{
return(new Result());
}
var userEntity = MapModelToEntity(user, entity);
var updateResult = await _userManager.UpdateAsync(entity);
result.Success = updateResult.Succeeded;
if (!result.Success)
{
result.ValidationFailures = updateResult.Errors.Select(e => new ValidationFailure("", e.Description)).ToList();
return(result);
}
await UpdateRoles(entity, user.Roles);
await UpdateIsLocked(entity, user.IsLocked);
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "User", entity.Id, user);
return(result);
}
public async Task <Result> UpdateBranch(ScopeOptions scope, Branch branch)
{
var validator = new BranchValidator(_context, scope, false);
var result = validator.Validate(branch).GetResult();
if (!result.Success)
{
return(result);
}
var entity = await ScopeQuery.GetBranchEntityQuery(_context, scope).FirstOrDefaultAsync(b => b.Id == branch.Id);
if (entity == null)
{
return(new Result());
}
entity = MapModelToEntity(branch, entity);
await _context.SaveChangesAsync();
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "Branch", entity.Id, branch);
return(result);
}
