public async Task Then_UpdateStandardData_Is_Called()
{
// Arrange
_mockOrgApiClient
.Setup(r => r.GetAppliedStandardVersionsForEPAO(It.IsAny <string>(), "ST0001"))
.ReturnsAsync(new List <AppliedStandardVersion> {
new AppliedStandardVersion {
IFateReferenceNumber = "ST0001", Title = "Title 1", Version = "1.0", LarsCode = 1, EPAChanged = false, ApprovedStatus = ApprovedStatus.NotYetApplied
},
new AppliedStandardVersion {
IFateReferenceNumber = "ST0001", Title = "Title 1", Version = "1.1", LarsCode = 1, EPAChanged = false, ApprovedStatus = ApprovedStatus.Approved
},
new AppliedStandardVersion {
IFateReferenceNumber = "ST0001", Title = "Title 1", Version = "1.2", LarsCode = 1, EPAChanged = false, ApprovedStatus = ApprovedStatus.NotYetApplied
},
});
// Act
var model = new StandardVersionViewModel()
{
IsConfirmed = true,
};
await _sut.ConfirmStandard(model, Guid.NewGuid(), "ST0001", "1.2");
// Assert
_mockApiClient.Verify(m => m.UpdateStandardData(It.IsAny <Guid>(), 1, "ST0001", "Title 1",
It.Is <List <string> >(x => x.Count == 1 && x[0] == "1.2"), StandardApplicationTypes.Version));
_mockQnaApiClient.Verify(m => m.UpdateApplicationData(It.IsAny <Guid>(), It.Is <ApplicationData>(x => x.ApplicationType == StandardApplicationTypes.Version)));
}
public async Task Then_Error_If_No_Versions_Selected()
{
// Arrange
_mockOrgApiClient
.Setup(r => r.GetAppliedStandardVersionsForEPAO(It.IsAny <string>(), "ST0001"))
.ReturnsAsync(new List <AppliedStandardVersion> {
new AppliedStandardVersion {
IFateReferenceNumber = "ST0001", Title = "Title 1", Version = "1.0", LarsCode = 1, EPAChanged = false, ApprovedStatus = ApprovedStatus.NotYetApplied
},
new AppliedStandardVersion {
IFateReferenceNumber = "ST0001", Title = "Title 1", Version = "1.1", LarsCode = 1, EPAChanged = false, ApprovedStatus = ApprovedStatus.NotYetApplied
},
});
// Act
var model = new StandardVersionViewModel()
{
IsConfirmed = true,
SelectedVersions = new List <string>()
{
}
};
var result = (await _sut.ConfirmStandard(model, Guid.NewGuid(), "ST0001", null)) as ViewResult;
// Assert
Assert.AreEqual("~/Views/Application/Standard/ConfirmStandard.cshtml", result.ViewName);
Assert.IsTrue(_sut.ModelState["SelectedVersions"].Errors.Any(x => x.ErrorMessage == "You must select at least one version"));
}
public IActionResult Index(Guid id)
{
var standardViewModel = new StandardVersionViewModel {
Id = id
};
return(View("~/Views/Application/Standard/FindStandard.cshtml", standardViewModel));
}
public async Task <IActionResult> Search(StandardVersionViewModel model)
{
if (string.IsNullOrEmpty(model.StandardToFind) || model.StandardToFind.Length <= 2)
{
ModelState.AddModelError(nameof(model.StandardToFind), "Enter a valid search string (more than 2 characters)");
TempData["ShowErrors"] = true;
return(RedirectToAction(nameof(Index), new { model.Id }));
}
var standards = await _standardVersionApiClient.GetLatestStandardVersions();
model.Results = standards
.Where(s => s.Title.Contains(model.StandardToFind, StringComparison.InvariantCultureIgnoreCase))
.ToList();
return(View("~/Views/Application/Standard/FindStandardResults.cshtml", model));
}
public void AndClickingBack_RedirectsToSearchResultPage_IfHasOneVersion(CertificateSession session, StandardVersionViewModel standardVersion)
{
session.Versions = new List <StandardVersionViewModel> {
standardVersion
};
var sessionString = JsonConvert.SerializeObject(session);
_mockSessionService.Setup(s => s.Get(nameof(CertificateSession))).Returns(sessionString);
var result = _certificateOptionController.Back() as RedirectToActionResult;
result.ControllerName.Should().Be("Search");
result.ActionName.Should().Be("Result");
}
public async Task WhenSelectingAVersion_WhenLoadingModel_WithOneVersion_WithOptions_RedirectsToOptionPage(CertificateSession session, StandardVersionViewModel standardVersion, StandardOptions options)
{
standardVersion.StandardUId = session.StandardUId;
session.Versions = new List <StandardVersionViewModel> {
standardVersion
};
var sessionString = JsonConvert.SerializeObject(session);
_mockSessionService.Setup(s => s.Get(nameof(CertificateSession))).Returns(sessionString);
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(session.StandardUId)).ReturnsAsync(options);
var result = await _certificateVersionController.Version(false) as RedirectToActionResult;
result.ControllerName.Should().Be("CertificateOption");
result.ActionName.Should().Be("Option");
_mockSessionService.Verify(s => s.Set(nameof(CertificateSession), It.Is <CertificateSession>(c => c.Options.SequenceEqual(options.CourseOption.ToList()) && c.StandardUId == standardVersion.StandardUId)));
}
public async Task WhenSelectingAVersion_WhenLoadingModel_WithOneVersion_WithNoOptions_RedirectsToDeclaration(CertificateSession session, StandardVersionViewModel standardVersion)
{
standardVersion.StandardUId = session.StandardUId;
session.Versions = new List <StandardVersionViewModel> {
standardVersion
};
var sessionString = JsonConvert.SerializeObject(session);
_mockSessionService.Setup(s => s.Get(nameof(CertificateSession))).Returns(sessionString);
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(session.StandardUId)).ReturnsAsync(new StandardOptions());
var result = await _certificateVersionController.Version(false) as RedirectToActionResult;
result.ControllerName.Should().Be("CertificateDeclaration");
result.ActionName.Should().Be("Declare");
}
public async Task <IActionResult> ConfirmStandard(Guid id, string standardReference, string version)
{
var application = await _applicationApiClient.GetApplication(id);
if (!CanUpdateApplicationAsync(application))
{
return(RedirectToAction("Applications", "Application"));
}
var org = await _orgApiClient.GetEpaOrganisation(application.OrganisationId.ToString());
var standardVersions = (await _orgApiClient.GetAppliedStandardVersionsForEPAO(org?.OrganisationId, standardReference))
.OrderBy(s => s.Version);
var earliestStandard = standardVersions.FirstOrDefault();
var latestStandard = standardVersions.LastOrDefault();
bool anyExistingVersions = standardVersions.Any(x => x.ApprovedStatus == ApprovedStatus.Approved || x.ApplicationStatus == ApplicationStatus.Submitted);
var allPreviousWithdrawalsForStandard = await _applicationApiClient.GetAllWithdrawnApplicationsForStandard(application.OrganisationId, latestStandard.LarsCode);
var previousApplications = await _applicationApiClient.GetPreviousApplicationsForStandard(application.OrganisationId, standardReference);
if (!string.IsNullOrWhiteSpace(version))
{
// specific version selected (from standversion view)
var standardViewModel = new StandardVersionViewModel
{
Id = id,
StandardReference = standardReference,
FromStandardsVersion = true
};
standardViewModel.SelectedStandard = (StandardVersion)standardVersions.FirstOrDefault(x => x.Version == version);
standardViewModel.EarliestVersionEffectiveFrom = standardViewModel.SelectedStandard.VersionEarliestStartDate;
standardViewModel.Results = new List <StandardVersion>()
{
standardViewModel.SelectedStandard
};
standardViewModel.ApplicationStatus = await ApplicationStandardStatus(application, standardReference, new List <string>() { version });
return(View("~/Views/Application/Standard/ConfirmStandard.cshtml", standardViewModel));
}
else if (anyExistingVersions)
{
// existing approved versions for this standard
var model = new StandardVersionApplicationViewModel {
Id = id, StandardReference = standardReference
};
model.SelectedStandard = new StandardVersionApplication(latestStandard);
model.Results = ApplyVersionStatuses(standardVersions, allPreviousWithdrawalsForStandard, previousApplications).OrderByDescending(x => x.Version).ToList();
return(View("~/Views/Application/Standard/StandardVersion.cshtml", model));
}
else
{
// no existing approved versions for this standard
var standardViewModel = new StandardVersionViewModel
{
Id = id,
StandardReference = standardReference,
FromStandardsVersion = false
};
standardViewModel.Results = standardVersions.Select(s => (StandardVersion)s).ToList();
standardViewModel.SelectedStandard = (StandardVersion)latestStandard;
standardViewModel.EarliestVersionEffectiveFrom = earliestStandard.VersionEarliestStartDate;
if (standardVersions.Count() == 1)
{
standardViewModel.ApplicationStatus = await ApplicationStandardStatus(application, standardReference, new List <string>() { standardVersions.First().Version });
}
return(View("~/Views/Application/Standard/ConfirmStandard.cshtml", standardViewModel));
}
}
public async Task <IActionResult> ConfirmStandard(StandardVersionViewModel model, Guid id, string standardReference, string version)
{
var application = await _applicationApiClient.GetApplication(id);
if (!CanUpdateApplicationAsync(application))
{
return(RedirectToAction("Applications", "Application"));
}
var org = await _orgApiClient.GetEpaOrganisation(application.OrganisationId.ToString());
var standardVersions = (await _orgApiClient.GetAppliedStandardVersionsForEPAO(org?.OrganisationId, standardReference))
.OrderBy(s => s.Version);
bool anyExistingVersions = standardVersions.Any(x => x.ApprovedStatus == ApprovedStatus.Approved || x.ApplicationStatus == ApplicationStatus.Submitted);
AppliedStandardVersion selectedStandard = null;
string applicationStatus = null;
List <string> versions = null;
if (string.IsNullOrWhiteSpace(version))
{
selectedStandard = standardVersions.LastOrDefault();
versions = model.SelectedVersions ?? new List <string> {
selectedStandard.Version
};
if (model.SelectedVersions != null)
{
applicationStatus = await ApplicationStandardStatus(application, standardReference, model.SelectedVersions);
}
}
else
{
selectedStandard = standardVersions.FirstOrDefault(x => x.Version == version);
versions = new List <string> {
selectedStandard.Version
};
}
// check that the confirm checkbox has been selected
if (!model.IsConfirmed)
{
ModelState.AddModelError(nameof(model.IsConfirmed), "Confirm you have read the assessment plan");
TempData["ShowConfirmedError"] = true;
}
// check that a version has been selected
if (string.IsNullOrWhiteSpace(version) &&
standardVersions.Count() > 1 &&
(model.SelectedVersions == null || !model.SelectedVersions.Any()))
{
ModelState.AddModelError(nameof(model.SelectedVersions), "You must select at least one version");
TempData["ShowVersionError"] = true;
}
if (!ModelState.IsValid || !string.IsNullOrWhiteSpace(applicationStatus))
{
model.Results = string.IsNullOrWhiteSpace(version) ? standardVersions.Select(s => (StandardVersion)s).ToList() :
new List <StandardVersion>()
{
selectedStandard
};
model.SelectedStandard = (StandardVersion)selectedStandard;
model.ApplicationStatus = applicationStatus;
return(View("~/Views/Application/Standard/ConfirmStandard.cshtml", model));
}
else if (anyExistingVersions)
{
await _applicationApiClient.UpdateStandardData(id, selectedStandard.LarsCode, selectedStandard.IFateReferenceNumber, selectedStandard.Title, versions, StandardApplicationTypes.Version);
// update QnA application data for the Application Type
var applicationData = await _qnaApiClient.GetApplicationData(application.ApplicationId);
applicationData.ApplicationType = StandardApplicationTypes.Version;
await _qnaApiClient.UpdateApplicationData(application.ApplicationId, applicationData);
}
else
{
await _applicationApiClient.UpdateStandardData(id, selectedStandard.LarsCode, selectedStandard.IFateReferenceNumber, selectedStandard.Title, versions, StandardApplicationTypes.Full);
}
return(RedirectToAction("SequenceSignPost", "Application", new { Id = id }));
}
