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