public async Task <IActionResult> Submit(SubmitEditModel m)
{
var response = await _orchestrator.SubmitVacancyAsync(m, User.ToVacancyUser());
if (!response.Success)
{
response.AddErrorsToModelState(ModelState);
}
if (ModelState.IsValid)
{
if (response.Data.IsSubmitted)
{
return(RedirectToRoute(RouteNames.Submitted_Index_Get));
}
if (response.Data.HasLegalEntityAgreement == false)
{
return(RedirectToRoute(RouteNames.LegalEntityAgreement_HardStop_Get));
}
throw new Exception("Unknown submit state");
}
var viewModel = await _orchestrator.GetVacancyPreviewViewModelAsync(m);
viewModel.SoftValidationErrors = null;
SetSectionStates(viewModel);
return(View(ViewNames.VacancyPreview, viewModel));
}
public async Task <IActionResult> Submit(SubmitEditModel m)
{
var response = await _orchestrator.SubmitVacancyAsync(m, User.ToVacancyUser());
if (!response.Success)
{
response.AddErrorsToModelState(ModelState);
}
if (ModelState.IsValid)
{
if (response.Data.IsSubmitted)
{
return(RedirectToRoute(RouteNames.Submitted_Index_Get));
}
if (response.Data.IsSentForReview)
{
return(RedirectToRoute(RouteNames.Reviewed_Index_Get));
}
if (response.Data.HasProviderAgreement == false)
{
return(RedirectToRoute(RouteNames.ProviderAgreement_HardStop_Get));
}
if (response.Data.HasLegalEntityAgreement == false)
{
return(RedirectToRoute(RouteNames.LegalEntityAgreement_HardStop_Get));
}
throw new Exception("Unknown submit state");
}
if (response.Errors.Errors.Any(e => e.ErrorCode == ErrorCodes.TrainingProviderMustHaveEmployerPermission))
{
throw new MissingPermissionsException(string.Format(RecruitWebExceptionMessages.ProviderMissingPermission, m.Ukprn));
}
var viewModel = await _orchestrator.GetVacancyPreviewViewModelAsync(m);
viewModel.SoftValidationErrors = null;
SetSectionStates(viewModel);
return(View(ViewNames.VacancyPreview, viewModel));
}
public async Task <IActionResult> Submit(SubmitEditModel m)
{
var response = await _orchestrator.SubmitVacancyAsync(m, User.ToVacancyUser());
if (!response.Success)
{
response.AddErrorsToModelState(ModelState);
}
//if (ModelState.IsValid)
// return RedirectToRoute(RouteNames.Submitted_Index_Get);
var viewModel = await _orchestrator.GetVacancyPreviewViewModelAsync(m);
SetSectionStates(viewModel);
return(View(ViewNames.VacancyPreview, viewModel));
}
public async Task <OrchestratorResponse> SubmitVacancyAsync(SubmitEditModel m, VacancyUser user)
{
var vacancy = await Utility.GetAuthorisedVacancyAsync(_client, _vacancyClient, m, RouteNames.Preview_Submit_Post);
if (!vacancy.CanSubmit)
{
throw new InvalidStateException(string.Format(ErrMsg.VacancyNotAvailableForEditing, vacancy.Title));
}
return(await ValidateAndExecute(
vacancy,
v =>
{
var result = _vacancyClient.Validate(v, ValidationRules);
SyncErrorsAndModel(result.Errors);
return result;
},
v => SubmitActionAsync(v, user)
));
}
public async Task <OrchestratorResponse <SubmitVacancyResponse> > SubmitVacancyAsync(SubmitEditModel m, VacancyUser user)
{
var vacancy = await Utility.GetAuthorisedVacancyAsync(_client, _vacancyClient, m, RouteNames.Preview_Submit_Post);
if (!vacancy.CanSubmit)
{
throw new InvalidStateException(string.Format(ErrMsg.VacancyNotAvailableForEditing, vacancy.Title));
}
vacancy.EmployerName = await _vacancyClient.GetEmployerNameAsync(vacancy);
return(await ValidateAndExecute(
vacancy,
v => ValidateVacancy(v, SubmitValidationRules),
v => SubmitActionAsync(v, user)
));
}
public async Task SubmitVacancyAsync_ShouldNotSubmitWhenMissingAgreements(bool hasLegalEntityAgreement, bool hasProviderAgreement, bool shouldBeSubmitted)
{
var vacancyId = Guid.NewGuid();
const long ukprn = 12345678;
const string employerAccountId = "ABCDEF";
const string accountLegalEntityPublicHashedId = "XVYABD";
var fixture = new Fixture();
var vacancy = fixture.Create <Vacancy>();
vacancy.Id = vacancyId;
vacancy.TrainingProvider.Ukprn = ukprn;
vacancy.Status = VacancyStatus.Draft;
vacancy.IsDeleted = false;
vacancy.EmployerAccountId = employerAccountId;
vacancy.AccountLegalEntityPublicHashedId = accountLegalEntityPublicHashedId;
vacancy.OwnerType = OwnerType.Provider;
var client = new Mock <IProviderVacancyClient>();
var vacancyClient = new Mock <IRecruitVacancyClient>();
vacancyClient.Setup(c => c.GetVacancyAsync(vacancyId))
.ReturnsAsync(vacancy);
vacancyClient.Setup(c => c.GetEmployerNameAsync(vacancy))
.ReturnsAsync("employer name from employer service");
vacancyClient.Setup(c => c.Validate(vacancy, It.IsAny <Recruit.Vacancies.Client.Application.Validation.VacancyRuleSet>()))
.Returns(new EntityValidationResult());
var logger = new Mock <ILogger <VacancyPreviewOrchestrator> >();
var geocodeImageService = new Mock <IGeocodeImageService>();
var externalLinks = new Mock <IOptions <ExternalLinksConfiguration> >();
var mapper = new DisplayVacancyViewModelMapper(geocodeImageService.Object, externalLinks.Object, vacancyClient.Object, client.Object);
var review = new Mock <IReviewSummaryService>();
var permission = new Mock <IProviderRelationshipsService>();
permission.Setup(p => p.HasProviderGotEmployersPermissionAsync(ukprn, employerAccountId, accountLegalEntityPublicHashedId, OperationType.RecruitmentRequiresReview))
.ReturnsAsync(false);
var legalEntityAgreement = new Mock <ILegalEntityAgreementService>();
legalEntityAgreement.Setup(l => l.HasLegalEntityAgreementAsync(employerAccountId, accountLegalEntityPublicHashedId))
.ReturnsAsync(hasLegalEntityAgreement);
var agreementServiceMock = new Mock <ITrainingProviderAgreementService>();
agreementServiceMock.Setup(t => t.HasAgreementAsync(ukprn))
.ReturnsAsync(hasProviderAgreement);
var messagingMock = new Mock <IMessaging>();
var orch = new VacancyPreviewOrchestrator(
client.Object, vacancyClient.Object, logger.Object, mapper, review.Object, permission.Object,
legalEntityAgreement.Object, agreementServiceMock.Object, messagingMock.Object);
var m = new SubmitEditModel
{
VacancyId = vacancyId,
Ukprn = ukprn
};
var user = new VacancyUser();
var actualResponse = await orch.SubmitVacancyAsync(m, user);
var submittedTimes = shouldBeSubmitted ? Times.Once() : Times.Never();
messagingMock.Verify(c => c.SendCommandAsync(It.IsAny <ICommand>()), submittedTimes);
actualResponse.Data.IsSubmitted.Should().Be(shouldBeSubmitted);
actualResponse.Data.HasLegalEntityAgreement.Should().Be(hasLegalEntityAgreement);
actualResponse.Data.HasProviderAgreement.Should().Be(hasProviderAgreement);
}
public async Task <OrchestratorResponse <SubmitVacancyResponse> > SubmitVacancyAsync(SubmitEditModel m, VacancyUser user)
{
var vacancy = await Utility.GetAuthorisedVacancyAsync(_vacancyClient, m, RouteNames.Preview_Submit_Post);
var employerProfile = await _client.GetEmployerProfileAsync(vacancy.EmployerAccountId, vacancy.LegalEntityId);
// Update the vacancy with the current employer description text from Profile.
vacancy.EmployerDescription = employerProfile?.AboutOrganisation ?? string.Empty;
if (!vacancy.CanSubmit)
{
throw new InvalidStateException(string.Format(ErrMsg.VacancyNotAvailableForEditing, vacancy.Title));
}
return(await ValidateAndExecute(
vacancy,
v =>
{
var result = _vacancyClient.Validate(v, ValidationRules);
SyncErrorsAndModel(result.Errors);
return result;
},
v => SubmitActionAsync(v, user)
));
}
