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; }