public GetBatchLearnerHandler(IMediator mediator, ILogger <GetBatchLearnerHandler> logger, ILearnerRepository learnerRepository, IOrganisationQueryRepository organisationRepository, IStandardService standardService, ICertificateRepository certificateRepository)
{
_mediator = mediator;
_logger = logger;
_learnerRepository = learnerRepository;
_organisationRepository = organisationRepository;
_standardService = standardService;
_certificateRepository = certificateRepository;
}
public LearnerManager(
ILearnerRepository learnerRepository,
IFeProviderRepository providerRepository,
ILogger <LearnerManager> logger)
{
_learnerRepository = learnerRepository;
_providerRepository = providerRepository;
_logger = logger;
}
public SubmissionService(ILearningObjectRepository learningObjectRepository,
ISubmissionRepository submissionRepository, ILearnerRepository learnerRepository,
ILectureRepository lectureRepository)
{
_learningObjectRepository = learningObjectRepository;
_submissionRepository = submissionRepository;
_learnerRepository = learnerRepository;
_lectureRepository = lectureRepository;
}
public StartCertificateHandler(ICertificateRepository certificateRepository, ILearnerRepository learnerRepository, IProvidersRepository providersRepository,
IOrganisationQueryRepository organisationQueryRepository, ILogger <StartCertificateHandler> logger, IStandardService standardService)
{
_certificateRepository = certificateRepository;
_learnerRepository = learnerRepository;
_providersRepository = providersRepository;
_organisationQueryRepository = organisationQueryRepository;
_logger = logger;
_standardService = standardService;
}
public GetLearnerDetailHandler(ILearnerRepository learnerRepository, ICertificateRepository certificateRepository,
IStaffCertificateRepository staffCertificateRepository, ILogger <GetLearnerDetailHandler> logger, IOrganisationQueryRepository organisationRepository, IStandardRepository standardRepository)
{
_learnerRepository = learnerRepository;
_certificateRepository = certificateRepository;
_staffCertificateRepository = staffCertificateRepository;
_logger = logger;
_organisationRepository = organisationRepository;
_standardRepository = standardRepository;
}
public LearningDeliveryManager(
ILearningDeliveryRepository learningDeliveryRepository,
ILearnerRepository learnerRepository,
ILocationService locationService,
ILogger <LearningDeliveryManager> logger)
{
_learningDeliveryRepository = learningDeliveryRepository;
_learnerRepository = learnerRepository;
_locationService = locationService;
_logger = logger;
}
public LearnerService(ILearnerRepository learnerRepository,
IUserService userService,
IGroupService groupService,
ICourseService courseService,
IOrganisationService organisationService)
{
_groupService = groupService;
_userService = userService;
_learnerRepository = learnerRepository;
_courseService = courseService;
_organisationService = organisationService;
}
public SearchHandler(IOrganisationQueryRepository organisationRepository,
ILearnerRepository learnerRepository, ICertificateRepository certificateRepository, ILogger <SearchHandler> logger, IContactQueryRepository contactRepository, IStandardService standardService)
{
_organisationRepository = organisationRepository;
_learnerRepository = learnerRepository;
_certificateRepository = certificateRepository;
_logger = logger;
_contactRepository = contactRepository;
_standardService = standardService;
BuildAlternates();
}
public CreateBatchCertificateHandler(ICertificateRepository certificateRepository, ILearnerRepository learnerRepository,
IOrganisationQueryRepository organisationQueryRepository, IContactQueryRepository contactQueryRepository,
ILogger <CreateBatchCertificateHandler> logger, IStandardService standardService, IProvidersRepository providersRepository)
{
_certificateRepository = certificateRepository;
_learnerRepository = learnerRepository;
_organisationQueryRepository = organisationQueryRepository;
_contactQueryRepository = contactQueryRepository;
_logger = logger;
_standardService = standardService;
_providersRepository = providersRepository;
}
public LearnerController(lmsContext context, ICourseRepository courseRepository, ILearnerRepository learnerRepository, IValidationService validationService)
{
_context = context;
_courseRepository = courseRepository;
_learnerRepository = learnerRepository;
_validationService = validationService;
_NotFound = new GenericResult {
Response = false, Message = "Record not found"
};
_Duplicate = new GenericResult {
Response = false, Message = "Record already exists. Cannot enter duplicate entry"
};
}
public FeProviderManager(
IFeProviderRepository feProviderRepository,
ILearnerRepository learnerRepository,
ILearningDeliveryRepository learningDeliveryRepository,
ILocationService locationService,
ILogger <FeProviderManager> logger)
{
_feProviderRepository = feProviderRepository;
_learnerRepository = learnerRepository;
_learningDeliveryRepository = learningDeliveryRepository;
_locationService = locationService;
_logger = logger;
}
public EnrollmentController(lmsContext context,
IEnrollmentRepository enrollmentRepository,
IInstructorRepository instructorRepository,
ILearnerRepository learnerRepository,
IValidationService validationService)
{
_context = context;
_enrollmentRepository = enrollmentRepository;
_instructorRepository = instructorRepository;
_learnerRepository = learnerRepository;
_validationService = validationService;
_NotFound = new GenericResult {
Response = false, Message = "Record not found"
};
}
public UpdateBatchCertificateRequestValidator(
IStringLocalizer <BatchCertificateRequestValidator> localiser,
IOrganisationQueryRepository organisationQueryRepository,
ILearnerRepository learnerRepository,
ICertificateRepository certificateRepository,
IStandardService standardService)
{
Include(new BatchCertificateRequestValidator(localiser, organisationQueryRepository, learnerRepository, 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 LearnerService(ILearnerRepository learnerRepository, IWorkspaceCreator workspaceCreator)
{
_learnerRepository = learnerRepository;
_workspaceCreator = workspaceCreator;
}
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 VARKRecommender(ILearningObjectRepository learningObjectRepository, ILearnerRepository learnerRepository)
{
_learningObjectRepository = learningObjectRepository;
_learnerRepository = learnerRepository;
}
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"));
}
}
}
});
public GetBatchLearnerRequestValidator(IStringLocalizer <GetBatchLearnerRequestValidator> 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.Standard).NotEmpty().WithMessage("Provide a Standard").DependentRules(() =>
{
RuleFor(m => m.Standard).CustomAsync(async(standard, context, cancellation) =>
{
var standardVersion = await standardService.GetStandardVersionById(standard);
if (standardVersion is null)
{
context.AddFailure(new ValidationFailure("Standard", "Standard not found"));
}
});
});
RuleFor(m => m.Uln).InclusiveBetween(1000000000, 9999999999).WithMessage("ULN should contain exactly 10 numbers").DependentRules(() =>
{
When(m => !string.IsNullOrEmpty(m.Standard) && !string.IsNullOrEmpty(m.FamilyName), () =>
{
RuleFor(m => m).CustomAsync(async(m, context, cancellation) =>
{
var standard = await standardService.GetStandardVersionById(m.Standard);
if (standard != null)
{
var requestedLearner = await learnerRepository.Get(m.Uln, standard.LarsCode);
var sumbittingEpao = await organisationQueryRepository.GetByUkPrn(m.UkPrn);
if (requestedLearner is null || !string.Equals(requestedLearner.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 == standard.LarsCode))
{
context.AddFailure(new ValidationFailure("StandardCode", "Your organisation is not approved to assess this Standard"));
}
}
}
});
public StaffLearnerRepository(AssessorDbContext context, ILearnerRepository learnerRepository, IDbConnection connection)
{
_context = context;
_learnerRepository = learnerRepository;
_connection = connection;
}
public GetCalculatedStandardVersionForApprenticeshipHandler(IStandardService standardService, ILearnerRepository learnerRepository)
{
_standardService = standardService;
_learnerRepository = learnerRepository;
}
public CreateBatchCertificateRequestValidator(
IStringLocalizer <BatchCertificateRequestValidator> localiser,
IOrganisationQueryRepository organisationQueryRepository,
ILearnerRepository learnerRepository,
ICertificateRepository certificateRepository,
IStandardService standardService)
{
Include(new BatchCertificateRequestValidator(localiser, organisationQueryRepository, learnerRepository, 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 learnerRepository.Get(m.Uln, m.StandardCode);
if (existingCertificate != null && existingCertificate.Status != CertificateStatus.Deleted)
{
var certData = JsonConvert.DeserializeObject <CertificateData>(existingCertificate.CertificateData);
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)
{
if (!string.IsNullOrEmpty(certData.OverallGrade))
{
context.AddFailure(new ValidationFailure("CertificateData", $"Certificate already exists: {existingCertificate.CertificateReference}"));
}
}
else if (existingCertificate.Status == CertificateStatus.Submitted && !string.IsNullOrWhiteSpace(certData.OverallGrade) && certData.OverallGrade.Equals(CertificateGrade.Fail, StringComparison.OrdinalIgnoreCase))
{
// A submitted fail can be re-created
}
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"));
}
// SV-1253 additional validation to check version and option
if (learnerDetails.VersionConfirmed && !string.IsNullOrWhiteSpace(learnerDetails.Version) && !string.IsNullOrWhiteSpace(m.CertificateData.Version))
{
if (learnerDetails.Version.Trim().ToUpperInvariant() != m.CertificateData.Version.Trim().ToUpperInvariant())
{
context.AddFailure(new ValidationFailure("LearnerDetails", "Incorrect version for learner"));
}
}
if (!string.IsNullOrWhiteSpace(learnerDetails.CourseOption) && !string.IsNullOrWhiteSpace(m.CertificateData.CourseOption))
{
if (learnerDetails.CourseOption.Trim().ToUpperInvariant() != m.CertificateData.CourseOption.Trim().ToUpperInvariant())
{
context.AddFailure(new ValidationFailure("LearnerDetails", "Incorrect course option for learner"));
}
}
}
else
{
context.AddFailure(new ValidationFailure("LearnerDetails", $"Learner details for ULN: {m.Uln} not found"));
}
});
});
}
public BatchCertificateRequestValidator(
IStringLocalizer <BatchCertificateRequestValidator> localiser,
IOrganisationQueryRepository organisationQueryRepository,
ILearnerRepository learnerRepository,
IStandardService standardService)
{
bool invalidVersionOrStandardMismatch = false;
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) =>
{
var standard = await standardService.GetStandardVersionById(m.StandardCode.ToString(), m.CertificateData.Version);
if (!string.IsNullOrEmpty(m.StandardReference))
{
if (m.StandardReference != standard?.IfateReferenceNumber)
{
invalidVersionOrStandardMismatch = true;
context.AddFailure("StandardReference and StandardCode must be for the same Standard");
}
}
if (!invalidVersionOrStandardMismatch && standard != null)
{
var standardOptions = await standardService.GetStandardOptionsByStandardId(standard.StandardUId);
var noOptions = standardOptions == null || !standardOptions.HasOptions();
var hasOptions = standardOptions != null && standardOptions.HasOptions();
var requestedLearner = await learnerRepository.Get(m.Uln, m.StandardCode);
var courseOption = m.CertificateData?.CourseOption;
if (null != requestedLearner && !string.IsNullOrWhiteSpace(requestedLearner.CourseOption))
{
courseOption = requestedLearner.CourseOption;
}
if (noOptions && !string.IsNullOrEmpty(m.CertificateData?.CourseOption))
{
context.AddFailure(new ValidationFailure("CourseOption", $"No course option available for this Standard and version. Must be empty"));
}
else if (hasOptions && !standardOptions.CourseOption.Any(o => o.Equals(courseOption, StringComparison.InvariantCultureIgnoreCase)))
{
string courseOptionsString = string.Join(", ", standardOptions.CourseOption);
context.AddFailure(new ValidationFailure("CourseOption", $"Invalid course option for this Standard and version. Must be one of the following: {courseOptionsString} where {courseOptionsString} depends on the standard code, and can be obtained with GET /api/v1/standard/options/{standard.LarsCode}/{standard.Version}"));
}
}
});
});
When(m => !string.IsNullOrWhiteSpace(m.CertificateData.Version), () =>
{
RuleFor(m => m).Custom((m, context) =>
{
// If Version specified but StandardUId not populated, must be invalid version
// Otherwise we assume the auto-select process succeeded.
if (string.IsNullOrWhiteSpace(m.StandardUId) && !invalidVersionOrStandardMismatch)
{
invalidVersionOrStandardMismatch = true;
context.AddFailure(new ValidationFailure("Standard", "Invalid version for 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, canellation) =>
{
var requestedLearner = await learnerRepository.Get(m.Uln, m.StandardCode);
var submittingEpao = await organisationQueryRepository.GetByUkPrn(m.UkPrn);
if (requestedLearner is null || !string.Equals(requestedLearner.FamilyName, m.FamilyName, StringComparison.InvariantCultureIgnoreCase))
{
context.AddFailure(new ValidationFailure("Uln", "ULN, FamilyName and Standard not found."));
}
else if (submittingEpao is null)
{
context.AddFailure(new ValidationFailure("UkPrn", "Specified UKPRN not found"));
}
else
{
var providedStandardVersions = await standardService.GetEPAORegisteredStandardVersions(submittingEpao.EndPointAssessorOrganisationId, m.StandardCode);
if (!providedStandardVersions.Any())
{
context.AddFailure(new ValidationFailure("StandardCode", "Your organisation is not approved to assess this Standard"));
}
else if (!(invalidVersionOrStandardMismatch || providedStandardVersions.Any(v => v.Version.Equals(m.CertificateData.Version, StringComparison.InvariantCultureIgnoreCase))))
{
context.AddFailure(new ValidationFailure("Version", $"Your organisation is not approved to assess this Standard Version: {m.CertificateData.Version}"));
}
}
});
});
public UpdateBatchEpaRequestValidator(IStringLocalizer <BatchEpaRequestValidator> localiser, IOrganisationQueryRepository organisationQueryRepository, ILearnerRepository learnerRepository, ICertificateRepository certificateRepository, IStandardService standardService)
{
Include(new BatchEpaRequestValidator(localiser, organisationQueryRepository, learnerRepository, 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 GetApprovalsLearnerRecordHandler(ILearnerRepository learnerRepository, ILogger <GetApprovalsLearnerRecordHandler> logger)
{
_learnerRepository = learnerRepository;
_logger = logger;
}
public GetPipelinesCountHandler(IWebConfiguration config, ILearnerRepository learnerRepository, ILogger <GetPipelinesCountHandler> logger)
{
_config = config;
_learnerRepository = learnerRepository;
_logger = logger;
}
