public GetBatchLearnerHandler(IMediator mediator, ILogger <GetBatchLearnerHandler> logger, IIlrRepository ilrRepository, IOrganisationQueryRepository organisationRepository)
{
_mediator = mediator;
_logger = logger;
_ilrRepository = ilrRepository;
_organisationRepository = organisationRepository;
}
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"));
}
});
});
}
public StartCertificateHandler(ICertificateRepository certificateRepository, IIlrRepository ilrRepository, IAssessmentOrgsApiClient assessmentOrgsApiClient,
IOrganisationQueryRepository organisationQueryRepository, ILogger <StartCertificateHandler> logger, IStandardService standardService)
{
_certificateRepository = certificateRepository;
_ilrRepository = ilrRepository;
_assessmentOrgsApiClient = assessmentOrgsApiClient;
_organisationQueryRepository = organisationQueryRepository;
_logger = logger;
_standardService = standardService;
}
public GetLearnerDetailHandler(IIlrRepository ilrRepository, ICertificateRepository certificateRepository,
IStaffCertificateRepository staffCertificateRepository, ILogger <GetLearnerDetailHandler> logger, IOrganisationQueryRepository organisationRepository, IStandardRepository standardRepository)
{
_ilrRepository = ilrRepository;
_certificateRepository = certificateRepository;
_staffCertificateRepository = staffCertificateRepository;
_logger = logger;
_organisationRepository = organisationRepository;
_standardRepository = standardRepository;
}
public CreateBatchCertificateHandler(ICertificateRepository certificateRepository, IIlrRepository ilrRepository,
IOrganisationQueryRepository organisationQueryRepository, IContactQueryRepository contactQueryRepository, ILogger <CreateBatchCertificateHandler> logger, IStandardService standardService, IRoatpApiClient roatpApiClient)
{
_certificateRepository = certificateRepository;
_ilrRepository = ilrRepository;
_organisationQueryRepository = organisationQueryRepository;
_contactQueryRepository = contactQueryRepository;
_logger = logger;
_standardService = standardService;
_roatpApiClient = roatpApiClient;
}
public SearchHandler(IRegisterQueryRepository registerQueryRepository, IOrganisationQueryRepository organisationRepository,
IIlrRepository ilrRepository, ICertificateRepository certificateRepository, ILogger <SearchHandler> logger, IContactQueryRepository contactRepository, IStandardService standardService)
{
_registerQueryRepository = registerQueryRepository;
_organisationRepository = organisationRepository;
_ilrRepository = ilrRepository;
_certificateRepository = certificateRepository;
_logger = logger;
_contactRepository = contactRepository;
_standardService = standardService;
BuildAlternates();
}
public UpdateBatchCertificateRequestValidator(
IStringLocalizer <BatchCertificateRequestValidator> localiser,
IOrganisationQueryRepository organisationQueryRepository,
IIlrRepository ilrRepository,
ICertificateRepository certificateRepository,
IStandardService standardService)
{
Include(new BatchCertificateRequestValidator(localiser, organisationQueryRepository, ilrRepository, 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 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"));
}
}
});
});
public BatchCertificateRequestValidator(
IStringLocalizer <BatchCertificateRequestValidator> localiser,
IOrganisationQueryRepository organisationQueryRepository,
IIlrRepository ilrRepository,
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) =>
{
bool validateCourseOption = true;
var collatedStandard = await standardService.GetStandard(m.StandardCode);
if (!string.IsNullOrEmpty(m.StandardReference))
{
if (m.StandardReference != collatedStandard?.ReferenceNumber)
{
validateCourseOption = false;
context.AddFailure("StandardReference and StandardCode must be for the same Standard");
}
}
// NOTE: This is not a nice way to do this BUT we cannot use another DependantRules()
if (validateCourseOption)
{
if (!collatedStandard.Options.Any() && !string.IsNullOrEmpty(m.CertificateData?.CourseOption))
{
context.AddFailure(new ValidationFailure("CourseOption", $"No course option available for this Standard. Must be empty"));
}
else if (collatedStandard.Options.Any() && !collatedStandard.Options.Any(o => o.Equals(m.CertificateData?.CourseOption, StringComparison.InvariantCultureIgnoreCase)))
{
string courseOptionsString = string.Join(", ", collatedStandard.Options);
context.AddFailure(new ValidationFailure("CourseOption", $"Invalid course option for this Standard. Must be one of the following: {courseOptionsString}"));
}
}
});
});
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, canellation) =>
{
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"));
}
}
});
});
public GetPipelinesCountHandler(IIlrRepository ilrRepository, ILogger <GetPipelinesCountHandler> logger)
{
_ilrRepository = ilrRepository;
_logger = logger;
}
public DeleteBatchEpaRequestValidator(IStringLocalizer <DeleteBatchEpaRequestValidator> 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) =>
{
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"));
}
}
});
});
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"));
}
public StaffIlrRepository(AssessorDbContext context, IIlrRepository ilrRepository, IDbConnection connection)
{
_context = context;
_ilrRepository = ilrRepository;
_connection = connection;
}
public ImportLearnerDetailHandler(IIlrRepository ilrRepository, ICertificateRepository certificateRepository, ILogger <ImportLearnerDetailHandler> logger)
{
_ilrRepository = ilrRepository;
_certificateRepository = certificateRepository;
_logger = logger;
}
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;
}
}
});
});
}
