public async Task <Certificate> Start(StartCertificateRequest request)
{
using (var httpRequest = new HttpRequestMessage(HttpMethod.Post, "api/v1/certificates/start"))
{
return(await PostPutRequestWithResponse <StartCertificateRequest, Certificate>(httpRequest, request));
}
}
public async Task WhenHandlingStartCertificateRequest_AndThereIsExistingCertificate_NotDeleted_UpdatesCertificateForNewGrade(
StartCertificateRequest request,
Organisation organisationRecord,
Certificate existingCertificate,
CertificateData certificateData,
Standard standard,
Provider provider,
Domain.Entities.Learner learnerRecord)
{
// Arrange
existingCertificate.Status = CertificateStatus.Submitted;
certificateData.OverallGrade = CertificateGrade.Fail;
existingCertificate.CertificateData = JsonConvert.SerializeObject(certificateData);
_mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord);
_mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync(existingCertificate);
_mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard);
_mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord);
_mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider);
Certificate updatedCertficate = null;
_mockCertificateRepository.Setup(s => s.Update(It.IsAny <Certificate>(), It.IsAny <string>(), It.IsAny <string>(), true, null))
.Callback <Certificate, string, string, bool, string>((cert, username, action, updateLogs, reason) =>
{
updatedCertficate = cert;
}).ReturnsAsync(updatedCertficate);
// Act
var response = await _sut.Handle(request, new CancellationToken());
// Assertions
updatedCertficate.Status.Should().Be(CertificateStatus.Draft);
_mockCertificateRepository.Verify(s => s.Update(existingCertificate, request.Username, CertificateActions.Restart, true, null), Times.Once);
}
public async Task WhenHandlingStartCertificateRequest_AndNoExistingCertificate_StandardUIdSet_CreatesNewCertificate_WithVersionDetails(
StartCertificateRequest request,
Domain.Entities.Learner learnerRecord,
Organisation organisationRecord,
Provider provider,
Certificate stubCertificate,
Standard standard)
{
// Arrange
learnerRecord.FundingModel = 81;
_mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null);
_mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord);
_mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord);
_mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider);
_mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard);
Certificate createdCertificate = null;
_mockCertificateRepository.Setup(s => s.New(It.IsAny <Certificate>())).Callback <Certificate>((cert) =>
{
createdCertificate = cert;
}).ReturnsAsync(stubCertificate);
// Act
var response = await _sut.Handle(request, new CancellationToken());
// Assertions
response.Should().BeEquivalentTo(stubCertificate);
createdCertificate.Should().BeEquivalentTo(new
{
request.Uln,
request.StandardCode,
ProviderUkPrn = learnerRecord.UkPrn,
OrganisationId = organisationRecord.Id,
CreatedBy = request.Username,
Status = CertificateStatus.Draft,
CertificateReference = string.Empty,
learnerRecord.LearnRefNumber,
CreateDay = DateTime.UtcNow.Date,
IsPrivatelyFunded = false,
StandardUId = standard.StandardUId
});
var certData = JsonConvert.DeserializeObject <CertificateData>(createdCertificate.CertificateData);
certData.Should().BeEquivalentTo(new
{
LearnerGivenNames = learnerRecord.GivenNames,
LearnerFamilyName = learnerRecord.FamilyName,
LearningStartDate = learnerRecord.LearnStartDate,
FullName = $"{learnerRecord.GivenNames} {learnerRecord.FamilyName}",
ProviderName = provider.Name,
StandardName = standard.Title,
StandardReference = standard.IfateReferenceNumber,
StandardLevel = standard.Level,
StandardPublicationDate = standard.VersionApprovedForDelivery,
Version = standard.Version,
CourseOption = request.CourseOption
});
}
public async Task WhenHandlingStartCertificateRequest_AndNoExistingCertificate_CreatesNewCertificate_WhenStandardUIdNotSet(
StartCertificateRequest request,
Domain.Entities.Learner learnerRecord,
Organisation organisationRecord,
Provider provider,
Certificate stubCertificate,
IEnumerable <Standard> standards)
{
// Arrange
request.StandardUId = null;
learnerRecord.FundingModel = 81;
_mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null);
_mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord);
_mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord);
_mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider);
_mockStandardService.Setup(s => s.GetStandardVersionsByLarsCode(learnerRecord.StdCode)).ReturnsAsync(standards);
Certificate createdCertificate = null;
_mockCertificateRepository.Setup(s => s.New(It.IsAny <Certificate>())).Callback <Certificate>((cert) =>
{
createdCertificate = cert;
}).ReturnsAsync(stubCertificate);
// Act
var response = await _sut.Handle(request, new CancellationToken());
// Assertions
response.Should().BeEquivalentTo(stubCertificate);
createdCertificate.Should().BeEquivalentTo(new
{
request.Uln,
request.StandardCode,
ProviderUkPrn = learnerRecord.UkPrn,
OrganisationId = organisationRecord.Id,
CreatedBy = request.Username,
Status = CertificateStatus.Draft,
CertificateReference = string.Empty,
learnerRecord.LearnRefNumber,
CreateDay = DateTime.UtcNow.Date,
IsPrivatelyFunded = false
});
var certData = JsonConvert.DeserializeObject <CertificateData>(createdCertificate.CertificateData);
certData.Should().BeEquivalentTo(new
{
LearnerGivenNames = learnerRecord.GivenNames,
LearnerFamilyName = learnerRecord.FamilyName,
LearningStartDate = learnerRecord.LearnStartDate,
FullName = $"{learnerRecord.GivenNames} {learnerRecord.FamilyName}",
ProviderName = provider.Name,
StandardName = standards.OrderByDescending(s => s.VersionMajor).ThenByDescending(t => t.VersionMinor).First().Title
});
}
private async Task <EpaDetails> CreateNewEpa(CreateBatchEpaRequest request)
{
_logger.LogInformation("CreateNewEpa Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (certificate is null)
{
_logger.LogInformation("CreateNewEpa Before StartCertificateRequest");
var startCertificateRequest = new StartCertificateRequest {
StandardCode = request.StandardCode, UkPrn = request.UkPrn, Uln = request.Uln, Username = ExternalApiConstants.ApiUserName
};
certificate = await _mediator.Send(startCertificateRequest);
}
else
{
certificate = EpaHelpers.ResetCertificateData(certificate);
}
if (certificate is null)
{
_logger.LogError($"CreateNewEpa StartCertificateRequest did not create Certificate for Uln {request.Uln} StandardCode {request.StandardCode}");
throw new NotFound();
}
certificate.Status = Domain.Consts.CertificateStatus.Draft;
_logger.LogInformation("CreateNewEpa Before Resetting Certificate Data");
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
_logger.LogInformation("CreateNewEpa Before Adding EPAs");
if (request.EpaDetails?.Epas != null)
{
foreach (var epa in request.EpaDetails.Epas)
{
epa.EpaOutcome = EpaHelpers.NormalizeEpaOutcome(epa.EpaOutcome);
certData.EpaDetails.Epas.Add(epa);
}
}
var latestEpaRecord = certData.EpaDetails.Epas.OrderByDescending(epa => epa.EpaDate).FirstOrDefault();
certData.EpaDetails.LatestEpaDate = latestEpaRecord?.EpaDate;
certData.EpaDetails.LatestEpaOutcome = latestEpaRecord?.EpaOutcome;
_logger.LogInformation("CreateNewEpa Before Update CertificateData");
certificate.CertificateData = JsonConvert.SerializeObject(certData);
_logger.LogInformation("CreateNewEpa Before Update Cert in db");
await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, CertificateActions.Epa);
return(certData.EpaDetails);
}
public async Task WhenHandlingStartCertificateRequest_AndThereIsExistingCertificate_WhichIsDeleted_ResetCertificateData(
StartCertificateRequest request,
Organisation organisationRecord,
Certificate existingCertificate,
Domain.Entities.Learner learnerRecord,
CertificateData certificateData,
Standard standard,
Provider provider,
Certificate stubCertificate)
{
// Arrange
learnerRecord.FundingModel = 81;
existingCertificate.Status = CertificateStatus.Deleted;
existingCertificate.CertificateData = JsonConvert.SerializeObject(certificateData);
_mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord);
_mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync(existingCertificate);
_mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord);
_mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard);
_mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider);
Certificate updatedCertficate = null;
_mockCertificateRepository.Setup(s => s.Update(It.IsAny <Certificate>(), It.IsAny <string>(), It.IsAny <string>(), true, null))
.Callback <Certificate, string, string, bool, string>((cert, username, action, updateLogs, reason) =>
{
updatedCertficate = cert;
}).ReturnsAsync(stubCertificate);
// Act
var response = await _sut.Handle(request, new CancellationToken());
// Assertions
updatedCertficate.IsPrivatelyFunded.Should().BeFalse();
var responseCertData = JsonConvert.DeserializeObject <CertificateData>(updatedCertficate.CertificateData);
responseCertData.LearnerGivenNames.Should().Be(learnerRecord.GivenNames);
responseCertData.LearnerFamilyName.Should().Be(learnerRecord.FamilyName);
responseCertData.LearningStartDate.Should().Be(learnerRecord.LearnStartDate);
responseCertData.FullName.Should().Be($"{learnerRecord.GivenNames} {learnerRecord.FamilyName}");
_mockCertificateRepository.Verify(s => s.Update(existingCertificate, request.Username, null, true, null), Times.Once);
}
public void WhenHandlingStartCertificateRequest_AndNoExistingCertificate_WhenStandardUIdSet_ButVersionInvalid_ThrowsException(
StartCertificateRequest request,
Domain.Entities.Learner learnerRecord,
Organisation organisationRecord,
Provider provider,
Certificate stubCertificate,
IEnumerable <Standard> standards)
{
// Arrange
_mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null);
_mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord);
_mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord);
_mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider);
_mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync((Standard)null);
// Act
Func <Task> act = async() => { await _sut.Handle(request, new CancellationToken()); };
act.Should().Throw <InvalidOperationException>().WithMessage($"StandardUId:{request.StandardUId} not found, unable to populate certificate data");
}
private async Task <EpaDetails> CreateNewEpa(CreateBatchEpaRequest request)
{
_logger.LogInformation("CreateNewEpa Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (certificate is null)
{
_logger.LogInformation("CreateNewEpa Before StartCertificateRequest");
var startCertificateRequest = new StartCertificateRequest {
StandardCode = request.StandardCode, UkPrn = request.UkPrn, Uln = request.Uln, Username = ExternalApiConstants.ApiUserName, CourseOption = request.CourseOption, StandardUId = request.StandardUId
};
certificate = await _mediator.Send(startCertificateRequest);
}
else
{
certificate = EpaHelpers.ResetCertificateData(certificate);
}
if (certificate is null)
{
_logger.LogError($"CreateNewEpa StartCertificateRequest did not create Certificate for Uln {request.Uln} StandardCode {request.StandardCode}");
throw new NotFoundException();
}
certificate.Status = Domain.Consts.CertificateStatus.Draft;
_logger.LogInformation("CreateNewEpa Before Resetting Certificate Data");
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
_logger.LogInformation("CreateNewEpa Before Adding EPAs");
if (request.EpaDetails?.Epas != null)
{
foreach (var epa in request.EpaDetails.Epas)
{
epa.EpaOutcome = EpaHelpers.NormalizeEpaOutcome(epa.EpaOutcome);
certData.EpaDetails.Epas.Add(epa);
}
}
var latestEpaRecord = certData.EpaDetails.Epas.OrderByDescending(epa => epa.EpaDate).FirstOrDefault();
certData.EpaDetails.LatestEpaDate = latestEpaRecord?.EpaDate;
certData.EpaDetails.LatestEpaOutcome = latestEpaRecord?.EpaOutcome;
var epaAction = CertificateActions.Epa;
if (latestEpaRecord?.EpaOutcome.Equals(EpaOutcome.Fail, StringComparison.InvariantCultureIgnoreCase) == true)
{
certData.AchievementDate = latestEpaRecord?.EpaDate;
certData.OverallGrade = CertificateGrade.Fail;
certificate.Status = CertificateStatus.Submitted;
epaAction = CertificateActions.Submit;
}
else
{
certData.AchievementDate = null;
certData.OverallGrade = null;
certificate.Status = CertificateStatus.Draft;
}
_logger.LogInformation("CreateNewEpa Before Update CertificateData");
certificate.CertificateData = JsonConvert.SerializeObject(certData);
_logger.LogInformation("CreateNewEpa Before Update Cert in db");
await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, epaAction);
return(certData.EpaDetails);
}
public async Task <IActionResult> Start([FromBody] StartCertificateRequest request)
{
return(Ok(await _mediator.Send(request)));
}
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"));
}
