public async Task <Result> UpdatePolicy(ScopeOptions scope, PolicyEdit policy)
{
var validator = new PolicyValidator(_context, scope, false);
var result = validator.Validate(policy, ruleSet: "default,availability").GetResult();
if (!result.Success)
{
return(result);
}
var entity = await GetPolicyEntityQuery(scope).FirstOrDefaultAsync(p => p.Id == policy.Id);
if (entity == null)
{
return(new Result());
}
var clientEntity = MapModelToEntity(policy, entity);
await _context.SaveChangesAsync();
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "Policy", entity.Id, policy);
return(result);
}
public void TestForeignKeyConstraintIsValidated()
{
// Arrange
var assignments = new List <PolicyByUser>()
{
new PolicyByUser(),
new PolicyByUser(),
new PolicyByUser(),
};
// We define the data that will be returned by the repository
var mockRepository = new Mock <IPolicyByUserRepository>();
var mockICoverageTypeByPolicyRepository = new Mock <ICoverageTypeByPolicyRepository>();
mockRepository.Setup(x => x.GetPolicyAssignations(It.IsAny <int>())).Returns(assignments.AsQueryable());
var validator = new PolicyValidator(mockRepository.Object, mockICoverageTypeByPolicyRepository.Object);
var policy = new Policy();
// Act
var result = validator.Validate(policy, ruleSet: "delete");
// Assert
Assert.Contains(result.Errors, x => x.ErrorMessage == "The policy is already assigned to a user, please delete the relationship first");
}
public PolicyProcessor(PolicyMiner policyMiner, PolicyValidator policyValidator, PolicyMapper policyMapper, ResponseMapper responseMapper, PolicySender policySender)
{
_policyMiner = policyMiner;
_policyMapper = policyMapper;
_policyValidator = policyValidator;
_policySender = policySender;
_responseMapper = responseMapper;
}
public void Setup()
{
_policyTrue = new Policy
{
OwnerName = "Bob",
PolicyNumber = "4D"
};
_policyFalse = new Policy
{
OwnerName = "0",
PolicyNumber = "87"
};
_policyValidator = new PolicyValidator();
}
public static void Validate(ExcelWorksheet worksheet, List <Entity> list)
{
if (worksheet.Name == "Beneficiary")
{
var validator = new BeneficiaryValidator();
//validator.Validate(list);
}
if (worksheet.Name == "Policy")
{
var validator = new PolicyValidator();
}
if (worksheet.Name == "Claim")
{
var validator = new ClaimValidator();
}
//return validator;
}
public void TestNoErrorIsReturnedIfPorcentageIsBelowOrEquals50AndTheRiskIsHigh()
{
// Arrange
var mockRepository = new Mock <IPolicyByUserRepository>();
var mockICoverageTypeByPolicyRepository = new Mock <ICoverageTypeByPolicyRepository>();
var validator = new PolicyValidator(mockRepository.Object, mockICoverageTypeByPolicyRepository.Object);
var policy = new Policy()
{
Coverage = 50,
RiskTypeId = (int)DataAccess.Enums.RiskType.High
};
// Act
var result = validator.Validate(policy);
// Assert
Assert.DoesNotContain(result.Errors, x => x.ErrorMessage == "The coverage percentage can go above 50% because the risk is High");
}
public async Task <Result> InsertPolicy(ScopeOptions scope, PolicyEdit policy)
{
var validator = new PolicyValidator(_context, scope, true);
var result = validator.Validate(policy, ruleSet: "default,availability").GetResult();
if (!result.Success)
{
return(result);
}
var entity = MapModelToEntity(policy);
await _context.Policy.AddAsync(entity);
await _context.SaveChangesAsync();
policy.Id = entity.Id;
result.Tag = policy;
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_INSERT, "Policy", entity.Id, policy);
return(result);
}
/// <summary>
/// This method gets called by the runtime.
/// Configures HTTP request pipeline.
/// </summary>
/// <param name="app"></param>
/// <param name="config"></param>
/// <param name="actionDescriptorCollectionProvider"></param>
public static void Configure(
IApplicationBuilder app,
GlobalConfig config,
IActionDescriptorCollectionProvider actionDescriptorCollectionProvider)
{
app.UseDeveloperExceptionPage();
if (config.AddSwagger)
{
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Bookshelf API");
});
}
app.UseRouting();
// app.UseHttpsRedirection();
app.UseCors(builder => builder
.WithOrigins(new[] { "http://localhost:4200" })
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials()
);
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
PolicyValidator.ValidateEndpointsPolicies(actionDescriptorCollectionProvider);
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
var meta = AppUsers.GetCurrentAsync().GetAwaiter().GetResult();
string tenant = TenantConvention.GetTenant();
var policy = new PolicyValidator
{
ObjectNamespace = this.ObjectNamespace,
ObjectName = this.ObjectName,
LoginId = meta.LoginId,
Tenant = tenant,
AccessType = this.Type
};
policy.ValidateAsync().GetAwaiter().GetResult();
bool hasAccess = policy.HasAccess;
if (hasAccess)
{
return;
}
filterContext.Result = new HttpUnauthorizedResult(Resources.AccessIsDenied);
}
public void When_IsValid_Returns_IsValid(string input)
{
var isValid = PolicyValidator.IsValid2(input);
Assert.True(isValid);
}
public void When_NotValid_Returns_NotValid(string input)
{
var isValid = PolicyValidator.IsValid2(input);
Assert.False(isValid);
}
public async Task <Result> MergePolicies(ScopeOptions scope, MergePolicies merge)
{
var clientValidator = new PolicyValidator(_context, scope, true);
var result = clientValidator.Validate(merge.TargetPolicy, ruleSet: "default").GetResult();
if (!result.Success)
{
return(result);
}
var mergeValidator = new MergePoliciesValidator(_context, scope);
result = mergeValidator.Validate(merge).GetResult();
if (!result.Success)
{
return(result);
}
var strategy = _context.Database.CreateExecutionStrategy();
result = await strategy.ExecuteAsync <Result>(async() =>
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
//Insert the 'new' policy
var entity = MapModelToEntity(merge.TargetPolicy);
await _context.Policy.AddAsync(entity);
await _context.SaveChangesAsync();
merge.TargetPolicy.Id = entity.Id;
//Move dependancies to the new policy ----------------------------------------------------
//1. Commissions
var commmissions = await _context.Commission.Where(p => merge.SourcePolicyIds.Contains(p.PolicyId)).ToListAsync();
foreach (var commmission in commmissions)
{
commmission.PolicyId = merge.TargetPolicy.Id.Value;
}
//2. Commission Errors
var commissionErrors = await _context.CommissionError.Where(c => merge.SourcePolicyIds.Contains(c.PolicyId.Value)).ToListAsync();
foreach (var commissionError in commissionErrors)
{
commissionError.PolicyId = merge.TargetPolicy.Id.Value;
}
//3. Commission Split Rule Policies
var commissionSplitRulePolicies = await _context.CommissionSplitRulePolicy.Where(c => merge.SourcePolicyIds.Contains(c.PolicyId)).ToListAsync();
foreach (var commissionSplitRulePolicy in commissionSplitRulePolicies)
{
commissionSplitRulePolicy.PolicyId = merge.TargetPolicy.Id.Value;
}
//4. Commission Allocation Policies
var commissionAllocationPolicies = await _context.CommissionAllocationPolicy.Where(c => merge.SourcePolicyIds.Contains(c.PolicyId)).ToListAsync();
foreach (var commissionAllocationPolicy in commissionAllocationPolicies)
{
commissionAllocationPolicy.PolicyId = merge.TargetPolicy.Id.Value;
}
await _context.SaveChangesAsync();
//----------------------------------------------------------------------------------------
//Delete 'old' policies
var policiesToDelete = await _context.Policy.Where(m => merge.SourcePolicyIds.Contains(m.Id)).ToListAsync();
foreach (var policyToDelete in policiesToDelete)
{
_context.Remove(policyToDelete);
}
await _context.SaveChangesAsync();
//Commit
await transaction.CommitAsync();
return(new Result(true));
}
catch
{
transaction.Rollback();
return(new Result(false));
}
}
});
result.Tag = merge.TargetPolicy;
await _auditService.InsertAuditLog(scope, "Merge", "Policy", merge.TargetPolicy.Id, merge);
return(result);
}
public PoliciesController(PolicyService policyService)
{
_policyService = policyService;
_validations = new PolicyValidator();
}
