public ActionResult ConfirmChangeEmail()
{
var email = TempData["EmailChangeNewEmail"];
var model = new OrchestratorResponse <ConfirmChangeEmailViewModel>
{
Data = new ConfirmChangeEmailViewModel(),
FlashMessage = new FlashMessageViewModel()
{
Severity = FlashMessageSeverityLevel.Success,
Headline = "Check your email",
SubMessage = email != null ? $"We've sent a security code to {TempData["EmailChangeNewEmail"]}" : "We've sent you a security code"
}
};
model.Data.UserId = GetLoggedInUserId();
TempData["EmailChangeRequested"] = true;
TempData["EmailChangeNewEmail"] = TempData["EmailChangeNewEmail"] as string;
TempData["EmailChangeReturnUrl"] = TempData["EmailChangeReturnUrl"];
TempData["EmailChangeClientId"] = TempData["EmailChangeClientId"];
return(View(model));
}
public async Task <ActionResult> Login(string id, LoginViewModel model)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException(nameof(id), "Missing id when posting to login");
}
if (model == null)
{
throw new ArgumentNullException(nameof(model), "Missing login model when posting to login");
}
model.OriginatingAddress = Request.UserHostAddress;
var result = await _accountOrchestrator.Login(model);
var response = new OrchestratorResponse <LoginViewModel>();
if (result == null)
{
throw new NullReferenceException("Orchestrator did not return a result");
}
if (result.Data.Success)
{
if (result.Data.RequiresActivation)
{
return(RedirectToAction("Confirm"));
}
var signinMessage = _owinWrapper.GetSignInMessage(id);
if (signinMessage == null)
{
_logger.Info($"Could not find signin message for id {id}, Redirecting to Employer Portal");
return(await RedirectToEmployerPortal());
}
return(Redirect(signinMessage.ReturnUrl));
}
if (result.Data.AccountIsLocked)
{
return(RedirectToAction("Unlock"));
}
if (result.Status != HttpStatusCode.OK)
{
response.Data = new LoginViewModel
{
ReturnUrl = model.ReturnUrl,
ClientId = model.ClientId
};
response.FlashMessage = result.FlashMessage;
response.Status = result.Status;
response.Data.ErrorDictionary = result.FlashMessage.ErrorMessages;
response.Status = HttpStatusCode.OK;
return(View(response));
}
return(View(response));
}
public async Task <ActionResult> Confirm(ActivateUserViewModel activateUserViewModel)
{
var id = GetLoggedInUserId();
activateUserViewModel =
await
_accountOrchestrator.ActivateUser(new ActivateUserViewModel
{
AccessCode = activateUserViewModel.AccessCode,
UserId = id
});
if (activateUserViewModel.Valid)
{
return(Redirect(activateUserViewModel.ReturnUrl));
}
var response = new OrchestratorResponse <ActivateUserViewModel>
{
Data = activateUserViewModel,
FlashMessage = new FlashMessageViewModel
{
ErrorMessages = activateUserViewModel.ErrorDictionary,
Severity = FlashMessageSeverityLevel.Error,
Headline = "Errors to fix",
Message = "Check the following details:"
}
};
return(View("Confirm", response));
}
public async Task <OrchestratorResponse <EmployerAgreementPdfViewModel> > GetPdfEmployerAgreement(string hashedAccountId, string agreementId, string userId)
{
var pdfEmployerAgreement = new OrchestratorResponse <EmployerAgreementPdfViewModel>();
try
{
var result = await _mediator.SendAsync(new GetEmployerAgreementPdfRequest
{
HashedAccountId = hashedAccountId,
HashedLegalAgreementId = agreementId,
UserId = userId
});
pdfEmployerAgreement.Data = new EmployerAgreementPdfViewModel {
PdfStream = result.FileStream
};
}
catch (UnauthorizedAccessException ex)
{
pdfEmployerAgreement.Data = new EmployerAgreementPdfViewModel();
pdfEmployerAgreement.Status = HttpStatusCode.Unauthorized;
}
catch (Exception ex)
{
pdfEmployerAgreement.Exception = ex;
pdfEmployerAgreement.Data = new EmployerAgreementPdfViewModel();
pdfEmployerAgreement.Status = HttpStatusCode.NotFound;
}
return(pdfEmployerAgreement);
}
public async Task <OrchestratorResponse <PayeSchemeDetailViewModel> > GetPayeDetails(string empRef, string hashedAccountId, string userId)
{
var response = new OrchestratorResponse <PayeSchemeDetailViewModel>();
try
{
var englishFractionResult = await Mediator.SendAsync(new GetEmployerEnglishFractionQuery
{
HashedAccountId = hashedAccountId,
EmpRef = empRef,
UserId = userId
});
var payeSchemeResult = await Mediator.SendAsync(new GetPayeSchemeByRefQuery
{
HashedAccountId = hashedAccountId,
Ref = empRef
});
response.Data = new PayeSchemeDetailViewModel
{
Fractions = englishFractionResult.Fractions,
EmpRef = englishFractionResult.EmpRef,
PayeSchemeName = payeSchemeResult?.PayeScheme?.Name ?? string.Empty,
EmpRefAdded = englishFractionResult.EmpRefAddedDate
};
return(response);
}
catch (UnauthorizedAccessException)
{
response.Status = HttpStatusCode.Unauthorized;
}
return(response);
}
public void Arrange()
{
_orchestrator = new Mock <OrganisationOrchestrator>();
_owinWrapper = new Mock <IOwinWrapper>();
_featureToggle = new Mock <IFeatureToggle>();
_userViewTestingService = new Mock <IMultiVariantTestingService>();
_mapper = new Mock <IMapper>();
_flashMessage = new Mock <ICookieStorageService <FlashMessageViewModel> >();
_validationResponse = new OrchestratorResponse <OrganisationDetailsViewModel>
{
Data = new OrganisationDetailsViewModel(),
Status = HttpStatusCode.OK
};
_orchestrator.Setup(x => x.ValidateLegalEntityName(It.IsAny <OrganisationDetailsViewModel>()))
.ReturnsAsync(_validationResponse);
_mapper.Setup(x => x.Map <FindOrganisationAddressViewModel>(It.IsAny <OrganisationDetailsViewModel>()))
.Returns(new FindOrganisationAddressViewModel());
_logger = new Mock <ILogger>();
_controller = new OrganisationController(
_owinWrapper.Object,
_orchestrator.Object,
_featureToggle.Object,
_userViewTestingService.Object,
_mapper.Object,
_logger.Object,
_flashMessage.Object);
}
public async Task <OrchestratorResponse <UserInvitationsViewModel> > GetAllInvitationsForUser(string externalUserId)
{
try
{
var response = await _mediator.SendAsync(new GetUserInvitationsRequest
{
UserId = externalUserId
});
var getUserAccountsQueryResponse = await _mediator.SendAsync(new GetUserAccountsQuery
{
UserRef = externalUserId
});
var result = new OrchestratorResponse <UserInvitationsViewModel>
{
Data = new UserInvitationsViewModel
{
Invitations = response.Invitations,
ShowBreadCrumbs = getUserAccountsQueryResponse.Accounts.AccountList.Count != 0
}
};
return(result);
}
catch (InvalidRequestException ex)
{
_logger.Info(ex);
}
return(new OrchestratorResponse <UserInvitationsViewModel>
{
Data = null
});
}
public async Task <OrchestratorResponse <PasswordResetViewModel> > ForgottenPasswordFromEmail(string hashedUserId)
{
var response = new OrchestratorResponse <PasswordResetViewModel>();
try
{
var user = await _mediator.SendAsync(new GetUserByHashedIdQuery { HashedUserId = hashedUserId });
if (user == null)
{
response.Status = HttpStatusCode.BadRequest;
return(response);
}
response.Data = new PasswordResetViewModel {
Email = user.Email, UnlockCodeLength = await GetUnlockCodeLength()
};
}
catch (InvalidRequestException ex)
{
response.Status = HttpStatusCode.BadRequest;
response.FlashMessage = new FlashMessageViewModel
{
Headline = "Errors to fix",
Message = "Check the following details:",
ErrorMessages = ex.ErrorMessages,
Severity = FlashMessageSeverityLevel.Error
};
response.Exception = ex;
}
return(response);
}
public async Task <OrchestratorResponse <ReviewOrganisationAddressViewModel> > GetRefreshedOrganisationDetails(string accountLegalEntityPublicHashedId)
{
var currentDetails = await Mediator.SendAsync(new GetAccountLegalEntityRequest
{
AccountLegalEntityId = _accountLegalEntityHashingService.DecodeValue(accountLegalEntityPublicHashedId)
});
var refreshedDetails = await Mediator.SendAsync(new GetOrganisationByIdRequest
{
Identifier = currentDetails.AccountLegalEntity.Identifier,
OrganisationType = currentDetails.AccountLegalEntity.OrganisationType
});
var result = new OrchestratorResponse <ReviewOrganisationAddressViewModel>
{
Data = new ReviewOrganisationAddressViewModel
{
DataSourceFriendlyName = currentDetails.AccountLegalEntity.OrganisationType.GetFriendlyName(),
AccountLegalEntityPublicHashedId = accountLegalEntityPublicHashedId,
OrganisationName = currentDetails.AccountLegalEntity.Name,
OrganisationAddress = currentDetails.AccountLegalEntity.Address,
RefreshedName = refreshedDetails.Organisation.Name,
RefreshedAddress = refreshedDetails.Organisation.Address.FormatAddress(),
}
};
result.Data.UpdatesAvailable = CheckForUpdate(result.Data.OrganisationName, result.Data.RefreshedName, OrganisationUpdatesAvailable.Name) |
CheckForUpdate(result.Data.OrganisationAddress, result.Data.RefreshedAddress, OrganisationUpdatesAvailable.Address);
return(result);
}
public virtual async Task <OrchestratorResponse <ICollection <OrganisationAgreementViewModel> > > GetOrganisationAgreements(string accountLegalEntityHashedId)
{
var response = new OrchestratorResponse <ICollection <OrganisationAgreementViewModel> >();
try
{
var result = await _mediator.SendAsync(new GetOrganisationAgreementsRequest
{
AccountLegalEntityHashedId = accountLegalEntityHashedId
});
response.Data = _mapper.Map <ICollection <EmployerAgreementDto>, ICollection <OrganisationAgreementViewModel> >(result.Agreements);
}
catch (InvalidRequestException ex)
{
return(new OrchestratorResponse <ICollection <OrganisationAgreementViewModel> >
{
Status = HttpStatusCode.BadRequest,
Exception = ex
});
}
catch (UnauthorizedAccessException)
{
return(new OrchestratorResponse <ICollection <OrganisationAgreementViewModel> >
{
Status = HttpStatusCode.Unauthorized
});
}
return(response);
}
public async Task <OrchestratorResponse <OrganisationUpdatedNextStepsViewModel> > UpdateOrganisation(
string accountLegalEntityPublicHashedId,
string organisationName,
string organisationAddress,
string hashedAccountId,
string userId)
{
var result = new OrchestratorResponse <OrganisationUpdatedNextStepsViewModel>
{
Data = new OrganisationUpdatedNextStepsViewModel()
};
try
{
var request = new UpdateOrganisationDetailsCommand
{
AccountLegalEntityId = _accountLegalEntityHashingService.DecodeValue(accountLegalEntityPublicHashedId),
Name = organisationName,
Address = organisationAddress,
HashedAccountId = hashedAccountId,
UserId = userId
};
await _mediator.SendAsync(request);
}
catch (Exception)
{
result.Data.ErrorMessage = "Failed to update the organisation's details.";
}
return(result);
}
public async Task <ActionResult> NextSteps(int?choice, string hashedAccountId)
{
var userId = OwinWrapper.GetClaimValue(ControllerConstants.UserRefClaimKeyName);
var userShownWizard = await _orchestrator.UserShownWizard(userId, hashedAccountId);
switch (choice ?? 0)
{
case 1: return(RedirectToAction(ControllerConstants.IndexActionName, ControllerConstants.EmployerAgreementControllerName));
case 2: return(RedirectToAction(ControllerConstants.IndexActionName, ControllerConstants.TransfersControllerName));
case 3: return(RedirectToAction(ControllerConstants.IndexActionName, ControllerConstants.EmployerTeamControllerName));
default:
var model = new OrchestratorResponse <EmployerAgreementNextStepsViewModel>
{
FlashMessage = GetFlashMessageViewModelFromCookie(),
Data = new EmployerAgreementNextStepsViewModel
{
ErrorMessage = "You must select an option to continue.",
UserShownWizard = userShownWizard
}
};
return(View(model)); //No option entered
}
}
public async Task <ActionResult> Invite(InviteTeamMemberViewModel model)
{
var response = await _employerTeamOrchestrator.InviteTeamMember(model, OwinWrapper.GetClaimValue(@"sub"));
if (response.Status == HttpStatusCode.OK)
{
var flashMessage = new FlashMessageViewModel
{
HiddenFlashMessageInformation = "page-invite-team-member-sent",
Severity = FlashMessageSeverityLevel.Success,
Headline = "Invitation sent",
Message = $"You've sent an invitation to <strong>{model.Email}</strong>"
};
AddFlashMessageToCookie(flashMessage);
return(RedirectToAction("ViewTeam"));
}
model.ErrorDictionary = response.FlashMessage.ErrorMessages;
var errorResponse = new OrchestratorResponse <InviteTeamMemberViewModel>
{
Data = model,
FlashMessage = response.FlashMessage,
};
return(View(errorResponse));
}
public ActionResult GatewayInform(string hashedAccountId)
{
if (!string.IsNullOrWhiteSpace(hashedAccountId))
{
_accountCookieStorage.Delete(_hashedAccountIdCookieName);
_accountCookieStorage.Create(
new HashedAccountIdModel {
Value = hashedAccountId
},
_hashedAccountIdCookieName);
}
var gatewayInformViewModel = new OrchestratorResponse <GatewayInformViewModel>
{
Data = new GatewayInformViewModel
{
BreadcrumbDescription = "Back to Your User Profile",
ConfirmUrl = Url.Action(ControllerConstants.GatewayViewName, ControllerConstants.EmployerAccountControllerName),
}
};
var flashMessageViewModel = GetFlashMessageViewModelFromCookie();
if (flashMessageViewModel != null)
{
gatewayInformViewModel.FlashMessage = flashMessageViewModel;
}
return(View(gatewayInformViewModel));
}
public async Task <OrchestratorResponse <SearchOrganisationResultsViewModel> > SearchOrganisation(string searchTerm, int pageNumber, OrganisationType?organisationType, string hashedAccountId, string userId)
{
var response = new OrchestratorResponse <SearchOrganisationResultsViewModel>();
try
{
_cookieService.Delete(CookieName);
var result = await Mediator.SendAsync(new GetOrganisationsRequest { SearchTerm = searchTerm, PageNumber = pageNumber, OrganisationType = organisationType });
response.Data = new SearchOrganisationResultsViewModel
{
Results = CreateResult(result.Organisations),
SearchTerm = searchTerm,
OrganisationType = organisationType
};
if (!string.IsNullOrEmpty(hashedAccountId))
{
await SetAlreadySelectedOrganisations(hashedAccountId, userId, response.Data.Results);
}
}
catch (InvalidRequestException ex)
{
response.Exception = ex;
response.FlashMessage = FlashMessageViewModel.CreateErrorFlashMessageViewModel(ex.ErrorMessages);
response.Status = HttpStatusCode.BadRequest;
}
return(response);
}
public async Task <OrchestratorResponse <EditVacancyDatesViewModel> > GetEditVacancyDatesViewModelAsync(VacancyRouteModel vrm, DateTime?proposedClosingDate, DateTime?proposedStartDate)
{
var vacancyTask = GetVacancyAsync(vrm);
var programmesTask = _vacancyClient.GetActiveApprenticeshipProgrammesAsync();
await Task.WhenAll(vacancyTask, programmesTask);
var vacancy = vacancyTask.Result;
var programmes = programmesTask.Result;
var vm = new EditVacancyDatesViewModel
{
ClosingDay = $"{vacancy.ClosingDate.Value.Day:00}",
ClosingMonth = $"{vacancy.ClosingDate.Value.Month:00}",
ClosingYear = $"{vacancy.ClosingDate.Value.Year}",
StartDay = $"{vacancy.StartDate.Value.Day:00}",
StartMonth = $"{vacancy.StartDate.Value.Month:00}",
StartYear = $"{vacancy.StartDate.Value.Year}",
CurrentYear = _timeProvider.Now.Year,
ProgrammeName = programmes.First(p => p.Id == vacancy.ProgrammeId).Title
};
var resp = new OrchestratorResponse <EditVacancyDatesViewModel>(vm);
ApplyProposedDateChanges(proposedClosingDate, proposedStartDate, resp);
return(resp);
}
private void RevalidateModel(OrchestratorResponse <SelectProviderViewModel> defaultViewModel)
{
var validator = new SelectProviderViewModelValidator();
var results = validator.Validate(defaultViewModel.Data, ruleSet: "SearchResult");
results.AddToModelState(ModelState, null);
}
//TODO: The message gets mutated by the method. Message needs to be made immutable
public virtual async Task <OrchestratorResponse <RemovePayeSchemeViewModel> > RemoveSchemeFromAccount(RemovePayeSchemeViewModel model)
{
var response = new OrchestratorResponse <RemovePayeSchemeViewModel> {
Data = model
};
try
{
var result = await Mediator.SendAsync(new GetPayeSchemeByRefQuery
{
HashedAccountId = model.HashedAccountId,
Ref = model.PayeRef,
});
model.PayeSchemeName = result.PayeScheme.Name;
await Mediator.SendAsync(new RemovePayeFromAccountCommand(model.HashedAccountId,
model.PayeRef, model.UserId, model.RemoveScheme == 2, model.PayeSchemeName));
response.Data = model;
}
catch (UnauthorizedAccessException)
{
response.Status = HttpStatusCode.Unauthorized;
}
catch (InvalidRequestException ex)
{
response.Status = HttpStatusCode.BadRequest;
response.Data.ErrorDictionary = ex.ErrorMessages;
}
return(response);
}
public async Task <ActionResult> RenameAccount(RenameEmployerAccountViewModel vm)
{
var userIdClaim = OwinWrapper.GetClaimValue(ControllerConstants.UserRefClaimKeyName);
var response = await _employerAccountOrchestrator.RenameEmployerAccount(vm, userIdClaim);
if (response.Status == HttpStatusCode.OK)
{
var flashmessage = new FlashMessageViewModel
{
Headline = "Account renamed",
Message = "You successfully updated the account name",
Severity = FlashMessageSeverityLevel.Success
};
AddFlashMessageToCookie(flashmessage);
return(RedirectToAction(ControllerConstants.IndexActionName, ControllerConstants.EmployerTeamControllerName));
}
var errorResponse = new OrchestratorResponse <RenameEmployerAccountViewModel>();
if (response.Status == HttpStatusCode.BadRequest)
{
vm.ErrorDictionary = response.FlashMessage.ErrorMessages;
}
errorResponse.Data = vm;
errorResponse.FlashMessage = response.FlashMessage;
errorResponse.Status = response.Status;
return(View(errorResponse));
}
public virtual async Task <OrchestratorResponse <OrganisationDetailsViewModel> > ValidateLegalEntityName(OrganisationDetailsViewModel request)
{
var response = new OrchestratorResponse <OrganisationDetailsViewModel>
{
Data = request
};
var validator = new OrganisationDetailsViewModelValidator();
var validationResult = await validator.ValidateAsync(request);
if (!validationResult.IsValid)
{
response.Data.ErrorDictionary = new Dictionary <string, string>();
foreach (var validationError in validationResult.Errors)
{
response.Data.ErrorDictionary.Add(validationError.PropertyName, validationError.ErrorMessage);
}
response.Status = HttpStatusCode.BadRequest;
response.FlashMessage = new FlashMessageViewModel
{
Headline = "Errors to fix",
Message = "Check the following details:",
Severity = FlashMessageSeverityLevel.Error,
ErrorMessages = response.Data.ErrorDictionary
};
}
return(response);
}
public virtual async Task <OrchestratorResponse <AddNewPayeSchemeViewModel> > AddPayeSchemeToAccount(AddNewPayeSchemeViewModel model, string userId)
{
var response = new OrchestratorResponse <AddNewPayeSchemeViewModel> {
Data = model
};
try
{
await Mediator.SendAsync(new AddPayeToAccountCommand
{
HashedAccountId = model.HashedAccountId,
AccessToken = model.AccessToken,
RefreshToken = model.RefreshToken,
Empref = model.PayeScheme,
ExternalUserId = userId,
EmprefName = model.PayeName
});
}
catch (UnauthorizedAccessException ex)
{
response.Status = HttpStatusCode.Unauthorized;
response.Exception = ex;
}
catch (InvalidRequestException ex)
{
response.Status = HttpStatusCode.BadRequest;
response.Data.ErrorDictionary = ex.ErrorMessages;
response.Exception = ex;
}
return(response);
}
public async Task <ActionResult> Confirm()
{
var userId = GetLoggedInUserId();
var confirmationRequired = await _accountOrchestrator.RequestConfirmAccount(userId);
if (!confirmationRequired)
{
return(RedirectToAction("Index", "Home"));
}
var flashMessage = new FlashMessageViewModel
{
Severity = FlashMessageSeverityLevel.Success,
Headline = "We've sent you an email",
SubMessage = $"To confirm your identity, we've sent a code to {GetLoggedInUserEmail()}"
};
var response = new OrchestratorResponse <ActivateUserViewModel>()
{
FlashMessage = flashMessage,
Data = new ActivateUserViewModel()
};
return(View("Confirm", response));
}
public virtual async Task <OrchestratorResponse <FinanceDashboardViewModel> > Index(GetAccountFinanceOverviewQuery query)
{
var accountTask = _accountApiClient.GetAccount(query.AccountId);
_logger.Info("After GetAccount call");
var getAccountFinanceOverviewTask = _mediator.SendAsync(query);
var account = await accountTask;
var getAccountFinanceOverview = await getAccountFinanceOverviewTask;
_logger.Info($"account : {account} getAccountFinanceOverview: {getAccountFinanceOverview} ");
_logger.Info($" account.ApprenticeshipEmployerType: {account.ApprenticeshipEmployerType} AccountHashedId: {query.AccountHashedId} CurrentLevyFunds: {getAccountFinanceOverview.CurrentFunds} ");
var viewModel = new OrchestratorResponse <FinanceDashboardViewModel>
{
Data = new FinanceDashboardViewModel
{
IsLevyEmployer = (ApprenticeshipEmployerType)Enum.Parse(typeof(ApprenticeshipEmployerType), account.ApprenticeshipEmployerType, true) == ApprenticeshipEmployerType.Levy,
AccountHashedId = query.AccountHashedId,
CurrentLevyFunds = getAccountFinanceOverview.CurrentFunds,
ExpiringFunds = getAccountFinanceOverview.ExpiringFundsAmount,
ExpiryDate = getAccountFinanceOverview.ExpiringFundsExpiryDate,
TotalSpendForLastYear = getAccountFinanceOverview.TotalSpendForLastYear,
FundingExpected = getAccountFinanceOverview.FundsIn,
AvailableFunds = getAccountFinanceOverview.FundsIn - getAccountFinanceOverview.FundsOut,
ProjectedSpend = getAccountFinanceOverview.FundsOut
}
};
_logger.Info($"viewModel : {viewModel}");
return(viewModel);
}
private static void SetSearchTermValidationModelProperties(OrchestratorResponse model)
{
model.Status = HttpStatusCode.BadRequest;
model.FlashMessage = FlashMessageViewModel.CreateErrorFlashMessageViewModel(new Dictionary <string, string> {
{ "searchTerm", "Enter organisation name" }
});
}
public virtual async Task <OrchestratorResponse <RegisterViewModel> > Register(RegisterViewModel registerUserViewModel, string returnUrl)
{
var returnModel = new OrchestratorResponse <RegisterViewModel>
{
Data = registerUserViewModel
};
try
{
await _mediator.SendAsync(new RegisterUserCommand
{
Id = Guid.NewGuid().ToString(),
FirstName = registerUserViewModel.FirstName,
LastName = registerUserViewModel.LastName,
Email = registerUserViewModel.Email,
Password = registerUserViewModel.Password,
ConfirmPassword = registerUserViewModel.ConfirmPassword,
HasAcceptedTermsAndConditions = registerUserViewModel.HasAcceptedTermsAndConditions,
ReturnUrl = returnUrl
});
var user = await _mediator.SendAsync(new GetUserByEmailAddressQuery
{
EmailAddress = registerUserViewModel.Email
});
LoginUser(user.Id, user.FirstName, user.LastName);
}
catch (InvalidRequestException ex)
{
_logger.Info(ex, ex.Message);
returnModel.Data.ErrorDictionary = ex.ErrorMessages;
returnModel.FlashMessage = new FlashMessageViewModel
{
Headline = "Errors to fix",
Message = "Check the following details:",
Severity = FlashMessageSeverityLevel.Error,
ErrorMessages = ex.ErrorMessages
};
}
catch (Exception ex)
{
_logger.Error(ex, ex.Message);
returnModel.FlashMessage = new FlashMessageViewModel
{
Headline = "Errors to fix",
Message = "Check the following details:",
Severity = FlashMessageSeverityLevel.Error,
ErrorMessages = new Dictionary <string, string> {
{ "", "Unexpected error occured" }
}
};
}
returnModel.Data = registerUserViewModel;
return(returnModel);
}
public async Task ThenShouldSkipSelectingChangeDateIfTrainingHasNotStarted(PaymentStatus paymentStatus)
{
_testApprenticeship.PaymentStatus = paymentStatus;
OrchestratorResponse <WhenToMakeChangeViewModel> response = await _sut.GetChangeStatusDateOfChangeViewModel("ABC123", "CDE321", ChangeStatusType.Stop, "user123");
response.Data.SkipStep.Should().BeTrue();
}
public async Task ThenShouldSkipSelectingChangeDateIfResumingApprenticeship()
{
_testApprenticeship.PaymentStatus = PaymentStatus.Paused;
OrchestratorResponse <WhenToMakeChangeViewModel> response = await _sut.GetChangeStatusDateOfChangeViewModel("ABC123", "CDE321", ChangeStatusType.Resume, "user123");
response.Data.SkipStep.Should().BeTrue();
}
public async Task ByResumingAnApprenticeship_ThenShouldSkipToConfirmationPage()
{
_testApprenticeship.PaymentStatus = PaymentStatus.Paused;
_testApprenticeship.PauseDate = MockDateTime.Object.Now.AddMonths(-1);
OrchestratorResponse <WhenToMakeChangeViewModel> response = await Orchestrator.GetChangeStatusDateOfChangeViewModel("ABC123", "CDE321", ChangeStatusType.Resume, "user123");
response.Data.SkipToConfirmationPage.Should().BeTrue();
}
public async Task IfStoppingThenStartedTrainingAndImmediateChangeSpecifiedShouldSetDateOfChangeToTodaysDate()
{
_testApprenticeship.StartDate = DateTime.UtcNow.AddMonths(-1); // Apprenticeship has already started
OrchestratorResponse <ConfirmationStateChangeViewModel> response = await _sut.GetChangeStatusConfirmationViewModel("ABC123", "CDE321", ChangeStatusType.Stop, WhenToMakeChangeOptions.Immediately, null, "user123");
response.Data.ChangeStatusViewModel.DateOfChange.DateTime.Should().Be(DateTime.UtcNow.Date);
}
private void SetFlashMessageOnModel <T>(OrchestratorResponse <T> model)
{
var flashMessage = GetFlashMessageViewModelFromCookie();
if (flashMessage != null)
{
model.FlashMessage = flashMessage;
}
}
