public async Task <IActionResult> Start(CertificateStartViewModel vm)
{
_sessionService.Remove("CertificateSession");
var ukprn = _contextAccessor.HttpContext.User.FindFirst("http://schemas.portal.com/ukprn")?.Value;
var username = _contextAccessor.HttpContext.User
.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn")?.Value;
_logger.LogInformation(
$"Start of Certificate Start for ULN {vm.Uln} and Standard Code: {vm.StdCode} by user {username}");
var cert = await _certificateApiClient.Start(new StartCertificateRequest()
{
UkPrn = int.Parse(ukprn),
StandardCode = vm.StdCode,
Uln = vm.Uln,
Username = username
});
var organisation = await _organisationsApiClient.Get(ukprn);
var options = (await _certificateApiClient.GetOptions(cert.StandardCode)).Select(o => o.OptionName).ToList();
_sessionService.Set("CertificateSession", new CertificateSession()
{
CertificateId = cert.Id,
Uln = vm.Uln,
StandardCode = vm.StdCode,
Options = options
});
_logger.LogInformation(
$"New Certificate received for ULN {vm.Uln} and Standard Code: {vm.StdCode} with ID {cert.Id}");
return(RedirectToAction("Declare", "CertificateDeclaration"));
}
public async Task <IActionResult> Start(CertificateStartViewModel vm)
{
_sessionService.Remove(nameof(CertificateSession));
var ukprn = _contextAccessor.HttpContext.User.FindFirst("http://schemas.portal.com/ukprn")?.Value;
var username = _contextAccessor.HttpContext.User.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn")?.Value;
List <string> options = new List <string>();
var singleOption = string.Empty;
List <StandardVersion> versions = new List <StandardVersion>();
var startCertificateRequest = new StartCertificateRequest()
{
UkPrn = int.Parse(ukprn),
StandardCode = vm.StdCode,
Uln = vm.Uln,
Username = username
};
async Task RetrieveAndPopulateStandardOptions(string standardUId)
{
var optionsResult = await _standardVersionClient.GetStandardOptions(standardUId);
if (optionsResult != null && optionsResult.HasOptions())
{
if (optionsResult.OnlyOneOption())
{
singleOption = optionsResult.CourseOption.Single();
startCertificateRequest.CourseOption = singleOption;
}
options = optionsResult.CourseOption.ToList();
}
}
var learner = await _learnerApiClient.GetLearnerRecord(vm.StdCode, vm.Uln);
var versionsResult = await _standardVersionClient.GetStandardVersionsByLarsCode(vm.StdCode);
if (learner.VersionConfirmed && !string.IsNullOrEmpty(learner.Version))
{
var version = versionsResult.First(v => v.Version == learner.Version);
startCertificateRequest.StandardUId = version.StandardUId;
versions.Add(version);
if (!string.IsNullOrEmpty(learner.CourseOption))
{
options.Add(learner.CourseOption);
startCertificateRequest.CourseOption = learner.CourseOption;
}
else
{
await RetrieveAndPopulateStandardOptions(version.StandardUId);
}
}
else
{
versions = versionsResult.ToList();
if (versionsResult.Count() == 1)
{
startCertificateRequest.StandardUId = versionsResult.First().StandardUId;
await RetrieveAndPopulateStandardOptions(versionsResult.First().StandardUId);
}
}
_logger.LogInformation($"Start of Certificate Start for ULN {vm.Uln} and Standard Code: {vm.StdCode} by user {username}");
var cert = await _certificateApiClient.Start(startCertificateRequest);
var certificateSession = new CertificateSession()
{
CertificateId = cert.Id,
Uln = vm.Uln,
StandardCode = vm.StdCode,
StandardUId = startCertificateRequest.StandardUId,
Versions = Mapper.Map <List <StandardVersionViewModel> >(versions),
Options = options
};
_sessionService.Set(nameof(CertificateSession), certificateSession);
_logger.LogInformation($"New Certificate received for ULN {vm.Uln} and Standard Code: {vm.StdCode} with ID {cert.Id}");
if (versions.Count() > 1)
{
return(RedirectToAction("Version", "CertificateVersion"));
}
else if (!string.IsNullOrWhiteSpace(singleOption))
{
return(RedirectToAction("Declare", "CertificateDeclaration"));
}
else if (options.Count > 1)
{
return(RedirectToAction("Option", "CertificateOption"));
}
return(RedirectToAction("Declare", "CertificateDeclaration"));
}
public async Task WhenStartingANewCertificate_WithoutApprovalsData_WithSingleVersionNoOptions_GoesToDeclaration(CertificateStartViewModel model, ApprovalsLearnerResult learner, StandardVersion standard)
{
CertificateSession setSession = new CertificateSession();
learner.Version = null;
learner.CourseOption = null;
_mockStandardVersionClient.Setup(s => s.GetStandardVersionsByLarsCode(model.StdCode)).ReturnsAsync(new List <StandardVersion> {
standard
});
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(standard.StandardUId)).ReturnsAsync(new StandardOptions());
_mockLearnerApiClient.Setup(c => c.GetLearnerRecord(model.StdCode, model.Uln)).ReturnsAsync(learner);
_mockSessionService.Setup(c => c.Set(nameof(CertificateSession), It.IsAny <object>()))
.Callback <string, object>((key, session) =>
{
if (key == nameof(CertificateSession) && session is CertificateSession)
{
setSession = (CertificateSession)session;
}
});
var result = await _certificateController.Start(model) as RedirectToActionResult;
_mockCertificateApiClient.Verify(s => s.Start(It.Is <StartCertificateRequest>(
m => m.StandardCode == model.StdCode && m.Uln == model.Uln &&
m.Username == Username && m.UkPrn == Ukprn)));
setSession.CertificateId.Should().Be(CertificateId);
setSession.Uln.Should().Be(model.Uln);
setSession.StandardCode.Should().Be(model.StdCode);
setSession.Options.Should().BeEmpty();
setSession.Versions.Should().BeEquivalentTo(new List <StandardVersionViewModel> {
Mapper.Map <StandardVersionViewModel>(standard)
});
result.ControllerName.Should().Be("CertificateDeclaration");
result.ActionName.Should().Be("Declare");
}
public async Task WhenStartingANewCertificate_WithVersionSetFromApprovals_OptionRequiredButNotSet_GoesToOptionsPage(CertificateStartViewModel model, ApprovalsLearnerResult learner, StandardVersion version, StandardOptions options)
{
CertificateSession setSession = new CertificateSession();
version.LarsCode = model.StdCode;
learner.Version = version.Version;
learner.VersionConfirmed = true;
learner.CourseOption = string.Empty;
_mockLearnerApiClient.Setup(c => c.GetLearnerRecord(It.IsAny <int>(), It.IsAny <long>()))
.ReturnsAsync(learner);
_mockStandardVersionClient.Setup(c => c.GetStandardVersionsByLarsCode(It.IsAny <int>()))
.ReturnsAsync(new List <StandardVersion> {
version
});
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(version.StandardUId))
.ReturnsAsync(options);
_mockSessionService.Setup(c => c.Set(nameof(CertificateSession), It.IsAny <object>()))
.Callback <string, object>((key, session) =>
{
if (key == nameof(CertificateSession) && session is CertificateSession)
{
setSession = (CertificateSession)session;
}
});
var result = await _certificateController.Start(model) as RedirectToActionResult;
_mockCertificateApiClient.Verify(s => s.Start(It.Is <StartCertificateRequest>(
m => m.StandardCode == model.StdCode &&
m.Uln == model.Uln &&
m.Username == Username &&
m.UkPrn == Ukprn &&
m.StandardUId == version.StandardUId &&
m.CourseOption == null)));
setSession.CertificateId.Should().Be(CertificateId);
setSession.Uln.Should().Be(model.Uln);
setSession.StandardCode.Should().Be(model.StdCode);
setSession.Options.Should().BeEquivalentTo(options.CourseOption.ToList());
setSession.Versions.Count().Should().Be(1);
setSession.Versions.Single().StandardUId.Should().Be(version.StandardUId);
result.ControllerName.Should().Be("CertificateOption");
result.ActionName.Should().Be("Option");
}
public async Task WhenStartingANewCertificate_WithVersionSetFromApprovalsButNotConfirmed_GoesToVersionPage(CertificateStartViewModel model, ApprovalsLearnerResult learner, IEnumerable <StandardVersion> standards)
{
CertificateSession setSession = new CertificateSession();
learner.Version = standards.First().Version;
learner.CourseOption = null;
learner.VersionConfirmed = false;
_mockLearnerApiClient.Setup(c => c.GetLearnerRecord(It.IsAny <int>(), It.IsAny <long>()))
.ReturnsAsync(learner);
_mockStandardVersionClient.Setup(c => c.GetStandardVersionsByLarsCode(It.IsAny <int>())).ReturnsAsync(standards);
_mockSessionService.Setup(c => c.Set(nameof(CertificateSession), It.IsAny <object>()))
.Callback <string, object>((key, session) =>
{
if (key == nameof(CertificateSession) && session is CertificateSession)
{
setSession = (CertificateSession)session;
}
});
var result = await _certificateController.Start(model) as RedirectToActionResult;
_mockCertificateApiClient.Verify(s => s.Start(It.Is <StartCertificateRequest>(
m => m.StandardCode == model.StdCode &&
m.Uln == model.Uln &&
m.Username == Username &&
m.UkPrn == Ukprn)));
setSession.CertificateId.Should().Be(CertificateId);
setSession.Uln.Should().Be(model.Uln);
setSession.StandardCode.Should().Be(model.StdCode);
setSession.Options.Should().BeEmpty();
setSession.Versions.Should().BeEquivalentTo(Mapper.Map <List <StandardVersionViewModel> >(standards));
result.ControllerName.Should().Be("CertificateVersion");
result.ActionName.Should().Be("Version");
}
