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 async Task Get()
{
var policy = new PolicyEdit()
{
Id = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
Number = "123456",
StartDate = DateTime.Now,
Premium = 500,
PolicyTypeId = Guid.NewGuid()
};
var service = new Mock <IPolicyService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
service.Setup(c => c.GetPolicy(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == policy.Id.Value)))
.ReturnsAsync(policy);
var controller = new PoliciesController(service.Object, authService.Object);
var result = await controller.Get(policy.Id.Value);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PolicyEdit>(okResult.Value);
Assert.Same(policy, returnValue);
}
public async Task <ActionResult> Delete(
[Bind(Include = "Id,UpdateDate,ObjectType,ObjectName,NameOwner,SurnameOwner")]
PolicyEdit deletedPolicy)
{
var result = await _client.DeleteAsync("api/PolicyAPI/" + deletedPolicy.Id);
switch (result.StatusCode)
{
case HttpStatusCode.Conflict:
var fullPolicy = await BindWithUnmodified(deletedPolicy);
if (fullPolicy == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ModelState.AddModelError(string.Empty, "The record you attempted to delete "
+ "was modified by another user");
return(View(fullPolicy));
case HttpStatusCode.BadRequest:
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
default:
return(RedirectToAction("Index"));
}
}
public async Task <ActionResult> Edit(
[Bind(Include = "Id,UpdateDate,ObjectType,ObjectName,NameOwner,SurnameOwner")]
PolicyEdit editPolicy)
{
var fullPolicy = await BindWithUnmodified(editPolicy);
if (fullPolicy == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
var result = await _client.PostAsync("api/PolicyAPI"
, Serializer.ToStringContent(fullPolicy));
if (result.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
if (result.StatusCode == HttpStatusCode.Conflict)
{
ModelState.AddModelError(string.Empty, "The record you attempted to delete "
+ "was modified by another user");
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
return(View(fullPolicy));
}
public async Task InsertPolicy()
{
var options = TestHelper.GetDbContext("InsertPolicy");
var user1 = TestHelper.InsertUserDetailed(options);
var client1 = TestHelper.InsertClient(options, user1.Organisation);
var user2 = TestHelper.InsertUserDetailed(options);
//Given
var policy1 = new PolicyEdit
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
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,
};
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new PolicyService(context, auditService);
//When
var scopeOptions = TestHelper.GetScopeOptions(user1);
var result = await service.InsertPolicy(scopeOptions, policy1);
//Then
Assert.True(result.Success);
var actual = await context.Policy.FindAsync(((PolicyEdit)result.Tag).Id);
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);
//Out of scope
scopeOptions = TestHelper.GetScopeOptions(user2);
result = await service.InsertPolicy(scopeOptions, policy1);
Assert.False(result.Success);
Assert.Equal("'User' does not exist.", result.ValidationFailures.First().ErrorMessage);
}
}
private PolicyEdit MapPolicyProperties(PolicyEdit policy, ImportClient data, Guid userId, List <PolicyType> policyTypes)
{
policy.UserId = userId;
policy.Premium = data.PolicyPremium != null ? data.PolicyPremium : policy.Premium;
policy.StartDate = data.PolicyStartDate != null ? data.PolicyStartDate : policy.StartDate;
policy.PolicyTypeId = GetPolicyTypeId(data.PolicyTypeCode, policyTypes);
return(policy);
}
public async Task <IActionResult> Insert([FromBody] PolicyEdit policy)
{
var scope = AuthenticationService.GetScope(User);
var result = await PolicyService.InsertPolicy(scope, policy);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
return(Ok(result));
}
public async Task <IActionResult> Update(Guid policyId, [FromBody] PolicyEdit policy)
{
policy.Id = policyId;
var scope = AuthenticationService.GetScope(User);
var result = await PolicyService.UpdatePolicy(scope, policy);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
return(Ok(result));
}
private async Task <PolicyDtoCreated> BindWithUnmodified(PolicyEdit editData)
{
var result = await _client.GetAsync("api/PolicyAPI/" + editData.Id);
if (result.IsSuccessStatusCode)
{
var policy = await result.Content
.ReadAsAsync <PolicyDtoCreated>();
if (policy != null)
{
return(editData.Convert(policy));
}
}
return(null);
}
public async Task Insert()
{
var policy = new PolicyEdit()
{
Id = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
Number = "123456",
StartDate = DateTime.Now,
Premium = 500,
PolicyTypeId = Guid.NewGuid()
};
var service = new Mock <IPolicyService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
PolicyEdit inserted = null;
service.Setup(c => c.InsertPolicy(It.IsAny <ScopeOptions>(), It.Is <PolicyEdit>(m => m == policy)))
.Callback((ScopeOptions o, PolicyEdit i) =>
{
inserted = i;
options = o;
})
.ReturnsAsync(result);
var controller = new PoliciesController(service.Object, authService.Object);
var actual = await controller.Insert(policy);
Assert.Same(policy, inserted);
Assert.Equal(Scope.Branch, options.Scope);
var okResult = Assert.IsType <OkObjectResult>(actual);
var returnValue = Assert.IsType <Result>(okResult.Value);
Assert.Same(result, returnValue);
}
public async Task MergePolicies()
{
var policy = new PolicyEdit()
{
Id = Guid.NewGuid(),
};
var merge = new MergePolicies()
{
TargetPolicy = policy,
SourcePolicyIds = new List <Guid>()
{
Guid.NewGuid(), Guid.NewGuid()
}
};
var service = new Mock <IPolicyService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
MergePolicies merged = null;
service.Setup(c => c.MergePolicies(It.IsAny <ScopeOptions>(), It.Is <MergePolicies>(m => m == merge)))
.Callback((ScopeOptions o, MergePolicies m) =>
{
merged = m;
options = o;
})
.ReturnsAsync(result);
var controller = new MergeController(null, service.Object, authService.Object);
var actual = await controller.MergePolicies(merge);
Assert.Same(merge, merged);
Assert.Equal(Scope.Branch, options.Scope);
var okResult = Assert.IsType <OkObjectResult>(actual);
var returnValue = Assert.IsType <Result>(okResult.Value);
Assert.Same(result, returnValue);
}
private async Task <Result> ImportPolicy(ScopeOptions scope, ImportClient data, ClientEdit client, Guid userId, List <PolicyType> policyTypes)
{
var result = new Result(true);
if (string.IsNullOrWhiteSpace(data.PolicyNumber))
{
return(result);
}
var policy = await _policyService.GetPolicy(scope, client.Id.Value, data.PolicyCompanyId.Value, data.PolicyNumber);
//Policy exits, update
if (policy != null)
{
policy = MapPolicyProperties(policy, data, userId, policyTypes);
result = await _policyService.UpdatePolicy(scope, policy);
if (!result.Success)
{
return(result);
}
}
else //else insert
{
policy = new PolicyEdit()
{
ClientId = client.Id,
CompanyId = data.PolicyCompanyId.Value,
Number = data.PolicyNumber
};
policy = MapPolicyProperties(policy, data, userId, policyTypes);
result = await _policyService.InsertPolicy(scope, policy);
if (!result.Success)
{
return(result);
}
}
return(result);
}
private PolicyEntity MapModelToEntity(PolicyEdit model, PolicyEntity entity = null)
{
if (entity == null)
{
entity = new PolicyEntity();
}
entity.ClientId = model.ClientId.Value;
entity.Number = model.Number.TrimWhiteSpace();;
entity.CompanyId = model.CompanyId.Value;
entity.UserId = model.UserId.Value;
entity.StartDate = model.StartDate;
entity.Premium = model.Premium;
entity.PolicyTypeId = model.PolicyTypeId;
entity.PolicyProductTypeId = model.PolicyProductTypeId;
entity.PolicyProductId = model.PolicyProductId;
entity.IsActive = model.IsActive;
entity.NumberAliases = model.NumberAliases;
return(entity);
}
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);
}
