[InlineData("88888")] // will match multiple providers
public async Task PostSelectTrainingProviderAsync_TrainingProviderSearch_WhenNoSingleProviderFoundShouldNotReturnFoundProvider(string trainingProviderSearch)
{
var fixture = new TrainingProviderOrchestratorTestsFixture();
fixture
.WithVacacny(
new Vacancy
{
Id = fixture.VacancyId,
EmployerAccountId = TrainingProviderOrchestratorTestsFixture.EmployerAccountId,
TrainingProvider = new TrainingProvider(),
Title = "specified for route validation",
ProgrammeId = "specified for route validation"
})
.Setup();
var selectTrainingProviderEditModel = new SelectTrainingProviderEditModel
{
EmployerAccountId = TrainingProviderOrchestratorTestsFixture.EmployerAccountId,
VacancyId = fixture.Vacancy.Id,
SelectionType = TrainingProviderSelectionType.TrainingProviderSearch,
TrainingProviderSearch = trainingProviderSearch
};
var result = await fixture.PostSelectTrainingProviderAsync(selectTrainingProviderEditModel);
fixture.VerifyNotFoundTrainingProviderUkprn(result);
}
public async Task PostSelectTrainingProviderAsync_UKPRN_WhenSingleProviderFoundShouldReturnFoundProvider()
{
var fixture = new TrainingProviderOrchestratorTestsFixture();
fixture
.WithVacacny(
new Vacancy
{
Id = fixture.VacancyId,
EmployerAccountId = TrainingProviderOrchestratorTestsFixture.EmployerAccountId,
TrainingProvider = new TrainingProvider(),
Title = "specified for route validation",
ProgrammeId = "specified for route validation"
})
.Setup();
var selectTrainingProviderEditModel = new SelectTrainingProviderEditModel
{
EmployerAccountId = TrainingProviderOrchestratorTestsFixture.EmployerAccountId,
VacancyId = fixture.Vacancy.Id,
SelectionType = TrainingProviderSelectionType.Ukprn,
Ukprn = fixture.TrainingProviderOne.Ukprn.ToString()
};
var result = await fixture.PostSelectTrainingProviderAsync(selectTrainingProviderEditModel);
fixture.VerifyFoundTrainingProviderUkprn(result, fixture.TrainingProviderOne.Ukprn.Value);
}
public async Task <IActionResult> ConfirmTrainingProvider(ConfirmTrainingProviderEditModel m)
{
if (!ModelState.IsValid)
{
return(View(m));
}
var providerExists = await _orchestrator.ConfirmProviderExists(long.Parse(m.Ukprn));
if (providerExists == false)
{
var vm = new SelectTrainingProviderEditModel {
VacancyId = m.VacancyId, Ukprn = m.Ukprn
};
return(await ProviderNotFound(vm));
}
var response = await _orchestrator.PostConfirmEditModelAsync(m, User.ToVacancyUser());
if (!response.Success)
{
response.AddErrorsToModelState(ModelState);
}
if (!ModelState.IsValid)
{
var vm = await _orchestrator.GetSelectTrainingProviderViewModel(m);
return(View(ViewNames.SelectTrainingProvider, vm));
}
return(RedirectToRoute(RouteNames.Vacancy_Preview_Get));
}
public async Task PostSelectTrainingProviderAsync_TrainingProviderSearch_WhenSingleProviderFoundShouldReturnFoundProvider()
{
var vacancy = new Vacancy
{
Id = VacancyId,
EmployerAccountId = EmployerAccountId,
TrainingProvider = new TrainingProvider(),
Title = "specified for route validation",
ProgrammeId = "specified for route validation"
};
var orch = GetTrainingProviderOrchestrator(vacancy);
var m = new SelectTrainingProviderEditModel
{
IsTrainingProviderSelected = true,
SelectionType = TrainingProviderSelectionType.TrainingProviderSearch,
TrainingProviderSearch = "MR EGG 88888888",
EmployerAccountId = EmployerAccountId,
VacancyId = VacancyId
};
var result = await orch.PostSelectTrainingProviderAsync(m, new VacancyUser());
result.Data.FoundTrainingProviderUkprn.Should().Be(88888888);
}
public async Task <ConfirmTrainingProviderViewModel> GetConfirmViewModel(SelectTrainingProviderEditModel m)
{
var vacancy = await Utility.GetAuthorisedVacancyForEditAsync(_client, _vacancyClient, m, RouteNames.TrainingProvider_Confirm_Get);
if (long.TryParse(m.Ukprn, out var ukprn) && ukprn != vacancy.TrainingProvider?.Ukprn)
{
var provider = await _client.GetTrainingProviderAsync(ukprn);
return(new ConfirmTrainingProviderViewModel
{
EmployerAccountId = m.EmployerAccountId,
VacancyId = m.VacancyId,
Title = vacancy.Title,
Ukprn = provider.Ukprn.Value,
ProviderName = provider.Name,
ProviderAddress = provider.Address.GetInlineAddress()
});
}
return(new ConfirmTrainingProviderViewModel
{
EmployerAccountId = m.EmployerAccountId,
VacancyId = m.VacancyId,
Title = vacancy.Title,
Ukprn = vacancy.TrainingProvider.Ukprn.Value,
ProviderName = vacancy.TrainingProvider.Name,
ProviderAddress = vacancy.TrainingProvider.Address.GetInlineAddress()
});
}
private async Task <IActionResult> ProviderNotFound(SelectTrainingProviderEditModel m)
{
ModelState.AddModelError(string.Empty, string.Format(InvalidUkprnMessageFormat, m.Ukprn));
var vm = await _orchestrator.GetSelectTrainingProviderViewModel(m);
return(View(ViewNames.SelectTrainingProvider, vm));
}
public async Task <IActionResult> SelectTrainingProvider(SelectTrainingProviderEditModel m)
{
if (!ModelState.IsValid)
{
var vm = await _orchestrator.GetSelectTrainingProviderViewModel(m);
return(View(vm));
}
if (long.TryParse(m.Ukprn, out var ukprnAsLong) == false)
{
return(await ProviderNotFound(m));
}
var providerExists = await _orchestrator.ConfirmProviderExists(ukprnAsLong);
if (providerExists == false)
{
return(await ProviderNotFound(m));
}
var confirmDetailsVm = await _orchestrator.GetConfirmViewModel(m);
TempData.Add(TrainingProviderJourneyTempDataKey, 1);
return(RedirectToRoute(RouteNames.TrainingProvider_Confirm_Get, confirmDetailsVm));
}
public async Task PostSelectTrainingProviderAsync_WhenNotChoosingThenRemoveExistingTrainingProvider()
{
var vacancy = new Vacancy
{
Id = VacancyId,
EmployerAccountId = EmployerAccountId,
TrainingProvider = new TrainingProvider(),
Title = "specified for route validation",
ProgrammeId = "specified for route validation"
};
var orch = GetTrainingProviderOrchestrator(vacancy);
var m = new SelectTrainingProviderEditModel
{
IsTrainingProviderSelected = false,
EmployerAccountId = EmployerAccountId,
VacancyId = VacancyId
};
var result = await orch.PostSelectTrainingProviderAsync(m, new VacancyUser());
vacancy.TrainingProvider.Should().BeNull();
result.Data.FoundTrainingProviderUkprn.Should().BeNull();
}
public void ShouldBeValidIfTrainingProviderSearchSpecified()
{
var vm = new SelectTrainingProviderEditModel {
TrainingProviderSearch = "something specified",
SelectionType = TrainingProviderSelectionType.TrainingProviderSearch
};
var validator = new SelectTrainingProviderEditModelValidator();
var result = validator.Validate(vm);
result.IsValid.Should().BeTrue();
}
public void ShouldBeValidIfUkprnSpecified()
{
var vm = new SelectTrainingProviderEditModel {
Ukprn = "12345678",
SelectionType = TrainingProviderSelectionType.Ukprn
};
var validator = new SelectTrainingProviderEditModelValidator();
var result = validator.Validate(vm);
result.IsValid.Should().BeTrue();
}
private async Task <TrainingProviderSummary> GetProviderFromModelAsync(SelectTrainingProviderEditModel model)
{
if (model.SelectionType == TrainingProviderSelectionType.TrainingProviderSearch)
{
var allProviders = await _vacancyClient.GetAllTrainingProvidersAsync();
var matches = allProviders.Where(p =>
FormatSuggestion(p.ProviderName, p.Ukprn).Contains(model.TrainingProviderSearch))
.ToList();
return(matches.Count() == 1 ? matches.First() : null);
}
return(await GetProviderAsync(model.Ukprn));
}
public void ShouldErrorIfUkprnIsNotSpecified(string inputUkprn)
{
var vm = new SelectTrainingProviderEditModel {
Ukprn = inputUkprn,
SelectionType = TrainingProviderSelectionType.Ukprn
};
var validator = new SelectTrainingProviderEditModelValidator();
var result = validator.Validate(vm);
result.IsValid.Should().BeFalse();
result.Errors.Count.Should().Be(1);
result.Errors[0].PropertyName.Should().Be(nameof(SelectTrainingProviderEditModel.Ukprn));
result.Errors[0].ErrorMessage.Should().Be("You must provide a UKPRN");
}
public void ShouldErrorIfUkprnIsNotSpecified(string inputUkprn)
{
var vm = new SelectTrainingProviderEditModel
{
Ukprn = inputUkprn
};
var context = new ValidationContext(vm, null, null);
var result = new List <ValidationResult>();
var isValid = Validator.TryValidateObject(vm, context, result, true);
isValid.Should().BeFalse();
result.Should().HaveCount(1);
result.Single(r => r.MemberNames.Single() == "Ukprn").ErrorMessage.Should().Be("The UKPRN field is required.");
}
public void ShouldErrorIfTrainingProviderSearchIsNotSpecified(string inputUkprn)
{
var vm = new SelectTrainingProviderEditModel {
TrainingProviderSearch = inputUkprn,
SelectionType = TrainingProviderSelectionType.TrainingProviderSearch
};
var validator = new SelectTrainingProviderEditModelValidator();
var result = validator.Validate(vm);
result.IsValid.Should().BeFalse();
result.Errors.Count.Should().Be(1);
result.Errors[0].PropertyName.Should().Be(nameof(SelectTrainingProviderEditModel.TrainingProviderSearch));
result.Errors[0].ErrorMessage.Should().Be("You must enter a training provider or UKPRN to continue");
}
public void ShouldErrorIfUkprnIsInvalid()
{
var vm = new SelectTrainingProviderEditModel {
Ukprn = "invalid ukprn",
SelectionType = TrainingProviderSelectionType.Ukprn
};
var validator = new SelectTrainingProviderEditModelValidator();
var result = validator.Validate(vm);
result.IsValid.Should().BeFalse();
result.Errors.Count.Should().Be(1);
result.Errors[0].PropertyName.Should().Be(nameof(SelectTrainingProviderEditModel.Ukprn));
result.Errors[0].ErrorMessage.Should().Be("UKPRN is not recognised");
}
public void ShouldErrorIfSelectTrainingProviderNotSpecified()
{
var vm = new SelectTrainingProviderEditModel
{
IsTrainingProviderSelected = null,
};
var validator = new SelectTrainingProviderEditModelValidator();
var result = validator.Validate(vm);
result.IsValid.Should().BeFalse();
result.Errors.Count.Should().Be(1);
result.Errors[0].PropertyName.Should().Be(nameof(SelectTrainingProviderEditModel.IsTrainingProviderSelected));
result.Errors[0].ErrorMessage.Should().Be("Select yes if you’ve found a training provider");
}
public void ShouldErrorIfSelectTrainingProviderNotSpecified()
{
var vm = new SelectTrainingProviderEditModel
{
IsTrainingProviderSelected = null,
};
var validator = new SelectTrainingProviderEditModelValidator();
var result = validator.Validate(vm);
result.IsValid.Should().BeFalse();
result.Errors.Count.Should().Be(1);
result.Errors[0].PropertyName.Should().Be(nameof(SelectTrainingProviderEditModel.IsTrainingProviderSelected));
result.Errors[0].ErrorMessage.Should().Be("Please select an option to continue");
}
private async Task <TrainingProviderSummary> GetProviderFromModelAsync(SelectTrainingProviderEditModel model)
{
if (model.SelectionType == TrainingProviderSelectionType.TrainingProviderSearch)
{
if (model.TrainingProviderSearch.EndsWith(EsfaTestTrainingProvider.Ukprn.ToString()))
{
return(await GetProviderAsync(EsfaTestTrainingProvider.Ukprn.ToString()));
}
var allProviders = await _trainingProviderSummaryProvider.FindAllAsync();
var matches = allProviders.Where(p =>
FormatSuggestion(p.ProviderName, p.Ukprn).Contains(model.TrainingProviderSearch))
.ToList();
return(matches.Count() == 1 ? matches.First() : null);
}
return(await GetProviderAsync(model.Ukprn));
}
public async Task <IActionResult> SelectTrainingProvider(SelectTrainingProviderEditModel m, [FromQuery] bool wizard)
{
if (ModelState.IsValid)
{
var response = await _orchestrator.PostSelectTrainingProviderAsync(m, User.ToVacancyUser());
if (response.Success)
{
return(response.Data.FoundTrainingProviderUkprn.HasValue
? RedirectToRoute(RouteNames.TrainingProvider_Confirm_Get, new { ukprn = response.Data.FoundTrainingProviderUkprn.Value, wizard })
: GetRedirectToNextPage(wizard));
}
AddTrainingProviderErrorsToModelState(m.SelectionType, m.Ukprn, response, ModelState);
}
var vm = await _orchestrator.GetSelectTrainingProviderViewModelAsync(m);
vm.PageInfo.SetWizard(wizard);
return(View(vm));
}
public async Task <OrchestratorResponse <PostSelectTrainingProviderResult> > PostSelectTrainingProviderAsync(SelectTrainingProviderEditModel m, VacancyUser user)
{
var vacancy = await Utility.GetAuthorisedVacancyForEditAsync(_client, _vacancyClient, m, RouteNames.TrainingProvider_Select_Post);
if (m.IsTrainingProviderSelected == false)
{
if (vacancy.TrainingProvider != null)
{
vacancy.TrainingProvider = null;
await _vacancyClient.UpdateDraftVacancyAsync(vacancy, user);
}
return(new OrchestratorResponse <PostSelectTrainingProviderResult>(new PostSelectTrainingProviderResult()));
}
var providerSummary = await GetProviderFromModelAsync(m);
TrainingProvider provider = null;
if (providerSummary != null)
{
provider = await _trainingProviderService.GetProviderAsync(providerSummary.Ukprn);
}
vacancy.TrainingProvider = provider;
return(await ValidateAndExecute(
vacancy,
v => _vacancyClient.Validate(v, ValidationRules),
v => Task.FromResult(new PostSelectTrainingProviderResult
{
FoundTrainingProviderUkprn = v.TrainingProvider?.Ukprn
})
));
}
public async Task <SelectTrainingProviderViewModel> GetSelectTrainingProviderViewModelAsync(SelectTrainingProviderEditModel m)
{
var vm = await GetSelectTrainingProviderViewModelAsync((VacancyRouteModel)m);
vm.Ukprn = m.Ukprn;
vm.TrainingProviderSearch = m.TrainingProviderSearch;
return(vm);
}
public async Task <OrchestratorResponse <PostSelectTrainingProviderResult> > PostSelectTrainingProviderAsync(SelectTrainingProviderEditModel model)
{
return(await Sut.PostSelectTrainingProviderAsync(model, User));
}
