public async Task <IActionResult> ApproveJobAdvert(ApproveJobAdvertViewModel vm)
{
if (!ModelState.IsValid)
{
return(View("ApproveJobAdvert"));
}
if (vm.ApproveJobAdvert.GetValueOrDefault())
{
var response = await _orchestrator.ApproveJobAdvertAsync(vm, User.ToVacancyUser());
if (!response.Success)
{
response.AddErrorsToModelState(ModelState);
}
if (ModelState.IsValid)
{
if (response.Data.IsSubmitted)
{
return(RedirectToRoute(RouteNames.JobAdvertConfirmation_Get));
}
if (response.Data.HasLegalEntityAgreement == false)
{
return(RedirectToRoute(RouteNames.LegalEntityAgreement_HardStop_Get));
}
throw new Exception("Unknown submit state");
}
}
else
{
return(RedirectToRoute(RouteNames.Vacancy_Preview_Get, new { VacancyId = vm.VacancyId, SubmitToEfsa = true }));
}
var viewModel = await _orchestrator.GetVacancyPreviewViewModelAsync(vm);
viewModel.SoftValidationErrors = null;
viewModel.SetSectionStates(viewModel, ModelState);
return(View(ViewNames.VacancyPreview, viewModel));
}
public async Task ApproveJobAdvertAsync_ShouldNotSubmitWhenMissingAgreements(
bool hasLegalEntityAgreement, bool shouldBeSubmitted)
{
//Arrange
var user = new VacancyUser {
Email = "*****@*****.**", Name = "advertname", UserId = "advertId"
};
var vacancy = new Vacancy
{
EmployerAccountId = "ABCDEF",
AccountLegalEntityPublicHashedId = "XVYABD",
Id = Guid.Parse("84af954e-5baf-4942-897d-d00180a0839e"),
Title = "has a value",
NumberOfPositions = 1,
EmployerLocation = new Address {
Postcode = "has a value"
},
ShortDescription = "has a value",
ProgrammeId = "has a value",
Wage = new Wage {
Duration = 1, WageType = WageType.FixedWage
},
LegalEntityName = "legal name",
EmployerNameOption = EmployerNameOption.RegisteredName,
StartDate = DateTime.Now,
Status = VacancyStatus.Review
};
var approveJobAdvertViewModel = new ApproveJobAdvertViewModel {
ApproveJobAdvert = true, VacancyId = vacancy.Id, EmployerAccountId = "ABCDEF"
};
_mockRecruitVacancyClient.Setup(x => x.GetVacancyAsync(vacancy.Id)).ReturnsAsync(vacancy);
_mockRecruitVacancyClient.Setup(x => x.GetEmployerDescriptionAsync(vacancy)).ReturnsAsync("employer description");
_mockRecruitVacancyClient.Setup(x => x.GetEmployerNameAsync(vacancy)).ReturnsAsync("employer name");
_mockRecruitVacancyClient.Setup(c => c.Validate(vacancy, It.IsAny <VacancyRuleSet>())).Returns(new EntityValidationResult());
var geocodeImageService = new Mock <IGeocodeImageService>();
var externalLinks = new Mock <IOptions <ExternalLinksConfiguration> >();
var mapper = new DisplayVacancyViewModelMapper(geocodeImageService.Object, externalLinks.Object, _mockRecruitVacancyClient.Object);
var legalEntityAgreement = new Mock <ILegalEntityAgreementService>();
legalEntityAgreement.Setup(l => l.HasLegalEntityAgreementAsync(vacancy.EmployerAccountId, vacancy.AccountLegalEntityPublicHashedId))
.ReturnsAsync(hasLegalEntityAgreement);
var utility = new Utility(_mockRecruitVacancyClient.Object, Mock.Of <IFeature>());
var sut = new VacancyPreviewOrchestrator(_mockRecruitVacancyClient.Object,
Mock.Of <ILogger <VacancyPreviewOrchestrator> >(), mapper,
_mockReviewSummaryService.Object, legalEntityAgreement.Object,
_mockmessaging.Object,
Mock.Of <IOptions <ExternalLinksConfiguration> >(), utility);
//Act
var response = await sut.ApproveJobAdvertAsync(approveJobAdvertViewModel, user);
//Assert
var submittedTimes = shouldBeSubmitted ? Times.Once() : Times.Never();
_mockmessaging.Verify(c => c.SendCommandAsync(It.IsAny <ICommand>()), submittedTimes);
response.Data.IsSubmitted.Should().Be(shouldBeSubmitted);
response.Data.HasLegalEntityAgreement.Should().Be(hasLegalEntityAgreement);
}
public async Task <OrchestratorResponse <SubmitVacancyResponse> > ApproveJobAdvertAsync(ApproveJobAdvertViewModel m, VacancyUser user)
{
var vacancy = await _utility.GetAuthorisedVacancyAsync(m, RouteNames.ApproveJobAdvert_Post);
if (!vacancy.CanReview)
{
throw new InvalidStateException(string.Format(ErrMsg.VacancyNotAvailableForEditing, vacancy.Title));
}
var employerDescriptionTask = _vacancyClient.GetEmployerDescriptionAsync(vacancy);
var employerNameTask = _vacancyClient.GetEmployerNameAsync(vacancy);
await Task.WhenAll(employerDescriptionTask, employerNameTask);
vacancy.EmployerDescription = employerDescriptionTask.Result;
vacancy.EmployerName = employerNameTask.Result;
return(await ValidateAndExecute(
vacancy,
v => ValidateVacancy(v, SubmitValidationRules),
v => SubmitActionAsync(v, user)
));
}
