public async Task <IActionResult> AddressSummary(CertificateAddressViewModel vm)
{
if (!ModelState.IsValid)
{
return(View("~/Views/Certificate/AddressSummary.cshtml", vm));
}
if (!string.IsNullOrEmpty(vm.Employer))
{
string nextRoute = "~/Views/Certificate/AddressSummary.cshtml";
var certificateAddressView =
await LoadViewModel <CertificateAddressViewModel>(nextRoute);
var viewResult = certificateAddressView as ViewResult;
var certificateAddressViewModel = viewResult.Model as CertificateAddressViewModel;
certificateAddressViewModel.Employer = vm.Employer;
if (vm.BackToCheckPage)
{
return(await SaveViewModel(certificateAddressViewModel,
returnToIfModelNotValid : "~/Views/Certificate/AddressSummary.cshtml",
nextAction : RedirectToAction("Check", "CertificateCheck"), action : CertificateActions.AddressSummary));
}
else
{
return(await SaveViewModel(certificateAddressViewModel,
returnToIfModelNotValid : "~/Views/Certificate/AddressSummary.cshtml",
nextAction : RedirectToAction("Recipient", "CertificateRecipient"), action : CertificateActions.AddressSummary));
}
}
return(RedirectToAction("Recipient", "CertificateRecipient"));
}
public async Task <IActionResult> Address(CertificateAddressViewModel vm)
{
var username = _contextAccessor.HttpContext.User
.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn")?.Value;
if (vm.SelectPreviousAddress)
{
var certificatePreviousAddress = await _certificateApiClient.GetContactPreviousAddress(username, vm.IsPrivatelyFunded);
vm = vm.CopyFromCertificateAddress(certificatePreviousAddress);
}
if (!ModelState.IsValid)
{
vm = await InitialisePreviousAddresssesForViewModel(vm, username);
}
if (vm.SelectPreviousAddress)
{
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/Certificate/Address.cshtml",
nextAction : RedirectToAction("Recipient", "CertificateRecipient"),
action : CertificateActions.Address));
}
else
{
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/Certificate/Address.cshtml",
nextAction : RedirectToAction("AddressSummary", "CertificateAddressSummary"),
action : CertificateActions.Address));
}
}
public async Task <IActionResult> Address(CertificateAddressViewModel vm)
{
var certData = await GetCertificateData(vm.Id);
if (ModelState.IsValid && vm.AddressHasChanged(certData))
{
// when address has been changed the complete journey is required
SessionService.SetRedirectToCheck(false);
}
if (vm.SendTo == CertificateSendTo.Apprentice)
{
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/Certificate/Address.cshtml",
nextAction : RedirectToAction("ConfirmAddress", "CertificateAddress"),
action : CertificateActions.Address));
}
else
{
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/Certificate/Address.cshtml",
nextAction : RedirectToAction("Recipient", "CertificateAddress"),
action : CertificateActions.Address));
}
}
public void When_PostcodeIsNullOrEmpty_Then_ValidatorReturnsInvalid(CertificateSendTo sendTo, string postcode)
{
_viewModel = CreateValidViewModel(sendTo);
_viewModel.Postcode = postcode;
_validator.ShouldHaveValidationErrorFor(vm => vm.Postcode, _viewModel);
}
public void When_CityIsNullOrEmpty_Then_ValidatorReturnsInvalid(CertificateSendTo sendTo, string city)
{
_viewModel = CreateValidViewModel(sendTo);
_viewModel.City = city;
_validator.ShouldHaveValidationErrorFor(vm => vm.City, _viewModel);
}
public void When_AddressLine1IsNullOrEmpty_Then_ValidatorReturnsInvalid(CertificateSendTo sendTo, string addressLine1)
{
_viewModel = CreateValidViewModel(sendTo);
_viewModel.AddressLine1 = addressLine1;
_validator.ShouldHaveValidationErrorFor(vm => vm.AddressLine1, _viewModel);
}
public void When_SendToIsEmployerAndEmployerIsNullOrEmpty_Then_ValidatorReturnsInvalid(string employer)
{
_viewModel = CreateValidViewModel(CertificateSendTo.Employer);
_viewModel.Employer = employer;
_validator.ShouldHaveValidationErrorFor(vm => vm.Employer, _viewModel);
}
public void When_AllFieldsAreCorrect_Then_ValidatorReturnsValid(CertificateSendTo sendTo)
{
_viewModel = CreateValidViewModel(sendTo);
var result = _validator.Validate(_viewModel);
result.IsValid.Should().Be(true);
}
public void Arrange()
{
var certificateAddressController = new CertificateAddressController(MockedLogger.Object, MockHttpContextAccessor.Object, ApiClient);
_result = certificateAddressController.Address(Certificate.Id).GetAwaiter().GetResult();
var result = _result as ViewResult;
_viewModelResponse = result.Model as CertificateAddressViewModel;
}
public async Task AndPostingAddressForSendToEmployer_RedirectsToRecipient(CertificateAddressViewModel vm)
{
vm.SendTo = CertificateSendTo.Employer;
vm.Id = CertificateIdWithPreviousAddress;
var result = await _certificateAddressController.Address(vm) as RedirectToActionResult;
result.ControllerName.Should().Be("CertificateAddress");
result.ActionName.Should().Be("Recipient");
}
public async Task AndPostingModelErrorToAddress_LoadsAddressView(CertificateAddressViewModel vm)
{
vm.Id = CertificateIdWithPreviousAddress;
_certificateAddressController.ModelState.AddModelError("Key", "Message");
var result = await _certificateAddressController.Address(vm) as ViewResult;
result.ViewName.Should().Be("~/Views/Certificate/Address.cshtml");
result.Model.Should().BeOfType <CertificateAddressViewModel>();
}
public void Arange()
{
_mockStringLocalizer = new Mock <IStringLocalizer <CertificateAddressViewModelValidator> >();
_mockStringLocalizer.Setup(l => l["EmployerCannotBeEmpty"]).Returns(new LocalizedString("Employer", _employerError));
_mockStringLocalizer.Setup(l => l["AddressLine1CannotBeEmpty"]).Returns(new LocalizedString("Address", _addressLine1Error));
_mockStringLocalizer.Setup(l => l["CityCannotBeEmpty"]).Returns(new LocalizedString("City", _cityError));
_mockStringLocalizer.Setup(l => l["PostcodeCannotBeEmpty"]).Returns(new LocalizedString("Postcode", _postcodeError));
_mockStringLocalizer.Setup(l => l["PostcodeValid"]).Returns(new LocalizedString("Postcode", _postcodeValidError));
_viewModel = CreateValidViewModel(CertificateSendTo.Apprentice);
_validator = new CertificateAddressViewModelValidator(_mockStringLocalizer.Object);
}
private async Task InitialisePreviousAddresses(string username, CertificateAddressViewModel certificateAddress)
{
try
{
var certificatePreviousAddress = await _certificateApiClient.GetContactPreviousAddress(username,
certificateAddress.IsPrivatelyFunded);
certificateAddress.PreviousAddress =
new CertificatePreviousAddressViewModel(certificatePreviousAddress);
}
catch (EntityNotFoundException)
{
var certificatePreviousAddress = new CertificateAddress();
certificateAddress.PreviousAddress =
new CertificatePreviousAddressViewModel(certificatePreviousAddress);
}
}
public async Task <IActionResult> Address(CertificateAddressViewModel vm)
{
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/CertificateAmend/Address.cshtml",
nextAction : RedirectToAction("Check", "CertificateAmend", new { certificateId = vm.Id }), action : CertificateActions.Address));
}
public async Task AndPostingDifferentAddressForSendToEmployer_RedirectsToRecipient_IfRedirectToCheckSet(CertificateSession session, CertificateAddressViewModel vm)
{
vm.SendTo = CertificateSendTo.Employer;
vm.Id = CertificateIdWithPreviousAddress;
vm.Employer = vm.Employer + "_Different";
var sessionString = JsonConvert.SerializeObject(session);
_mockSessionService.Setup(s => s.Get(nameof(CertificateSession))).Returns(sessionString);
var redirectToCheck = true;
_mockSessionService.Setup(s => s.TryGet <bool>("RedirectToCheck", out redirectToCheck)).Returns(true);
_mockSessionService.Setup(s => s.Set("RedirectToCheck", It.IsAny <object>())).Callback((string key, object value) => {
redirectToCheck = (bool)value;
_mockSessionService.Setup(s => s.TryGet <bool>("RedirectToCheck", out redirectToCheck)).Returns(true);
});
var result = await _certificateAddressController.Address(vm) as RedirectToActionResult;
result.ControllerName.Should().Be("CertificateAddress");
result.ActionName.Should().Be("Recipient");
}
public async Task AndPostingSameAddressForSendToEmployer_ReturnsToCheck_IfRedirectToCheckSet(CertificateSession session, CertificateAddressViewModel vm)
{
vm.SendTo = CertificateSendTo.Employer;
vm.Id = CertificateIdWithPreviousAddress;
var sessionString = JsonConvert.SerializeObject(session);
_mockSessionService.Setup(s => s.Get(nameof(CertificateSession))).Returns(sessionString);
var expectedValue = true;
_mockSessionService.Setup(s => s.TryGet <bool>("RedirectToCheck", out expectedValue)).Returns(true);
var result = await _certificateAddressController.Address(vm) as RedirectToActionResult;
result.ControllerName.Should().Be("CertificateCheck");
result.ActionName.Should().Be("Check");
}
public async Task AndPostingAddressForSendToApprentice_RedirectsToConfirmAddress(CertificateAddressViewModel vm)
{
vm.SendTo = CertificateSendTo.Apprentice;
vm.Id = CertificateIdWithPreviousAddress;
var result = await _certificateAddressController.Address(vm) as RedirectToActionResult;
result.ControllerName.Should().Be("CertificateAddress");
result.ActionName.Should().Be("ConfirmAddress");
}
private async Task <CertificateAddressViewModel> InitialisePreviousAddresssesForViewModel(CertificateAddressViewModel certificateAddressViewModel,
string username)
{
await InitialisePreviousAddresses(username, certificateAddressViewModel);
return(certificateAddressViewModel);
}
