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 StartPrivateCertificateHandler(ICertificateRepository certificateRepository, IOrganisationQueryRepository organisationQueryRepository, ILogger <StartCertificateHandler> logger) { _certificateRepository = certificateRepository; _organisationQueryRepository = organisationQueryRepository; _logger = logger; }
public UpdateContactWithOrgAndStatus(IContactRepository contactRepository, IOrganisationRepository organisationRepository, IOrganisationQueryRepository organisationQueryRepository) { _contactRepository = contactRepository; _organisationRepository = organisationRepository; _organisationQueryRepository = organisationQueryRepository; }
public NotifyUserManagementUsersHandler(IEMailTemplateQueryRepository eMailTemplateQueryRepository, IContactQueryRepository contactQueryRepository, IMediator mediator, IOrganisationQueryRepository organisationQueryRepository) { _eMailTemplateQueryRepository = eMailTemplateQueryRepository; _contactQueryRepository = contactQueryRepository; _mediator = mediator; _organisationQueryRepository = organisationQueryRepository; }
public GetBatchLearnerHandler(IMediator mediator, ILogger <GetBatchLearnerHandler> logger, IIlrRepository ilrRepository, IOrganisationQueryRepository organisationRepository) { _mediator = mediator; _logger = logger; _ilrRepository = ilrRepository; _organisationRepository = organisationRepository; }
public GetBatchCertificateHandler(ICertificateRepository certificateRepository, IContactQueryRepository contactQueryRepository, IStandardRepository standardRepository, IOrganisationQueryRepository organisationQueryRepository, ILogger <GetBatchCertificateHandler> logger) { _certificateRepository = certificateRepository; _contactQueryRepository = contactQueryRepository; _standardRepository = standardRepository; _organisationQueryRepository = organisationQueryRepository; _logger = logger; }
public CreateOrganisationHandler(IOrganisationRepository organisationRepository, IOrganisationQueryRepository organisationQueryRepository, IContactRepository contactRepository) { _organisationRepository = organisationRepository; _contactRepository = contactRepository; _organisationQueryRepository = organisationQueryRepository; }
public MergeOrganisationsHandler( IOrganisationQueryRepository organisationQueryRepository , IOrganisationMergingService organisationMergingService ) { _organisationQueryRepository = organisationQueryRepository; _organisationMergingService = organisationMergingService; }
public RequestForPrivilegeHandler(IMediator mediator, IContactQueryRepository contactQueryRepository, IOrganisationQueryRepository organisationQueryRepository, IWebConfiguration config, IContactRepository contactRepository) { _mediator = mediator; _contactQueryRepository = contactQueryRepository; _organisationQueryRepository = organisationQueryRepository; _config = config; _contactRepository = contactRepository; }
public RejectContactHandler(IContactQueryRepository contactQueryRepository, IEMailTemplateQueryRepository eMailTemplateQueryRepository, IMediator mediator, IOrganisationQueryRepository organisationQueryRepository, IContactRepository contactRepository) { _contactQueryRepository = contactQueryRepository; _eMailTemplateQueryRepository = eMailTemplateQueryRepository; _mediator = mediator; _organisationQueryRepository = organisationQueryRepository; _contactRepository = contactRepository; }
public CreateApplicationHandler(IOrganisationQueryRepository organisationQueryRepository, IRegisterQueryRepository registerQueryRepository, IContactQueryRepository contactQueryRepository, IApplyRepository applyRepository) { _applyRepository = applyRepository; _organisationQueryRepository = organisationQueryRepository; _registerQueryRepository = registerQueryRepository; _contactQueryRepository = contactQueryRepository; }
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 ApproveContactHandler(IContactRepository contactRepository, IContactQueryRepository contactQueryRepository, IEMailTemplateQueryRepository eMailTemplateQueryRepository, IMediator mediator, IWebConfiguration config, IOrganisationQueryRepository organisationQueryRepository) { _contactRepository = contactRepository; _contactQueryRepository = contactQueryRepository; _eMailTemplateQueryRepository = eMailTemplateQueryRepository; _mediator = mediator; _config = config; _organisationQueryRepository = organisationQueryRepository; }
public InviteContactToOrganisationHandler(IContactQueryRepository contactQueryRepository, IContactRepository contactRepository, IMediator mediator, ISignInService signInService, IOrganisationQueryRepository organisationQueryRepository) { _contactQueryRepository = contactQueryRepository; _contactRepository = contactRepository; _mediator = mediator; _signInService = signInService; _organisationQueryRepository = organisationQueryRepository; }
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 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(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 LoginHandler(ILogger <LoginHandler> logger, IOrganisationQueryRepository organisationQueryRepository, IContactQueryRepository contactQueryRepository, IContactRepository contactRepository, IRegisterRepository registerRepository) { _logger = logger; _organisationQueryRepository = organisationQueryRepository; _contactQueryRepository = contactQueryRepository; _contactRepository = contactRepository; _registerRepository = registerRepository; }
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 OrganisationQueryController( ILogger <OrganisationQueryController> logger, IMediator mediator, IOrganisationQueryRepository organisationQueryRepository, UkPrnValidator ukPrnValidator, IStringLocalizer <OrganisationQueryController> localizer, IWebConfiguration config ) { _logger = logger; _mediator = mediator; _organisationQueryRepository = organisationQueryRepository; _ukPrnValidator = ukPrnValidator; _localizer = localizer; _config = config; }
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 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 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 UpdateOrganisationRequestValidator(IStringLocalizer <UpdateOrganisationRequestValidator> localiser, IContactQueryRepository contactQueryRepository, IOrganisationQueryRepository organisationQueryRepository ) { _contactQueryRepository = contactQueryRepository; _organisationQueryRepository = organisationQueryRepository; // ReSharper disable once LocalNameCapturedOnly UpdateOrganisationRequest updateOrganisationRequest; RuleFor(organisation => organisation.EndPointAssessorName).NotEmpty().WithMessage( string.Format(localiser[ResourceMessageName.MustBeDefined].Value, nameof(updateOrganisationRequest.EndPointAssessorName).ToCamelCase())); RuleFor(organisation => organisation.PrimaryContact) .Custom((primaryContact, context) => { if (string.IsNullOrEmpty(primaryContact)) { return; } var result = contactQueryRepository.CheckContactExists(primaryContact).Result; if (!result) { context.AddFailure(new ValidationFailure("PrimaryContact", string.Format(localiser[ResourceMessageName.DoesNotExist].Value, "PrimaryContact", primaryContact))); } }); RuleFor(organisation => organisation.EndPointAssessorOrganisationId) .Custom((endPointAssessorOrganisationId, context) => { var result = organisationQueryRepository.CheckIfAlreadyExists(endPointAssessorOrganisationId).Result; if (!result) { context.AddFailure(new ValidationFailure("Organisation", string.Format(localiser[ResourceMessageName.DoesNotExist].Value, "Organisation", endPointAssessorOrganisationId))); } }); }
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 CreateOrganisationRequestValidator(IStringLocalizer <CreateOrganisationRequestValidator> localiser, IContactQueryRepository contactQueryRepository, IOrganisationQueryRepository organisationQueryRepository ) { _contactQueryRepository = contactQueryRepository; // ReSharper disable once LocalNameCapturedOnly CreateOrganisationRequest createOrganisationRequest; RuleFor(organisation => organisation.EndPointAssessorOrganisationId) .NotEmpty() .WithMessage( string.Format(localiser[ResourceMessageName.MustBeDefined].Value, nameof(createOrganisationRequest.EndPointAssessorOrganisationId).ToCamelCase())) .MaximumLength(12) // Please note we have to string.Format this due to limitation in Moq not handling Optional // Params .WithMessage(string.Format(localiser[ResourceMessageName.MaxLengthError].Value, nameof(createOrganisationRequest.EndPointAssessorOrganisationId), 12)); RuleFor(organisation => organisation.EndPointAssessorName).NotEmpty().WithMessage( string.Format(localiser[ResourceMessageName.MustBeDefined].Value, nameof(createOrganisationRequest.EndPointAssessorName).ToCamelCase())); RuleFor(organisation => organisation.EndPointAssessorUkprn).InclusiveBetween(10000000, 99999999) .WithMessage(localiser[ResourceMessageName.InvalidUkprn].Value); RuleFor(organisation => organisation.EndPointAssessorOrganisationId) .Custom((endPointAssessorOrganisationId, context) => { var result = organisationQueryRepository.CheckIfAlreadyExists(endPointAssessorOrganisationId).Result; if (result) { context.AddFailure(new ValidationFailure("Organisation", string.Format(localiser[ResourceMessageName.AlreadyExists].Value, "Organisation"))); } }); }
public static List <SearchResult> MatchUpExistingCompletedStandards(this List <SearchResult> searchResults, SearchQuery request, string likedSurname, IEnumerable <int> approvedStandards, ICertificateRepository certificateRepository, IContactQueryRepository contactRepository, IOrganisationQueryRepository _organisationRepository, ILogger <SearchHandler> logger) { logger.LogInformation("MatchUpExistingCompletedStandards Before Get Certificates for uln from db"); var certificates = certificateRepository.GetDraftAndCompletedCertificatesFor(request.Uln).Result; logger.LogInformation("MatchUpExistingCompletedStandards After Get Certificates for uln from db"); // Don't match up existing standards if paramters for filtering not passed in. if (string.IsNullOrWhiteSpace(likedSurname) || approvedStandards == null || approvedStandards.Count() == 0) { return(searchResults); } var searchingEpao = _organisationRepository.Get(request.EpaOrgId).Result; if (searchResults.Count > 0) { foreach (var searchResult in searchResults) { var certificate = certificates.SingleOrDefault(s => s.StandardCode == searchResult.StdCode); if (certificate != null) { var hasPreviousSubmission = certificate.CertificateLogs.Any(l => l.Action == CertificateActions.Submit); if (hasPreviousSubmission) { searchResult.PopulateCertificateBasicInformation(certificate); searchResult.PopulateCertificateExtraInformationDependingOnPermission(request, contactRepository, certificate, searchingEpao, logger); } } } } else if (certificates.Count > 0) { foreach (var certificate in certificates) { // Don't return certficate if the EPAO isn't able to assess that standard if (!approvedStandards.Contains(certificate.StandardCode)) { continue; } var certificateData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData); // Don't return certificate if the name does not match. if (!string.Equals(certificateData.LearnerFamilyName.Trim(), likedSurname.Trim(), StringComparison.CurrentCultureIgnoreCase)) { continue; } // Create a new search result as it would be when returned by the Learner record var searchResult = new SearchResult { Uln = certificate.Uln, FamilyName = certificateData.LearnerFamilyName, GivenNames = certificateData.LearnerGivenNames, StdCode = certificate.StandardCode, UkPrn = certificate.ProviderUkPrn, CreatedAt = certificate.CreatedAt, LearnStartDate = certificateData.LearningStartDate }; searchResult.PopulateCertificateBasicInformation(certificate); searchResult.PopulateCertificateExtraInformationDependingOnPermission(request, contactRepository, certificate, searchingEpao, logger); searchResults.Add(searchResult); } } return(searchResults); }
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 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 GetOrganisationHandler(IOrganisationQueryRepository organisationQueryRepository) { _organisationQueryRepository = organisationQueryRepository; }