public static void CheckRouteIsValidForVacancy(Vacancy vacancy, string currentRouteName, VacancyRouteModel vrm)
{
var validRoutes = GetPermittedRoutesForVacancy(vacancy);
if (validRoutes == null || validRoutes.Contains(currentRouteName))
{
return;
}
var redirectRoute = validRoutes.Last();
throw new InvalidRouteForVacancyException(string.Format(RecruitWebExceptionMessages.RouteNotValidForVacancy, currentRouteName, redirectRoute),
redirectRoute, vrm);
}
public async Task <IActionResult> Qualification(VacancyRouteModel vrm, int index)
{
var vm = await _orchestrator.GetQualificationViewModelForEditAsync(vrm, index);
return(View(vm));
}
public async Task <OrchestratorResponse> PostQualificationEditModelForAddAsync(VacancyRouteModel vrm, QualificationEditModel m, VacancyUser user)
{
var vacancy = await Utility.GetAuthorisedVacancyForEditAsync(_client, _vacancyClient, vrm, RouteNames.Qualification_Add_Post);
if (vacancy.Qualifications == null)
{
vacancy.Qualifications = new List <Qualification>();
}
var qualification = new Qualification();
vacancy.Qualifications.Add(qualification);
return(await UpdateVacancyWithQualificationAsync(vacancy, null, qualification, m, user));
}
public async Task <IActionResult> ShortDescription(VacancyRouteModel vrm)
{
var vm = await _orchestrator.GetShortDescriptionViewModelAsync(vrm);
return(View(vm));
}
public async Task <ShortDescriptionViewModel> GetShortDescriptionViewModelAsync(VacancyRouteModel vrm)
{
var vacancy = await Utility.GetAuthorisedVacancyForEditAsync(_providerVacancyClient,
_recruitVacancyClient, vrm, RouteNames.ShortDescription_Get);
var vm = new ShortDescriptionViewModel
{
VacancyId = vacancy.Id,
ShortDescription = vacancy.ShortDescription,
Title = vacancy.Title
};
if (vacancy.Status == VacancyStatus.Referred)
{
vm.Review = await _reviewSummaryService.GetReviewSummaryViewModelAsync(vacancy.VacancyReference.Value,
ReviewFieldMappingLookups.GetShortDescriptionReviewFieldIndicators());
}
return(vm);
}
public IActionResult ApproveJobAdvert(VacancyRouteModel vm)
{
return(View(new ApproveJobAdvertViewModel()));
}
public async Task <IActionResult> ConfirmationJobAdvert(VacancyRouteModel vrm)
{
var viewModel = await _orchestrator.GetVacancyConfirmationJobAdvertAsync(vrm);
return(View("ConfirmationJobAdvert", viewModel));
}
public IActionResult Cancel(VacancyRouteModel vrm, [FromQuery] bool wizard)
{
return(CancelAndRedirect(wizard));
}
public static async Task <Vacancy> GetAuthorisedVacancyForEditAsync(IEmployerVacancyClient client, IRecruitVacancyClient vacancyClient, VacancyRouteModel vrm, string routeName)
{
var vacancy = await GetAuthorisedVacancyAsync(vacancyClient, vrm, routeName);
CheckCanEdit(vacancy);
return(vacancy);
}
public async Task <VacancyEmployerInfoModel> GetVacancyEmployerInfoModelAsync(VacancyRouteModel vrm)
{
var vacancy = await _utility.GetAuthorisedVacancyForEditAsync(vrm, RouteNames.Employer_Post);
var model = new VacancyEmployerInfoModel()
{
VacancyId = vacancy.Id,
AccountLegalEntityPublicHashedId = vacancy.AccountLegalEntityPublicHashedId
};
if (vacancy.EmployerNameOption.HasValue)
{
model.EmployerIdentityOption = vacancy.EmployerNameOption.Value.ConvertToModelOption();
model.AnonymousName = vacancy.IsAnonymous ? vacancy.EmployerName : null;
model.AnonymousReason = vacancy.IsAnonymous ? vacancy.AnonymousReason : null;
}
return(model);
}
public async Task <IActionResult> CloneVacancyWithNewDates(VacancyRouteModel vrm)
{
var vm = await _orchestrator.GetCloneVacancyWithNewDatesViewModelAsync(vrm);
return(View(vm));
}
public async Task <IActionResult> TrainingFirstVacancy(VacancyRouteModel vrm)
{
var vm = await _orchestrator.GetTrainingFirstVacancyViewModelAsync(vrm);
return(View(vm));
}
public IActionResult TrainingHelp(VacancyRouteModel vrm)
{
return(View());
}
public async Task <IActionResult> Considerations(VacancyRouteModel vrm)
{
var vm = await _orchestrator.GetConsiderationsViewModelAsync(vrm);
return(View(vm));
}
public async Task PostQualificationEditModelForEditAsync(VacancyRouteModel vacancyRouteModel, QualificationEditModel model, int index)
{
await Sut.PostQualificationEditModelForEditAsync(vacancyRouteModel, model, User, index);
}
public static async Task <Vacancy> GetAuthorisedVacancyAsync(IRecruitVacancyClient client, VacancyRouteModel vrm, string routeName)
{
var vacancy = await client.GetVacancyAsync(vrm.VacancyId);
CheckAuthorisedAccess(vacancy, vrm.EmployerAccountId);
CheckRouteIsValidForVacancy(vacancy, routeName);
return(vacancy);
}
public async Task DeleteQualificationAsync(VacancyRouteModel vacancyRouteModel, int index)
{
await Sut.DeleteQualificationAsync(vacancyRouteModel, index, User);
}
public async Task <ProviderContactDetailsViewModel> GetProviderContactDetailsViewModelAsync(VacancyRouteModel vrm)
{
var vacancy = await Utility.GetAuthorisedVacancyForEditAsync(_client, _vacancyClient, vrm, RouteNames.ProviderContactDetails_Get);
var vm = new ProviderContactDetailsViewModel
{
Title = vacancy.Title,
ProviderContactName = vacancy.ProviderContact?.Name,
ProviderContactEmail = vacancy.ProviderContact?.Email,
ProviderContactPhone = vacancy.ProviderContact?.Phone,
ProviderName = vacancy.TrainingProvider?.Name
};
if (vacancy.Status == VacancyStatus.Referred)
{
vm.Review = await _reviewSummaryService.GetReviewSummaryViewModelAsync(vacancy.VacancyReference.Value,
ReviewFieldMappingLookups.GetProviderContactDetailsFieldIndicators());
}
return(vm);
}
public async Task <IActionResult> RejectJobAdvert(VacancyRouteModel vm)
{
var viewModel = await _orchestrator.GetVacancyRejectJobAdvertAsync(vm);
return(View(viewModel));
}
public async Task <ApplicationProcessViewModel> GetApplicationProcessViewModelAsync(VacancyRouteModel vrm)
{
var vacancy = await _utility.GetAuthorisedVacancyForEditAsync(vrm, RouteNames.ApplicationProcess_Get);
var vm = new ApplicationProcessViewModel
{
Title = vacancy.Title,
FindAnApprenticeshipUrl = _externalLinks.FindAnApprenticeshipUrl,
ApplicationMethod = vacancy.ApplicationMethod,
ApplicationInstructions = vacancy.ApplicationInstructions,
ApplicationUrl = vacancy.ApplicationUrl
};
if (vacancy.Status == VacancyStatus.Referred)
{
vm.Review = await _reviewSummaryService.GetReviewSummaryViewModelAsync(vacancy.VacancyReference.Value,
ReviewFieldMappingLookups.GetApplicationProcessFieldIndicators());
}
vm.IsTaskListCompleted = _utility.TaskListCompleted(vacancy);
return(vm);
}
public async Task <IActionResult> AboutEmployer(VacancyRouteModel vrm)
{
var vm = await _orchestrator.GetAboutEmployerViewModelAsync(vrm);
return(View(vm));
}
public async Task <ConfirmTrainingViewModel> GetConfirmTrainingViewModelAsync(VacancyRouteModel vrm, string programmeId)
{
var vacancyTask = Utility.GetAuthorisedVacancyForEditAsync(_client, _vacancyClient, vrm, RouteNames.Training_Confirm_Get);
var programmesTask = _vacancyClient.GetActiveApprenticeshipProgrammesAsync();
await Task.WhenAll(vacancyTask, programmesTask);
var programme = programmesTask.Result.SingleOrDefault(p => p.Id == programmeId);
if (programme == null)
{
return(null);
}
return(new ConfirmTrainingViewModel
{
ProgrammeId = programme.Id,
ApprenticeshipLevel = programme.ApprenticeshipLevel,
TrainingTitle = programme.Title,
DurationMonths = programme.Duration,
ProgrammeType = programme.ApprenticeshipType.GetDisplayName(),
PageInfo = Utility.GetPartOnePageInfo(vacancyTask.Result),
TrainingEffectiveToDate = programme.EffectiveTo?.AsGdsDate(),
EducationLevelName =
EducationLevelNumberHelper.GetEducationLevelNameOrDefault(programme.EducationLevelNumber, programme.ApprenticeshipLevel)
});
}
public async Task <IActionResult> Confirmation(VacancyRouteModel vrm)
{
var vm = await _orchestrator.GetVacancySubmittedConfirmationViewModelAsync(vrm, User.ToVacancyUser());
return(View(vm));
}
public Task <IActionResult> Delete(VacancyRouteModel vrm)
{
return(GetDeleteVacancyConfirmationView(vrm));
}
public async Task <VacancySubmittedConfirmationViewModel> GetVacancySubmittedConfirmationViewModelAsync(VacancyRouteModel vrm, VacancyUser vacancyUser)
{
var vacancy = await Utility.GetAuthorisedVacancyAsync(_vacancyClient, vrm, RouteNames.Submitted_Index_Get);
if (vacancy.Status != VacancyStatus.Submitted)
{
throw new InvalidStateException(string.Format(ErrorMessages.VacancyNotSubmittedSuccessfully, vacancy.Title));
}
var isResubmit = false;
if (vacancy.VacancyReference.HasValue)
{
var review = await _vacancyClient.GetCurrentReferredVacancyReviewAsync(vacancy.VacancyReference.Value);
isResubmit = review != null;
}
var preferences = await _vacancyClient.GetUserNotificationPreferencesAsync(vacancyUser.UserId);
var vm = new VacancySubmittedConfirmationViewModel
{
Title = vacancy.Title,
VacancyReference = vacancy.VacancyReference?.ToString(),
IsResubmit = isResubmit,
HasNotificationsSet = preferences != null && preferences.NotificationTypes > NotificationTypes.None
};
return(vm);
}
private async Task <IActionResult> GetDeleteVacancyConfirmationView(VacancyRouteModel vrm)
{
var vm = await _orchestrator.GetDeleteViewModelAsync(vrm);
return(View(vm));
}
public async Task <QualificationViewModel> GetQualificationViewModelForEditAsync(VacancyRouteModel vrm, QualificationEditModel m, int index)
{
var vm = await GetQualificationViewModelForEditAsync(vrm, index);
SetQualificationViewModelFromEditModel(vm, m);
return(vm);
}
public async Task PostQualificationEditModelForAddAsync(VacancyRouteModel vacancyRouteModel, QualificationEditModel model)
{
await Sut.PostQualificationEditModelForAddAsync(vacancyRouteModel, model, User);
}
public async Task <OrchestratorResponse> PostQualificationEditModelForEditAsync(VacancyRouteModel vrm, QualificationEditModel m, VacancyUser user, int index)
{
var vacancy = await Utility.GetAuthorisedVacancyForEditAsync(_client, _vacancyClient, vrm, RouteNames.Qualification_Edit_Post);
var qualification = vacancy.Qualifications[index];
var currentQualification = new Qualification
{
QualificationType = qualification.QualificationType,
Grade = qualification.Grade,
Subject = qualification.Subject,
Weighting = qualification.Weighting,
};
return(await UpdateVacancyWithQualificationAsync(vacancy, currentQualification, qualification, m, user));
}
public static async Task <Vacancy> GetAuthorisedVacancyAsync(IProviderVacancyClient client, IRecruitVacancyClient vacancyClient, VacancyRouteModel vrm, string routeName)
{
var vacancy = await vacancyClient.GetVacancyAsync(vrm.VacancyId.GetValueOrDefault());
CheckAuthorisedAccess(vacancy, vrm.Ukprn);
CheckRouteIsValidForVacancy(vacancy, routeName, vrm);
return(vacancy);
}
