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); }