public async Task <Unit> Handle(CertificateReprintRequest request, CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.CertificateReference, request.LastName, request.AchievementDate);
if (certificate == null)
{
throw new NotFound();
}
if (certificate.Status == SFA.DAS.AssessorService.Domain.Consts.CertificateStatus.Reprint)
{
return(Unit.Value);
}
if (certificate.Status == SFA.DAS.AssessorService.Domain.Consts.CertificateStatus.Printed)
{
certificate.Status = SFA.DAS.AssessorService.Domain.Consts.CertificateStatus.Reprint;
await _certificateRepository.Update(certificate, request.Username,
SFA.DAS.AssessorService.Domain.Consts.CertificateActions.Reprint);
}
else
{
throw new NotFound();
}
return(Unit.Value);
}
private X509Certificate2 RetrieveCertificate(Signing signInfo)
{
if (signInfo.SigningCertificateInformation == null)
{
throw new ConfigurationErrorsException(
"No signing certificate information found in PMode to perform signing. "
+ "Please provide either a <CertificateFindCriteria/> or <PrivateKeyCertificate/> tag to the Security.Signing element");
}
if (signInfo.SigningCertificateInformation is CertificateFindCriteria certFindCriteria)
{
return(_repository.GetCertificate(
findType: certFindCriteria.CertificateFindType,
privateKeyReference: certFindCriteria.CertificateFindValue));
}
if (signInfo.SigningCertificateInformation is PrivateKeyCertificate embeddedCertInfo)
{
return(new X509Certificate2(
rawData: Convert.FromBase64String(embeddedCertInfo.Certificate),
password: embeddedCertInfo.Password,
keyStorageFlags:
X509KeyStorageFlags.Exportable
| X509KeyStorageFlags.MachineKeySet
| X509KeyStorageFlags.PersistKeySet));
}
throw new NotSupportedException(
"The signing certificate information specified in the PMode could not be used to retrieve the certificate. " +
"Please provide either a <CertificateFindCriteria/> or <PrivateKeyCertificate/> tag to the Security.Signing element");
}
private X509Certificate2 GetCertificate(MessagingContext messagingContext)
{
Decryption decryption = messagingContext.ReceivingPMode.Security.Decryption;
if (decryption.DecryptCertificateInformation == null)
{
throw new ConfigurationErrorsException(
"Cannot start decrypting: no certificate information found " +
$"in ReceivingPMode {messagingContext.ReceivingPMode.Id} to decrypt the message. " +
"Please use either a <CertificateFindCriteria/> or <PrivateKeyCertificate/> to specify the certificate information");
}
if (decryption.DecryptCertificateInformation is CertificateFindCriteria certFindCriteria)
{
return(_certificateRepository.GetCertificate(
certFindCriteria.CertificateFindType,
certFindCriteria.CertificateFindValue));
}
if (decryption.DecryptCertificateInformation is PrivateKeyCertificate embeddedCertInfo)
{
return(new X509Certificate2(
rawData: Convert.FromBase64String(embeddedCertInfo.Certificate),
password: embeddedCertInfo.Password,
keyStorageFlags: X509KeyStorageFlags.Exportable
| X509KeyStorageFlags.MachineKeySet
| X509KeyStorageFlags.PersistKeySet));
}
throw new NotSupportedException(
"The decrypt-certificate information specified in the ReceivingPMode " +
$"{messagingContext.ReceivingPMode.Id} could not be used to retrieve the certificate used for decryption. " +
"Please use either a <CertificateFindCriteria/> or <PrivateKeyCertificate/> to specify the certificate information");
}
public async Task <Unit> Handle(UpdateCertificateWithReprintReasonCommand request, CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.CertificateReference);
if (certificate == null)
{
throw new NotFoundException();
}
try
{
var certificateData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
certificateData.ReprintReasons = ReprintReasonsToList(request.Reasons);
certificateData.IncidentNumber = request.IncidentNumber;
certificate.CertificateData = JsonConvert.SerializeObject(certificateData);
await _certificateRepository.Update(certificate, request.Username, CertificateActions.ReprintReason, true, request.OtherReason);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Unable to update certificate {request.CertificateReference} with reprint reason");
throw;
}
return(Unit.Value);
}
public CreateBatchCertificateRequestValidator(
IStringLocalizer <BatchCertificateRequestValidator> localiser,
IOrganisationQueryRepository organisationQueryRepository,
IIlrRepository ilrRepository,
ICertificateRepository certificateRepository,
IStandardService standardService)
{
Include(new BatchCertificateRequestValidator(localiser, organisationQueryRepository, ilrRepository, standardService));
RuleFor(m => m.CertificateReference).Empty().WithMessage("Certificate reference must be empty").DependentRules(() =>
{
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
var existingCertificate = await certificateRepository.GetCertificate(m.Uln, m.StandardCode);
var sumbittingEpao = await organisationQueryRepository.GetByUkPrn(m.UkPrn);
var learnerDetails = await ilrRepository.Get(m.Uln, m.StandardId.GetValueOrDefault());
if (existingCertificate != null && existingCertificate.Status != CertificateStatus.Deleted)
{
if (sumbittingEpao?.Id != existingCertificate.OrganisationId)
{
context.AddFailure(new ValidationFailure("CertificateData", $"Your organisation is not the creator of the EPA"));
}
else if (existingCertificate.Status == CertificateStatus.Draft)
{
var certData = JsonConvert.DeserializeObject <CertificateData>(existingCertificate.CertificateData);
if (!string.IsNullOrEmpty(certData.OverallGrade) && certData.AchievementDate.HasValue && !string.IsNullOrEmpty(certData.ContactPostCode))
{
context.AddFailure(new ValidationFailure("CertificateData", $"Certificate already exists: {existingCertificate.CertificateReference}"));
}
else if (!EpaOutcome.Pass.Equals(certData.EpaDetails?.LatestEpaOutcome, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("CertificateData", $"Latest EPA Outcome has not passed"));
}
}
else
{
context.AddFailure(new ValidationFailure("CertificateData", $"Certificate already exists: {existingCertificate.CertificateReference}"));
}
}
if (learnerDetails != null)
{
if (learnerDetails.CompletionStatus == (int)CompletionStatus.Withdrawn)
{
context.AddFailure(new ValidationFailure("LearnerDetails", "Cannot find the apprentice details"));
}
else if (learnerDetails.CompletionStatus == (int)CompletionStatus.TemporarilyWithdrawn)
{
context.AddFailure(new ValidationFailure("LearnerDetails", "Cannot find the apprentice details"));
}
}
else
{
context.AddFailure(new ValidationFailure("LearnerDetails", $"Learner details for ULN: {m.Uln} not found"));
}
});
});
}
private async Task <Certificate> UpdateCertificate(UpdateBatchCertificateRequest request)
{
_logger.LogInformation("UpdateCertificate Before Get Standard from API");
var standard = await _standardService.GetStandard(request.StandardCode);
_logger.LogInformation("UpdateCertificate Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (standard != null && certificate != null)
{
var certData = CombineCertificateData(JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData), request.CertificateData, standard);
_logger.LogInformation("UpdateCertificate Before Update CertificateData");
// need to update EPA Reference too
certData.EpaDetails.EpaReference = certificate.CertificateReference;
certificate.CertificateData = JsonConvert.SerializeObject(certData);
// adjust Status appropriately
if (certificate.Status == CertificateStatus.Deleted)
{
certificate.Status = CertificateStatus.Draft;
}
_logger.LogInformation("UpdateCertificate Before Update Cert in db");
await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, CertificateActions.Amend);
return(await CertificateHelpers.ApplyStatusInformation(_certificateRepository, _contactQueryRepository, certificate));
}
else
{
_logger.LogWarning($"UpdateCertificate Did not find Certificate for Uln {request.Uln} and StandardCode {request.StandardCode}");
throw new NotFound();
}
}
private X509Certificate2 RetrieveCertificate(SendingProcessingMode pmode)
{
Encryption encryptionSettings = pmode.Security.Encryption;
if (encryptionSettings.EncryptionCertificateInformation == null)
{
throw new ConfigurationErrorsException(
$"No encryption certificate information found in SendingPMode {pmode.Id} to perform encryption");
}
if (encryptionSettings.EncryptionCertificateInformation is CertificateFindCriteria certFindCriteria)
{
return(_certificateRepository.GetCertificate(
certFindCriteria.CertificateFindType,
certFindCriteria.CertificateFindValue));
}
if (encryptionSettings.EncryptionCertificateInformation is PublicKeyCertificate pubKeyCert)
{
return(new X509Certificate2(Convert.FromBase64String(pubKeyCert.Certificate), string.Empty));
}
throw new NotSupportedException(
$"The encryption certificate information specified in the Sending PMode {pmode.Id} could not be used to retrieve the certificate");
}
private async Task DeleteEpaDetails(DeleteBatchEpaRequest request)
{
_logger.LogInformation("DeleteEpaDetails Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (certificate is null)
{
throw new NotFound();
}
else
{
_logger.LogInformation("DeleteEpaDetails Before Removing EpaDetails CertificateData");
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
certData.EpaDetails = new EpaDetails {
Epas = new List <EpaRecord>()
};
certificate.CertificateData = JsonConvert.SerializeObject(certData);
await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, CertificateActions.Epa);
}
_logger.LogInformation("DeleteEpaDetails Before set Certificate to Deleted in db");
await _certificateRepository.Delete(request.Uln, request.StandardCode, ExternalApiConstants.ApiUserName, CertificateActions.Delete);
_logger.LogInformation("DeleteEpaDetails Certificate set to Deleted in db");
}
public async Task <Certificate> Handle(StartCertificateRequest request, CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (certificate == null)
{
certificate = await CreateNewCertificate(request);
}
else if (certificate.Status == Domain.Consts.CertificateStatus.Deleted)
{
_logger.LogInformation("CreateNewCertificate Before Get Ilr from db");
var ilr = await _ilrRepository.Get(request.Uln, request.StandardCode);
if (ilr != null)
{
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
certData.LearnerGivenNames = ilr.GivenNames;
certData.LearnerFamilyName = ilr.FamilyName;
certData.LearningStartDate = ilr.LearnStartDate;
certData.FullName = $"{ilr.GivenNames} {ilr.FamilyName}";
certificate.CertificateData = JsonConvert.SerializeObject(certData);
certificate.IsPrivatelyFunded = false;
await _certificateRepository.Update(certificate, request.Username, null);
}
}
return(certificate);
}
public async Task <Unit> Handle(CertificateReprintRequest request, CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.CertificateReference, request.LastName, request.AchievementDate);
if (certificate == null)
{
throw new NotFound();
}
if (certificate.Status == CertificateStatus.Reprint)
{
return(Unit.Value);
}
if (CertificateStatus.CanRequestDuplicateCertificate(certificate.Status))
{
certificate.Status = CertificateStatus.Reprint;
await _certificateRepository.Update(certificate, request.Username, CertificateActions.Reprint);
}
else
{
throw new NotFound();
}
return(Unit.Value);
}
private async Task <Certificate> CreateNewCertificate(CreateBatchCertificateRequest request)
{
_logger.LogInformation("CreateNewCertificate Before Get Ilr from db");
var ilr = await _ilrRepository.Get(request.Uln, request.StandardCode);
if (ilr is null)
{
_logger.LogWarning($"CreateNewCertificate Did not find ILR for Uln {request.Uln} and StandardCode {request.StandardCode}");
return(null);
}
_logger.LogInformation("CreateNewCertificate Before Get Organisation from db");
var organisation = await _organisationQueryRepository.GetByUkPrn(request.UkPrn);
_logger.LogInformation("CreateNewCertificate Before Get Standard from API");
var standard = await _standardService.GetStandard(ilr.StdCode);
_logger.LogInformation("CreateNewCertificate Before Get Provider from API");
var provider = await GetProviderFromUkprn(ilr.UkPrn);
var certData = CombineCertificateData(request.CertificateData, ilr, standard, provider);
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (certificate == null)
{
_logger.LogInformation("CreateNewCertificate Before create new Certificate");
certificate = await _certificateRepository.New(
new Certificate()
{
Uln = request.Uln,
StandardCode = request.StandardCode,
ProviderUkPrn = ilr.UkPrn,
OrganisationId = organisation.Id,
CreatedBy = ExternalApiConstants.ApiUserName,
CertificateData = JsonConvert.SerializeObject(certData),
Status = CertificateStatus.Draft, // NOTE: Web & Staff always creates Draft first
CertificateReference = string.Empty,
LearnRefNumber = ilr.LearnRefNumber,
CreateDay = DateTime.UtcNow.Date
});
}
else
{
_logger.LogInformation("CreateNewCertificate Before resurrecting deleted Certificate");
certData.EpaDetails.EpaReference = certificate.CertificateReference;
certificate.CertificateData = JsonConvert.SerializeObject(certData);
certificate.Status = CertificateStatus.Draft;
await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, CertificateActions.Start);
}
_logger.LogInformation(LoggingConstants.CertificateStarted);
_logger.LogInformation($"Certificate with ID: {certificate.Id} Started with reference of {certificate.CertificateReference}");
return(await CertificateHelpers.ApplyStatusInformation(_certificateRepository, _contactQueryRepository, certificate));
}
public GetBatchCertificateRequestValidator(IStringLocalizer <GetBatchCertificateRequestValidator> localiser, IOrganisationQueryRepository organisationQueryRepository, ILearnerRepository learnerRepository, ICertificateRepository certificateRepository, IStandardService standardService)
{
RuleFor(m => m.UkPrn).InclusiveBetween(10000000, 99999999).WithMessage("The UKPRN should contain exactly 8 numbers");
RuleFor(m => m.FamilyName).NotEmpty().WithMessage("Provide apprentice family name");
RuleFor(m => m.StandardCode).GreaterThan(0).WithMessage("Provide a valid Standard");
RuleFor(m => m.Uln).InclusiveBetween(1000000000, 9999999999).WithMessage("ULN should contain exactly 10 numbers").DependentRules(() =>
{
When(m => m.StandardCode > 0 && !string.IsNullOrEmpty(m.FamilyName), () =>
{
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
// NOTE: Currently we're making the Certificate & Learner/ILR record both mandatory - this is wrong fixing it!
var submittingEpao = await organisationQueryRepository.GetByUkPrn(m.UkPrn);
if (submittingEpao is null)
{
context.AddFailure(new ValidationFailure("UkPrn", "Specified UKPRN not found"));
}
else
{
var existingCertificateCreatedByCallingEpao = await certificateRepository.GetCertificateByUlnOrgIdLastnameAndStandardCode(m.Uln, submittingEpao.EndPointAssessorOrganisationId, m.FamilyName, m.StandardCode);
if (existingCertificateCreatedByCallingEpao == null)
{
var requestedLearner = await learnerRepository.Get(m.Uln, m.StandardCode);
var existingCertificate = await certificateRepository.GetCertificate(m.Uln, m.StandardCode);
var providedStandards = await standardService.GetEpaoRegisteredStandards(submittingEpao.EndPointAssessorOrganisationId);
if (!providedStandards.Any(s => s.StandardCode == m.StandardCode))
{
context.AddFailure(new ValidationFailure("StandardCode", "Your organisation is not approved to assess this Standard"));
}
if (existingCertificate != null)
{
var certData = JsonConvert.DeserializeObject <CertificateData>(existingCertificate.CertificateData ?? "{}");
if (!certData.LearnerFamilyName.Equals(m.FamilyName, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("FamilyName", $"Cannot find apprentice with the specified Uln, FamilyName & Standard"));
}
else if (!EpaOutcome.Pass.Equals(certData.EpaDetails?.LatestEpaOutcome, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("Uln", $"Cannot find certificate with the specified Uln, FamilyName & Standard"));
}
}
else if (requestedLearner is null || !string.Equals(requestedLearner.FamilyName, m.FamilyName, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("Uln", "Cannot find apprentice with the specified Uln, FamilyName & Standard"));
}
}
}
});
/// <summary>
/// Client side request for authorization token
/// </summary>
/// <param name="context">context</param>
/// <param name="subject">subject of the request (null to default use client configuration)</param>
/// <returns>JWT token</returns>
public async Task <string> CreateRequestToken(IWorkContext context, string subject = null)
{
Verify.IsNotNull(nameof(context), context);
context = context.WithTag(_tag);
X509Certificate2 certificate = await _certificateRepository.GetCertificate(context, _clientTokenManagerConfiguration.RequestSigningCertificateKey, true);
subject = subject ?? _clientTokenManagerConfiguration.TokenKey.RequestingSubject;
Verify.IsNotEmpty(nameof(subject), subject);
string token = new JwtTokenBuilder()
.AddSubject(subject)
.SetIssuer(_clientTokenManagerConfiguration.RequestingIssuer)
.SetExpires(DateTime.Now.AddMinutes(5))
.SetIssuedAt(DateTime.Now)
.SetCertificate(certificate)
.Build();
return(token);
}
public async Task <Certificate> Handle(StaffCertificateDuplicateRequest request,
CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.Id);
if (CertificateStatus.CanRequestDuplicateCertificate(certificate.Status))
{
certificate.Status = CertificateStatus.Reprint;
await _certificateRepository.Update(certificate, request.Username, action : CertificateActions.Reprint);
}
return(certificate);
}
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 <LearnerDetail> Handle(LearnerDetailRequest request, CancellationToken cancellationToken)
{
var learner = await _ilrRepository.Get(request.Uln, request.StdCode);
var standard = await _standardRepository.GetStandardCollationByStandardId(request.StdCode);
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StdCode);
var logs = new List <CertificateLogSummary>();
var certificateData = new CertificateData();
var epao = new Organisation();
if (certificate != null)
{
logs = await _staffCertificateRepository.GetCertificateLogsFor(certificate.Id, request.AllRecords);
if (logs.Count() > 1)
{
CalculateDifferences(logs);
}
certificateData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData) ?? new CertificateData();
epao = await _organisationRepository.Get(certificate.OrganisationId) ?? new Organisation();
}
var learnerDetail = new LearnerDetail()
{
Uln = request.Uln,
FamilyName = !string.IsNullOrEmpty(certificateData.LearnerFamilyName) ? certificateData.LearnerFamilyName : learner?.FamilyName,
GivenNames = !string.IsNullOrEmpty(certificateData.LearnerGivenNames) ? certificateData.LearnerGivenNames : learner?.GivenNames,
LearnStartDate = certificateData.LearningStartDate.HasValue ? certificateData.LearningStartDate : learner?.LearnStartDate,
StandardCode = (certificate?.StandardCode).HasValue ? certificate.StandardCode : standard?.StandardId ?? 0,
Standard = !string.IsNullOrEmpty(certificateData.StandardName) ? certificateData.StandardName : standard?.Title,
Level = certificateData.StandardLevel > 0 ? certificateData.StandardLevel : standard?.StandardData?.Level ?? 0,
CertificateReference = certificate?.CertificateReference,
CertificateStatus = certificate?.Status,
OverallGrade = certificateData.OverallGrade,
AchievementDate = certificateData.AchievementDate, //?.UtcToTimeZoneTime(),
Option = certificateData.CourseOption,
OrganisationName = epao.EndPointAssessorName,
OrganisationId = epao.EndPointAssessorOrganisationId,
CertificateLogs = logs,
FundingModel = learner?.FundingModel,
CompletionStatus = learner?.CompletionStatus,
CompletionStatusDescription = FormatCompletionStatusDescription(learner?.CompletionStatus),
IsPrivatelyFunded = certificate?.IsPrivatelyFunded,
CertificateId = certificate?.Id
};
return(learnerDetail);
}
private async Task <Certificate> GetCertificate(GetBatchCertificateRequest request)
{
_logger.LogInformation("GetCertificate Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
_logger.LogInformation("GetCertificate Before Get Searching Organisation from db");
var searchingOrganisation = await _organisationQueryRepository.GetByUkPrn(request.UkPrn);
var allowedCertificateStatus = new string[] { CertificateStatus.Draft, CertificateStatus.Submitted, CertificateStatus.Printed, CertificateStatus.Reprint };
if (certificate != null && searchingOrganisation != null && allowedCertificateStatus.Contains(certificate.Status))
{
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
if (string.Equals(certData.LearnerFamilyName, request.FamilyName, StringComparison.InvariantCultureIgnoreCase))
{
certificate = await CertificateHelpers.ApplyStatusInformation(_certificateRepository, _contactQueryRepository, certificate);
if (!EpaOutcome.Pass.Equals(certData.EpaDetails?.LatestEpaOutcome, StringComparison.InvariantCultureIgnoreCase))
{
// As EPA has not passed, only give access to basic information & EPA Details
certificate = RedactCertificateInformation(certificate, true);
}
if (certificate.OrganisationId != searchingOrganisation.Id)
{
var providedStandards = await _standardRepository.GetEpaoRegisteredStandards(searchingOrganisation.EndPointAssessorOrganisationId, short.MaxValue, null);
if (providedStandards.PageOfResults.Any(s => s.StandardCode == certificate.StandardCode))
{
// Shared standard but not the EPAO who created the certificate
certificate = RedactCertificateInformation(certificate, false);
}
else
{
certificate = null;
}
}
}
else
{
certificate = null;
}
}
else
{
certificate = null;
}
return(certificate);
}
private async Task <string> HandleSameSourceRequest(Ilr learner, ImportLearnerDetail importLearnerDetail, CancellationToken cancellationToken)
{
if (importLearnerDetail.Ukprn == learner.UkPrn)
{
if (importLearnerDetail.LearnActEndDate != null && importLearnerDetail.LearnStartDate == importLearnerDetail.LearnActEndDate)
{
return("IgnoreLearnActEndDateSameAsLearnStartDate");
}
if (importLearnerDetail.PlannedEndDate == learner.PlannedEndDate && importLearnerDetail.LearnStartDate == learner.LearnStartDate)
{
return(await UpdateIlrRecord(importLearnerDetail, true, learner));
}
if (importLearnerDetail.LearnStartDate > learner.LearnStartDate)
{
return(await UpdateIlrRecord(importLearnerDetail, false));
}
}
else
{
var certificate = await _certificateRepository.GetCertificate(importLearnerDetail.Uln.Value, importLearnerDetail.StdCode.Value);
if (certificate != null)
{
return("IgnoreUkprnChangedButCertficateAlreadyExists");
}
if (importLearnerDetail.FundingModel == 99 && learner.FundingModel != 99)
{
return("IgnoreFundingModelChangedTo99WhenPrevioulsyNot99");
}
if (importLearnerDetail.LearnActEndDate == null && learner.LearnActEndDate != null)
{
return(await UpdateIlrRecord(importLearnerDetail, false));
}
if (importLearnerDetail.LearnActEndDate != null && importLearnerDetail.PlannedEndDate > learner.PlannedEndDate)
{
return(await UpdateIlrRecord(importLearnerDetail, false));
}
if (importLearnerDetail.LearnStartDate > learner.LearnStartDate)
{
return(await UpdateIlrRecord(importLearnerDetail, false));
}
}
return("IgnoreOutOfDate");
}
protected override X509Certificate2 LoadCertificate()
{
if (String.IsNullOrWhiteSpace(_certificateSerialNr))
{
throw new InvalidOperationException("Unable to retrieve Certificate: No X509SerialNumber available.");
}
if (_certificateRepository == null)
{
throw new InvalidOperationException("Unable to retrieve Certificate: No CertificateRepository defined.");
}
return(_certificateRepository.GetCertificate(X509FindType.FindBySerialNumber, _certificateSerialNr));
}
public UpdateBatchEpaRequestValidator(IStringLocalizer <BatchEpaRequestValidator> localiser, IOrganisationQueryRepository organisationQueryRepository, IIlrRepository ilrRepository, ICertificateRepository certificateRepository, IStandardService standardService)
{
Include(new BatchEpaRequestValidator(localiser, organisationQueryRepository, ilrRepository, standardService));
RuleFor(m => m.EpaDetails.EpaReference).NotEmpty().WithMessage("Provide EPA reference").DependentRules(() =>
{
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
var existingCertificate = await certificateRepository.GetCertificate(m.Uln, m.StandardCode);
var sumbittingEpao = await organisationQueryRepository.GetByUkPrn(m.UkPrn);
if (existingCertificate is null || !string.Equals(existingCertificate.CertificateReference, m.EpaDetails.EpaReference, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("EpaReference", $"EPA not found"));
}
private async Task <Certificate> GetCertificate(GetBatchCertificateRequest request)
{
_logger.LogInformation("GetCertificate Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode, request.FamilyName, request.IncludeLogs);
_logger.LogInformation("GetCertificate Before Get Searching Organisation from db");
var searchingOrganisation = await _organisationQueryRepository.GetByUkPrn(request.UkPrn);
var allowedCertificateStatus = new[] { CertificateStatus.Draft, CertificateStatus.Submitted }.Concat(CertificateStatus.PrintProcessStatus);
if (certificate == null || searchingOrganisation == null || !allowedCertificateStatus.Contains(certificate.Status))
{
return(null);
}
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
certificate = await CertificateHelpers.ApplyStatusInformation(_certificateRepository, _contactQueryRepository, certificate);
if ((certificate.Status == CertificateStatus.Submitted || CertificateStatus.HasPrintProcessStatus(certificate.Status)) && certData.OverallGrade == CertificateGrade.Fail)
{
return(null);
}
else if (certificate.Status == CertificateStatus.Draft &&
EpaOutcome.Pass.Equals(certData.EpaDetails?.LatestEpaOutcome, StringComparison.InvariantCultureIgnoreCase) &&
certData.OverallGrade == null)
{
return(null);
}
if (certificate.OrganisationId != searchingOrganisation.Id)
{
var providedStandards = await _standardRepository.GetEpaoRegisteredStandards(searchingOrganisation.EndPointAssessorOrganisationId, int.MaxValue, 1);
if (providedStandards.PageOfResults.Any(s => s.StandardCode == certificate.StandardCode))
{
// Shared standard but not the EPAO who created the certificate
certificate = RedactCertificateInformation(certificate, false);
}
else
{
certificate = null;
}
}
return(certificate);
}
public async Task <Certificate> Handle(UpdateCertificateRequestReprintCommand request, CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.CertificateId);
if (certificate == null)
{
throw new NotFoundException();
}
if (certificate.Status != CertificateStatus.Reprint && CertificateStatus.CanRequestReprintCertificate(certificate.Status))
{
certificate.Status = CertificateStatus.Reprint;
await _certificateRepository.Update(certificate, request.Username, CertificateActions.Reprint);
}
return(certificate);
}
public UpdateBatchCertificateRequestValidator(IStringLocalizer <BatchCertificateRequestValidator> localiser, IOrganisationQueryRepository organisationQueryRepository, IIlrRepository ilrRepository, ICertificateRepository certificateRepository, IStandardService standardService)
{
Include(new BatchCertificateRequestValidator(localiser, organisationQueryRepository, ilrRepository, certificateRepository, standardService));
RuleFor(m => m.CertificateReference).NotEmpty().WithMessage("Provide the certificate reference").DependentRules(() =>
{
// TODO: ON-2130 Consider in the future how to merge both create & update versions as the Cert will always exist due to EPA
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
var existingCertificate = await certificateRepository.GetCertificate(m.Uln, m.StandardCode);
var sumbittingEpao = await organisationQueryRepository.GetByUkPrn(m.UkPrn);
if (existingCertificate is null || !string.Equals(existingCertificate.CertificateReference, m.CertificateReference, StringComparison.InvariantCultureIgnoreCase) ||
existingCertificate.Status == CertificateStatus.Deleted)
{
context.AddFailure(new ValidationFailure("CertificateReference", $"Certificate not found"));
}
public async Task <Certificate> Handle(StartCertificateRequest request, CancellationToken cancellationToken)
{
_logger.LogDebug($"Starting new certificate for EPAO UkPrn:{request.UkPrn}");
var organisation = await _organisationQueryRepository.GetByUkPrn(request.UkPrn);
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (certificate == null)
{
certificate = await CreateNewCertificate(request, organisation);
}
else
{
certificate = await UpdateExistingCertificate(request, organisation, certificate);
}
return(certificate);
}
private async Task <EpaDetails> UpdateEpaDetails(UpdateBatchEpaRequest request)
{
_logger.LogInformation("UpdateEpaDetails Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (certificate is null)
{
throw new NotFound();
}
else
{
certificate = EpaHelpers.ResetCertificateData(certificate);
}
_logger.LogInformation("UpdateEpaDetails Before Combining EpaDetails");
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
certData.EpaDetails = new EpaDetails {
EpaReference = certificate.CertificateReference, Epas = new List <EpaRecord>()
};
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("UpdateEpaDetails Before Update CertificateData");
certificate.CertificateData = JsonConvert.SerializeObject(certData);
_logger.LogInformation("UpdateEpaDetails Before Update Cert in db");
await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, CertificateActions.Epa);
return(certData.EpaDetails);
}
private async Task <Certificate> SubmitCertificate(SubmitBatchCertificateRequest request)
{
_logger.LogInformation("SubmitCertificate Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode);
if (certificate != null)
{
_logger.LogInformation("SubmitCertificate Before Update Certificate Status");
certificate.Status = CertificateStatus.Submitted;
_logger.LogInformation("SubmitCertificate Before Update Cert in db");
var submittedCertificate = await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, CertificateActions.Submit);
return(await CertificateHelpers.ApplyStatusInformation(_certificateRepository, _contactQueryRepository, submittedCertificate));
}
else
{
_logger.LogWarning($"SubmitCertificate Did not find Certificate for Uln {request.Uln} and StandardCode {request.StandardCode}");
return(null);
}
}
public CreateBatchEpaRequestValidator(IStringLocalizer <BatchEpaRequestValidator> localiser, IOrganisationQueryRepository organisationQueryRepository, IIlrRepository ilrRepository, ICertificateRepository certificateRepository, IStandardService standardService)
{
Include(new BatchEpaRequestValidator(localiser, organisationQueryRepository, ilrRepository, standardService));
RuleFor(m => m.EpaDetails.EpaReference).Empty().WithMessage("EPA reference must be empty").DependentRules(() =>
{
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
var existingCertificate = await certificateRepository.GetCertificate(m.Uln, m.StandardCode);
if (existingCertificate != null)
{
switch (existingCertificate.Status)
{
case CertificateStatus.Deleted:
break;
case CertificateStatus.Draft:
var certData = JsonConvert.DeserializeObject <CertificateData>(existingCertificate.CertificateData);
if (!string.IsNullOrEmpty(certData.OverallGrade) && certData.AchievementDate.HasValue && !string.IsNullOrEmpty(certData.ContactPostCode))
{
context.AddFailure(new ValidationFailure("EpaDetails", $"Certificate already exists, cannot create EPA record"));
}
else if (!string.IsNullOrEmpty(certData.EpaDetails?.LatestEpaOutcome))
{
context.AddFailure(new ValidationFailure("EpaDetails", $"EPA already provided for the learner"));
}
break;
default:
context.AddFailure(new ValidationFailure("EpaDetails", $"Certificate already exists, cannot create EPA record"));
break;
}
}
});
});
}
public CreateBatchEpaRequestValidator(IStringLocalizer <BatchEpaRequestValidator> localiser, IOrganisationQueryRepository organisationQueryRepository, ILearnerRepository learnerRepository, ICertificateRepository certificateRepository, IStandardService standardService)
{
Include(new BatchEpaRequestValidator(localiser, organisationQueryRepository, learnerRepository, standardService));
RuleFor(m => m.EpaDetails.EpaReference).Empty().WithMessage("EPA reference must be empty").DependentRules(() =>
{
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
var existingCertificate = await certificateRepository.GetCertificate(m.Uln, m.StandardCode);
if (existingCertificate != null)
{
var certData = JsonConvert.DeserializeObject <CertificateData>(existingCertificate.CertificateData);
var submittedCertificate = !(existingCertificate.Status == CertificateStatus.Draft || existingCertificate.Status == CertificateStatus.Deleted);
var outcomeIsAFail = certData.OverallGrade == CertificateGrade.Fail;
var outcomeIsAPass = !outcomeIsAFail;
var isDraftCertificate = existingCertificate.Status == CertificateStatus.Draft;
var canUpdateDraftCertificate = string.IsNullOrEmpty(certData.EpaDetails?.LatestEpaOutcome);
if (submittedCertificate && outcomeIsAPass)
{
context.AddFailure(new ValidationFailure("EpaDetails", $"Certificate already exists, cannot create EPA record"));
}
else if (submittedCertificate && outcomeIsAFail)
{
context.AddFailure(new ValidationFailure("EpaDetails", $"EPA already provided for the learner"));
}
else if (isDraftCertificate && !canUpdateDraftCertificate)
{
context.AddFailure(new ValidationFailure("EpaDetails", $"EPA already provided for the learner"));
}
}
});
});
}
public async Task <GetBatchLearnerResponse> Handle(GetBatchLearnerRequest request, CancellationToken cancellationToken)
{
// Get certificate will be called twice.
// The Get Certificate Handler contains will not return a certificate in certain scenarios
// but there is information stored in the certificate that we need for learner details
var standard = await _standardService.GetStandardVersionById(request.Standard);
if (standard != null)
{
var certificateFromRepository = await _certificateRepository.GetCertificate(request.Uln, standard.LarsCode, request.FamilyName);
var learner = await GetLearnerDetails(request, standard, certificateFromRepository);
var epaDetails = GetEpaDetailsFromCertificate(certificateFromRepository);
var certificateFromHandler = await GetCertificate(request, standard);
return(new GetBatchLearnerResponse {
Learner = learner, Certificate = certificateFromHandler, EpaDetails = epaDetails
});
}
return(new GetBatchLearnerResponse());
}
public GetBatchCertificateRequestValidator(IStringLocalizer <GetBatchCertificateRequestValidator> localiser, IOrganisationQueryRepository organisationQueryRepository, IIlrRepository ilrRepository, ICertificateRepository certificateRepository, IStandardService standardService)
{
RuleFor(m => m.UkPrn).InclusiveBetween(10000000, 99999999).WithMessage("The UKPRN should contain exactly 8 numbers");
RuleFor(m => m.FamilyName).NotEmpty().WithMessage("Provide apprentice family name");
RuleFor(m => m.StandardCode).GreaterThan(0).WithMessage("Provide a valid Standard").DependentRules(() =>
{
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
if (!string.IsNullOrEmpty(m.StandardReference))
{
var collatedStandard = await standardService.GetStandard(m.StandardReference);
if (m.StandardCode != collatedStandard?.StandardId)
{
context.AddFailure("StandardReference and StandardCode must be for the same Standard");
}
}
});
});
RuleFor(m => m.Uln).InclusiveBetween(1000000000, 9999999999).WithMessage("ULN should contain exactly 10 numbers").DependentRules(() =>
{
When(m => m.StandardCode > 0 && !string.IsNullOrEmpty(m.FamilyName), () =>
{
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
// NOTE: Currently we're making the Certificate & ILR record both mandatory
var requestedIlr = await ilrRepository.Get(m.Uln, m.StandardCode);
var sumbittingEpao = await organisationQueryRepository.GetByUkPrn(m.UkPrn);
if (requestedIlr is null || !string.Equals(requestedIlr.FamilyName, m.FamilyName, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("Uln", "ULN, FamilyName and Standard not found"));
}
else if (sumbittingEpao is null)
{
context.AddFailure(new ValidationFailure("UkPrn", "Specified UKPRN not found"));
}
else
{
var providedStandards = await standardService.GetEpaoRegisteredStandards(sumbittingEpao.EndPointAssessorOrganisationId);
if (!providedStandards.Any(s => s.StandardCode == m.StandardCode))
{
context.AddFailure(new ValidationFailure("StandardCode", "Your organisation is not approved to assess this Standard"));
}
}
});
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
var existingCertificate = await certificateRepository.GetCertificate(m.Uln, m.StandardCode);
if (existingCertificate is null)
{
// TODO: FUTURE WORK - ON-2130 Do Alan's Certificate Search THEN the ILR Search (which may be the validation down below)
}
else
{
var certData = JsonConvert.DeserializeObject <CertificateData>(existingCertificate.CertificateData ?? "{}");
if (!certData.LearnerFamilyName.Equals(m.FamilyName, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("FamilyName", $"Invalid family name"));
}
else if (!EpaOutcome.Pass.Equals(certData.EpaDetails?.LatestEpaOutcome, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("Uln", $"Latest EPA Outcome has not passed"));
}
}
});
});
