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