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