public async Task <MergeOrganisation> Handle(MergeOrganisationsRequest mergeOrganisationRequest, CancellationToken cancellationToken)
{
var primaryOrganisation = await _organisationQueryRepository.Get(mergeOrganisationRequest.PrimaryEndPointAssessorOrganisationId);
var secondaryOrganisation = await _organisationQueryRepository.Get(mergeOrganisationRequest.SecondaryEndPointAssessorOrganisationId);
var mergeOrganisation = await _organisationMergingService.MergeOrganisations(primaryOrganisation, secondaryOrganisation, mergeOrganisationRequest.SecondaryStandardsEffectiveTo, mergeOrganisationRequest.ActionedByUser);
return(mergeOrganisation);
}
public async Task <Organisation> Handle(GetOrganisationRequest request,
CancellationToken cancellationToken)
{
var organisation = await _organisationQueryRepository.Get(request.Id);
return(organisation);
}
public async Task <Unit> Handle(RejectContactRequest message, CancellationToken cancellationToken)
{
const string epaoUserReject = "EPAOUserApproveReject";
var contact = await _contactQueryRepository.GetContactById(message.ContactId);
var organisation = await _organisationQueryRepository.Get(contact.OrganisationId.Value);
await _contactRepository.UpdateStatus(message.ContactId, ContactStatus.New);
await _contactRepository.UpdateOrganisationId(message.ContactId, null);
var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(epaoUserReject);
await _mediator.Send(new SendEmailRequest(contact.Email,
emailTemplate, new
{
Contact = $"{contact.DisplayName}",
ServiceName = "Apprenticeship assessment service",
Organisation = organisation.EndPointAssessorName,
ServiceTeam = "Apprenticeship assessment services team"
}), cancellationToken);
return(Unit.Value);
}
public async Task <Unit> Handle(InvitationCheckRequest message, CancellationToken cancellationToken)
{
var contactInvitation = await _contactRepository.GetContactInvitation(message.ContactId);
if (contactInvitation is null || contactInvitation.IsAccountCreated)
{
return(Unit.Value);
}
var acceptedContact = await _contactQueryRepository.GetContactById(contactInvitation.InviteeContactId);
var invitingContact = await _contactQueryRepository.GetContactById(contactInvitation.InvitorContactId);
var organisation = await _organisationQueryRepository.Get(contactInvitation.OrganisationId);
var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate("EPAOLoginAccountCreated");
await _mediator.Send(new SendEmailRequest(invitingContact.Email, emailTemplate, new
{
Contact = invitingContact.GivenNames,
ContactName = acceptedContact.DisplayName,
OrganisationName = organisation.EndPointAssessorName,
ServiceTeam = "Apprenticeship assessment service team"
}), cancellationToken);
await _contactRepository.SetInvitationAccepted(contactInvitation);
return(Unit.Value);
}
public async Task <Unit> Handle(NotifyUserManagementUsersRequest message, CancellationToken cancellationToken)
{
const string epaoUserApproveRequestTemplate = "EPAOUserApproveRequest";
var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(epaoUserApproveRequestTemplate);
var organisation = await _organisationQueryRepository.Get(message.EndPointAssessorOrganisationId);
var contactsWithUserManagementPrivilege = (await _contactQueryRepository.GetAllContactsIncludePrivileges(organisation.EndPointAssessorOrganisationId))
.Where(c => c.ContactsPrivileges.Any(cp => cp.Privilege.Key == Privileges.ManageUsers &&
cp.Contact.Status == ContactStatus.Live)).ToList();
foreach (var contact in contactsWithUserManagementPrivilege)
{
await _mediator.Send(new SendEmailRequest(contact.Email, emailTemplate, new
{
Contact = contact.DisplayName,
username = message.DisplayName,
ServiceName = "Apprenticeship assessment service",
LoginLink = message.ServiceLink,
ServiceTeam = "Apprenticeship assessment service team",
Organisation = organisation.EndPointAssessorName
}), cancellationToken);
}
return(Unit.Value);
}
public async Task <Unit> Handle(ApproveContactRequest message, CancellationToken cancellationToken)
{
const string epaoApproveConfirmTemplate = "EPAOUserApproveConfirm";
var contact = await _contactQueryRepository.GetContactById(message.ContactId);
var organisation = await _organisationQueryRepository.Get(contact.OrganisationId.Value);
await _contactRepository.UpdateContactWithOrganisationData(new UpdateContactWithOrgAndStausRequest(message.ContactId.ToString(),
organisation.Id.ToString(), organisation.EndPointAssessorOrganisationId, ContactStatus.Live));
var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(epaoApproveConfirmTemplate);
await _mediator.Send(new SendEmailRequest(contact.Email,
emailTemplate, new
{
Contact = $"{contact.DisplayName}",
ServiceName = "Apprenticeship assessment service",
Organisation = organisation.EndPointAssessorName,
LoginLink = _config.ServiceLink,
ServiceTeam = "Apprenticeship assessment services team"
}), cancellationToken);
return(Unit.Value);
}
private async Task UpdateOrganisationWithUpdatedGrade(Guid applicationId, FinancialGrade grade)
{
var application = await _applyRepository.GetApplication(applicationId);
var org = await _organisationQueryRepository.Get(application.OrganisationId);
if (org != null)
{
org.OrganisationData.FHADetails = new FHADetails()
{
FinancialDueDate = grade.FinancialDueDate,
FinancialExempt = grade.SelectedGrade == FinancialApplicationSelectedGrade.Exempt
};
if (org.OrganisationData.FinancialGrades == null)
{
org.OrganisationData.FinancialGrades = new List <FinancialGrade>();
}
if (org.OrganisationData.FinancialGrades.Any(x => x.ApplicationReference == grade.ApplicationReference))
{
org.OrganisationData.FinancialGrades = org.OrganisationData.FinancialGrades.
Where(x => x.ApplicationReference == grade.ApplicationReference).Select(s => { return(grade); }
).ToList();
}
else
{
org.OrganisationData.FinancialGrades.Add(grade);
}
await _organisationRepository.UpdateOrganisation(org);
}
}
public async Task <InviteContactToOrganisationResponse> Handle(InviteContactToOrganisationRequest request, CancellationToken cancellationToken)
{
var existingContact = await _contactQueryRepository.GetContactFromEmailAddress(request.Email);
if (existingContact != null)
{
return(new InviteContactToOrganisationResponse()
{
Success = false,
ErrorMessage = existingContact.OrganisationId == request.OrganisationId
? "This email address is already registered against your organisation. You must use a unique email address."
: "This email address is already registered against another organisation. You must use a unique email address."
});
}
var organisation = await _organisationQueryRepository.Get(request.OrganisationId);
var newContact = await CreateNewContact(request, organisation);
var inviter = await _contactQueryRepository.GetContactById(request.InvitedByContactId);
await _signInService.InviteUserToOrganisation(request.Email, request.GivenName, request.FamilyName, newContact.Id, organisation.EndPointAssessorName, inviter.DisplayName);
await _contactRepository.AddContactInvitation(request.InvitedByContactId, newContact.Id, organisation.Id);
return(new InviteContactToOrganisationResponse {
Success = true, ContactId = newContact.Id
});
}
private async Task <List <SearchResult> > Search(SearchQuery request, CancellationToken cancellationToken)
{
_logger.LogInformation($"Search for surname: {request.Surname} uln: {request.Uln} made by {request.EpaOrgId}");
var thisEpao = await _organisationRepository.Get(request.EpaOrgId);
if (thisEpao == null)
{
_logger.LogInformation($"{LoggingConstants.SearchFailure} - Invalid EpaOrgId", request.EpaOrgId);
return(new List <SearchResult>());
}
var approvedStandards = await GetEpaoApprovedStandardsWithAtLeastOneVersion(thisEpao);
var learnerResults = await _learnerRepository.SearchForLearnerByUln(request.Uln);
var likedSurname = request.Surname.Replace(" ", "");
var listOfLearnerResults = learnerResults?.ToList();
likedSurname = DealWithSpecialCharactersAndSpaces(request, likedSurname, listOfLearnerResults);
learnerResults = listOfLearnerResults?.Where(r => approvedStandards.Contains(r.StdCode) &&
string.Equals(r.FamilyNameForSearch.Trim(), likedSurname.Trim(), StringComparison.CurrentCultureIgnoreCase))
.ToList();
_logger.LogInformation((learnerResults != null && learnerResults.Any())? LoggingConstants.SearchSuccess : LoggingConstants.SearchFailure);
var searchResults = Mapper.Map <List <SearchResult> >(learnerResults)
.MatchUpExistingCompletedStandards(request, likedSurname, approvedStandards, _certificateRepository, _contactRepository, _organisationRepository, _logger)
.PopulateStandards(_standardService, _logger);
return(searchResults);
}
public async Task <IActionResult> GetOrganisation(Guid id)
{
_logger.LogInformation($"Received request to retrieve Organisation {id}");
var organisation =
await _organisationQueryRepository.Get(id);
return(Ok(organisation));
}
private async Task SetOrganisationStatusToApplyAndSetPrimaryContact(string endPointAssessorOrganisationId, Contact contact)
{
var organisation =
await _organisationQueryRepository.Get(endPointAssessorOrganisationId);
organisation.PrimaryContact = contact.Username;
organisation.Status = OrganisationStatus.Applying;
await _organisationRepository.UpdateOrganisation(organisation);
}
public async Task <LearnerDetail> Handle(LearnerDetailRequest request, CancellationToken cancellationToken)
{
var learner = await _ilrRepository.Get(request.Uln, request.StdCode);
var standard = await _standardRepository.GetStandardCollationByStandardId(request.StdCode);
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StdCode);
var logs = new List <CertificateLogSummary>();
var certificateData = new CertificateData();
var epao = new Organisation();
if (certificate != null)
{
logs = await _staffCertificateRepository.GetCertificateLogsFor(certificate.Id, request.AllRecords);
if (logs.Count() > 1)
{
CalculateDifferences(logs);
}
certificateData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData) ?? new CertificateData();
epao = await _organisationRepository.Get(certificate.OrganisationId) ?? new Organisation();
}
var learnerDetail = new LearnerDetail()
{
Uln = request.Uln,
FamilyName = !string.IsNullOrEmpty(certificateData.LearnerFamilyName) ? certificateData.LearnerFamilyName : learner?.FamilyName,
GivenNames = !string.IsNullOrEmpty(certificateData.LearnerGivenNames) ? certificateData.LearnerGivenNames : learner?.GivenNames,
LearnStartDate = certificateData.LearningStartDate.HasValue ? certificateData.LearningStartDate : learner?.LearnStartDate,
StandardCode = (certificate?.StandardCode).HasValue ? certificate.StandardCode : standard?.StandardId ?? 0,
Standard = !string.IsNullOrEmpty(certificateData.StandardName) ? certificateData.StandardName : standard?.Title,
Level = certificateData.StandardLevel > 0 ? certificateData.StandardLevel : standard?.StandardData?.Level ?? 0,
CertificateReference = certificate?.CertificateReference,
CertificateStatus = certificate?.Status,
OverallGrade = certificateData.OverallGrade,
AchievementDate = certificateData.AchievementDate, //?.UtcToTimeZoneTime(),
Option = certificateData.CourseOption,
OrganisationName = epao.EndPointAssessorName,
OrganisationId = epao.EndPointAssessorOrganisationId,
CertificateLogs = logs,
FundingModel = learner?.FundingModel,
CompletionStatus = learner?.CompletionStatus,
CompletionStatusDescription = FormatCompletionStatusDescription(learner?.CompletionStatus),
IsPrivatelyFunded = certificate?.IsPrivatelyFunded,
CertificateId = certificate?.Id
};
return(learnerDetail);
}
public async Task <Guid> Handle(CreateApplicationRequest request, CancellationToken cancellationToken)
{
var org = await _organisationQueryRepository.Get(request.OrganisationId);
var orgTypes = await _registerQueryRepository.GetOrganisationTypes();
var creatingContact = await _contactQueryRepository.GetContactById(request.CreatingContactId);
if (org != null && orgTypes != null && creatingContact != null)
{
var orgType = orgTypes.FirstOrDefault(x => x.Id == org.OrganisationTypeId);
var sequences = request.ApplySequences;
DisableSequencesAndSectionsAsAppropriate(sequences, org, orgType);
MakeLowerSequenceActive(sequences);
var applyData = new ApplyData
{
Sequences = sequences,
Apply = new ApplyTypes.Apply
{
ReferenceNumber = await CreateReferenceNumber(request.ApplicationReferenceFormat),
InitSubmissions = new List <Submission>(),
InitSubmissionsCount = 0,
StandardSubmissions = new List <Submission>(),
StandardSubmissionsCount = 0
}
};
var application = new Domain.Entities.Apply
{
ApplyData = applyData,
ApplicationId = request.QnaApplicationId,
ApplicationStatus = ApplicationStatus.InProgress,
ReviewStatus = ApplicationReviewStatus.Draft,
FinancialReviewStatus = IsFinancialExempt(org.OrganisationData?.FHADetails, orgType) ? FinancialReviewStatus.Exempt : FinancialReviewStatus.Required,
OrganisationId = org.Id,
CreatedBy = creatingContact.Id.ToString(),
CreatedAt = DateTime.UtcNow
};
return(await _applyRepository.CreateApplication(application));
}
return(Guid.Empty);
}
private async Task <List <SearchResult> > Search(SearchQuery request, CancellationToken cancellationToken)
{
_logger.LogInformation($"Search for surname: {request.Surname} uln: {request.Uln} made by {request.EpaOrgId}");
var thisEpao = await _organisationRepository.Get(request.EpaOrgId);
if (thisEpao == null)
{
_logger.LogInformation($"{LoggingConstants.SearchFailure} - Invalid EpaOrgId", request.EpaOrgId);
return(new List <SearchResult>());
}
var intStandards = await GetEpaoStandards(thisEpao);
var ilrResults = await _ilrRepository.SearchForLearnerByUln(request.Uln);
var likedSurname = request.Surname.Replace(" ", "");
var listOfIlrResults = ilrResults?.ToList();
if (request.IsPrivatelyFunded && (listOfIlrResults == null || (!listOfIlrResults.Any())))
{
//Learner not in ILR so try to create an in memory record with details from found certificate and request information
listOfIlrResults = new List <Ilr> {
new Ilr {
Uln = request.Uln, EpaOrgId = request.EpaOrgId, FamilyNameForSearch = request.Surname, FamilyName = request.Surname
}
};
likedSurname = DealWithSpecialCharactersAndSpaces(request, likedSurname, listOfIlrResults);
var certificate =
await _certificateRepository.GetCertificateByOrgIdLastname(request.Uln, request.EpaOrgId, likedSurname);
if (certificate == null)
{
//Now check if exists for uln and surname without considering org
certificate = await _certificateRepository.GetCertificateByUlnLastname(request.Uln, likedSurname);
if (certificate != null)
{
if (certificate?.Status == CertificateStatus.Deleted)
{
var result = GetDeletedOrFailedCertificateResult(certificate, request);
if (result.Any())
{
return(result);
}
}
if (intStandards?.Contains(certificate.StandardCode) ?? false)
{
var standard = await _standardService.GetStandard(certificate.StandardCode);
return(new List <SearchResult>
{
new SearchResult {
UlnAlreadyExits = true, FamilyName = likedSurname, Uln = request.Uln, IsPrivatelyFunded = true, Standard = standard?.Title, Level = standard?.StandardData.Level.GetValueOrDefault() ?? 0
}
});
}
return(new List <SearchResult> {
new SearchResult {
UlnAlreadyExits = true, Uln = request.Uln, IsPrivatelyFunded = true, IsNoMatchingFamilyName = true
}
});
}
//If we got here then certifcate does not exist with uln and surename so
//lastly check if there is a certificate that exist with the given uln only disregarding org and surname
var deletedCert = await _certificateRepository.GetCertificateDeletedByUln(request.Uln);
if (deletedCert != null)
{
var result = GetDeletedOrFailedCertificateResult(deletedCert, request);
if (result.Any())
{
return(result);
}
}
var certificateExist = await _certificateRepository.CertifciateExistsForUln(request.Uln);
return(certificateExist
? new List <SearchResult> {
new SearchResult {
UlnAlreadyExits = true, Uln = request.Uln, IsPrivatelyFunded = true, IsNoMatchingFamilyName = true
}
}
: new List <SearchResult>());
}
if (certificate?.Status == CertificateStatus.Deleted)
{
var result = GetDeletedOrFailedCertificateResult(certificate, request);
if (result.Any())
{
return(result);
}
}
//We found the certifate, check if standard in certificate exists in standards registered by calling org
if (intStandards?.Contains(certificate.StandardCode) ?? false)
{
listOfIlrResults[0].StdCode = certificate.StandardCode;
}
}
else
{
likedSurname = DealWithSpecialCharactersAndSpaces(request, likedSurname, listOfIlrResults);
}
ilrResults = listOfIlrResults?.Where(r => (
r.EpaOrgId == thisEpao.EndPointAssessorOrganisationId ||
(r.EpaOrgId != thisEpao.EndPointAssessorOrganisationId && intStandards.Contains(r.StdCode))) &&
string.Equals(r.FamilyNameForSearch.Trim(), likedSurname.Trim(), StringComparison.CurrentCultureIgnoreCase)).ToList();
if (request.IsPrivatelyFunded && ilrResults != null && !ilrResults.Any())
{
var certificate = await _certificateRepository.GetCertificateByUlnLastname(request.Uln, likedSurname);
//If privately funded and uln found in ilr but existing certificate is marked as deleted
if (certificate?.Status == CertificateStatus.Deleted)
{
var result = GetDeletedOrFailedCertificateResult(certificate, request);
if (result.Any())
{
return(result);
}
}
//If privately funded and uln found in ilr but due to the previous checks the result was empty then set uln exist flag
return(new List <SearchResult> {
new SearchResult {
UlnAlreadyExits = true, Uln = request.Uln,
IsPrivatelyFunded = request.IsPrivatelyFunded, IsNoMatchingFamilyName = true
}
});
}
if (request.IsPrivatelyFunded)
{
var certificate = await _certificateRepository.GetCertificateByUlnLastname(request.Uln, likedSurname);
if (certificate?.IsPrivatelyFunded == true &&
certificate?.Status != CertificateStatus.Deleted &&
certificate?.Status != CertificateStatus.Draft)
{
var certData = JsonConvert.DeserializeObject <Domain.JsonData.CertificateData>(certificate?.CertificateData);
if (certData != null && certData.OverallGrade != CertificateGrade.Fail)
{
return(new List <SearchResult> {
new SearchResult {
FamilyName = likedSurname, UlnAlreadyExits = true, Uln = request.Uln,
IsPrivatelyFunded = true, IsNoMatchingFamilyName = false, StdCode = certificate.StandardCode
}
}.PopulateStandards(_standardService, _logger));
}
else
{
var result = GetDeletedOrFailedCertificateResult(certificate, request);
if (result.Any())
{
return(result);
}
}
}
}
_logger.LogInformation((ilrResults != null && ilrResults.Any())? LoggingConstants.SearchSuccess : LoggingConstants.SearchFailure);
var searchResults = Mapper.Map <List <SearchResult> >(ilrResults)
.MatchUpExistingCompletedStandards(request, _certificateRepository, _contactRepository, _organisationRepository, _logger)
.PopulateStandards(_standardService, _logger);
return(searchResults);
}
public async Task <LearnerDetailResult> Handle(GetLearnerDetailRequest request,
CancellationToken cancellationToken)
{
var learner = await _learnerRepository.Get(request.Uln, request.StdCode);
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StdCode);
var logs = new List <CertificateLogSummary>();
var certificateData = new CertificateData();
var epao = new Organisation();
if (certificate != null)
{
if (request.AllRecords)
{
logs.AddRange(await _staffCertificateRepository.GetAllCertificateLogs(certificate.Id));
}
else
{
var showSummaryStatus = new[] { CertificateStatus.Submitted }.Concat(CertificateStatus.PrintProcessStatus).ToList();
if (showSummaryStatus.Contains(certificate.Status))
{
logs.AddRange(await _staffCertificateRepository.GetSummaryCertificateLogs(certificate.Id));
}
else
{
var latestCertificateLog = await _staffCertificateRepository.GetLatestCertificateLog(certificate.Id);
if (latestCertificateLog != null)
{
logs.Add(latestCertificateLog);
}
}
}
if (logs.Count() > 1)
{
CalculateDifferences(logs);
}
certificateData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData) ?? new CertificateData();
epao = await _organisationRepository.Get(certificate.OrganisationId) ?? new Organisation();
}
var standard = await _standardRepository.GetStandardVersionByLarsCode(request.StdCode, certificateData?.Version);
var learnerDetail = new LearnerDetailResult()
{
Uln = request.Uln,
FamilyName = !string.IsNullOrEmpty(certificateData.LearnerFamilyName) ? certificateData.LearnerFamilyName : learner?.FamilyName,
GivenNames = !string.IsNullOrEmpty(certificateData.LearnerGivenNames) ? certificateData.LearnerGivenNames : learner?.GivenNames,
LearnStartDate = certificateData.LearningStartDate.HasValue ? certificateData.LearningStartDate : learner?.LearnStartDate,
StandardCode = (certificate?.StandardCode).HasValue ? certificate.StandardCode : standard?.LarsCode ?? 0,
Standard = !string.IsNullOrEmpty(certificateData.StandardName) ? certificateData.StandardName : standard?.Title,
Version = !string.IsNullOrEmpty(certificateData.Version) ? certificateData.Version : learner?.Version,
Level = certificateData.StandardLevel > 0 ? certificateData.StandardLevel : standard?.Level ?? 0,
CertificateReference = certificate?.CertificateReference,
CertificateStatus = certificate?.Status,
OverallGrade = certificateData.OverallGrade,
AchievementDate = certificateData.AchievementDate,
Option = !string.IsNullOrEmpty(certificateData.CourseOption) ? certificateData.CourseOption : learner?.CourseOption,
OrganisationName = epao.EndPointAssessorName,
OrganisationId = epao.EndPointAssessorOrganisationId,
CertificateLogs = logs,
FundingModel = learner?.FundingModel,
CompletionStatus = learner?.CompletionStatus,
CompletionStatusDescription = FormatCompletionStatusDescription(learner?.CompletionStatus),
IsPrivatelyFunded = certificate?.IsPrivatelyFunded,
CertificateId = certificate?.Id,
PrintStatusAt = certificate?.CertificateBatchLog?.StatusAt,
ReasonForChange = certificate?.CertificateBatchLog?.ReasonForChange,
CertificateSendTo = certificateData.SendTo.ToString(),
ContactName = certificateData.ContactName,
ContactDept = certificateData.Department,
ContactOrganisation = certificateData.ContactOrganisation,
ContactAddLine1 = certificateData.ContactAddLine1,
ContactAddLine2 = certificateData.ContactAddLine2,
ContactAddLine3 = certificateData.ContactAddLine3,
ContactAddLine4 = certificateData.ContactAddLine4,
ContactPostCode = certificateData.ContactPostCode,
LastUpdatedAt = certificate?.LatestChange()
};
return(learnerDetail);
}
public static List <SearchResult> MatchUpExistingCompletedStandards(this List <SearchResult> searchResults, SearchQuery request, ICertificateRepository certificateRepository, IContactQueryRepository contactRepository, IOrganisationQueryRepository _organisationRepository, ILogger <SearchHandler> logger)
{
logger.LogInformation("MatchUpExistingCompletedStandards Before Get Certificates for uln from db");
var completedCertificates = certificateRepository.GetCompletedCertificatesFor(request.Uln).Result;
logger.LogInformation("MatchUpExistingCompletedStandards After Get Certificates for uln from db");
var searchingEpao = _organisationRepository.Get(request.EpaOrgId).Result;
foreach (var searchResult in searchResults.Where(r => completedCertificates.Select(s => s.StandardCode).Contains(r.StdCode)))
{
var certificate = completedCertificates.Single(s => s.StandardCode == searchResult.StdCode);
var certificateData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
searchResult.CertificateReference = certificate.CertificateReference;
searchResult.CertificateId = certificate.Id;
searchResult.CertificateStatus = certificate.Status;
searchResult.LearnStartDate = certificateData.LearningStartDate;
searchResult.Option = certificateData.CourseOption;
var certificateLogs = certificateRepository.GetCertificateLogsFor(certificate.Id).Result;
logger.LogInformation("MatchUpExistingCompletedStandards After GetCertificateLogsFor");
var submittedLogEntry = certificateLogs.FirstOrDefault(l => l.Status == CertificateStatus.Submitted);
var createdLogEntry = certificateLogs.FirstOrDefault(l => l.Status == CertificateStatus.Draft);
if (request.IsPrivatelyFunded)
{
var toBeApprovedLogEntry = certificateLogs.FirstOrDefault(l => l.Status == CertificateStatus.ToBeApproved);
if (toBeApprovedLogEntry == null)
{
continue;
}
submittedLogEntry = toBeApprovedLogEntry;
}
if (submittedLogEntry == null)
{
continue;
}
var submittingContact = contactRepository.GetContact(submittedLogEntry.Username).Result ?? contactRepository.GetContact(certificate.UpdatedBy).Result;
var createdContact = contactRepository.GetContact(createdLogEntry?.Username).Result ?? contactRepository.GetContact(certificate.CreatedBy).Result;
var lastUpdatedLogEntry = certificateLogs.Aggregate((i1, i2) => i1.EventTime > i2.EventTime ? i1 : i2) ?? submittedLogEntry;
var lastUpdatedContact = contactRepository.GetContact(lastUpdatedLogEntry.Username).Result;
logger.LogInformation("MatchUpExistingCompletedStandards After GetContact");
var searchingContact = contactRepository.GetContact(request.Username).Result;
if (submittingContact != null && submittingContact.OrganisationId == searchingContact.OrganisationId)
{
searchResult.ShowExtraInfo = true;
searchResult.OverallGrade = certificateData.OverallGrade;
searchResult.SubmittedBy = submittingContact.DisplayName; // This needs to be contact real name
searchResult.SubmittedAt = submittedLogEntry.EventTime.UtcToTimeZoneTime(); // This needs to be local time
searchResult.AchDate = certificateData.AchievementDate;
searchResult.UpdatedBy = lastUpdatedContact != null ? lastUpdatedContact.DisplayName : lastUpdatedLogEntry.Username; // This needs to be contact real name
searchResult.UpdatedAt = lastUpdatedLogEntry.EventTime.UtcToTimeZoneTime(); // This needs to be local time
}
else if (createdContact != null && searchingContact != null && createdContact.OrganisationId == searchingContact.OrganisationId)
{
searchResult.ShowExtraInfo = true;
searchResult.OverallGrade = certificateData.OverallGrade;
searchResult.SubmittedBy = submittedLogEntry.Username; // This needs to be contact real name
searchResult.SubmittedAt = submittedLogEntry.EventTime.UtcToTimeZoneTime(); // This needs to be local time
searchResult.AchDate = certificateData.AchievementDate;
searchResult.UpdatedBy = lastUpdatedContact != null ? lastUpdatedContact.DisplayName : lastUpdatedLogEntry.Username; // This needs to be contact real name
searchResult.UpdatedAt = lastUpdatedLogEntry.EventTime.UtcToTimeZoneTime(); // This needs to be local time
}
else if (certificate.OrganisationId == searchingEpao?.Id)
{
searchResult.ShowExtraInfo = true;
searchResult.OverallGrade = certificateData.OverallGrade;
searchResult.SubmittedBy = submittedLogEntry.Username ?? certificate.UpdatedBy;
searchResult.SubmittedAt = submittedLogEntry.EventTime.UtcToTimeZoneTime(); // This needs to be local time
searchResult.AchDate = certificateData.AchievementDate;
searchResult.UpdatedBy = lastUpdatedLogEntry.Username ?? certificate.UpdatedBy;
searchResult.UpdatedAt = lastUpdatedLogEntry.EventTime.UtcToTimeZoneTime(); // This needs to be local time
}
else
{
searchResult.ShowExtraInfo = false;
searchResult.OverallGrade = "";
searchResult.SubmittedBy = "";
searchResult.SubmittedAt = null;
searchResult.LearnStartDate = null;
searchResult.AchDate = null;
searchResult.UpdatedBy = null;
searchResult.UpdatedAt = null;
}
}
return(searchResults);
}
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 async Task <LoginResponse> Handle(LoginRequest request, CancellationToken cancellationToken)
{
var response = new LoginResponse();
var contact = await _contactQueryRepository.GetBySignInId(request.SignInId);
//Check if username is null or starts with unnown then update the username with users email
var originalUsername = contact.Username;
if (string.IsNullOrEmpty(originalUsername) ||
originalUsername.StartsWith("unknown-", StringComparison.CurrentCultureIgnoreCase))
{
await _contactRepository.UpdateUserName(contact.Id, contact.Email);
}
if (UserDoesNotHaveAcceptableRole(contact.Id))
{
_logger.LogInformation("Invalid Role");
_logger.LogInformation(LoggingConstants.SignInIncorrectRole);
response.Result = LoginResult.InvalidRole;
return(response);
}
_logger.LogInformation("Role is good");
if (contact.OrganisationId == null)
{
// This user has no organisation... send them off to find one.
response.Result = LoginResult.NotRegistered;
return(response);
}
var organisation = await _organisationQueryRepository.Get(contact.OrganisationId.Value);
if (organisation == null)
{
_logger.LogInformation($"Org not registered");
_logger.LogInformation(LoggingConstants.SignInNotAnEpao);
response.Result = LoginResult.NotRegistered;
return(response);
}
//ON-1926 If there was an organisation associated with the current contact then if the primary contact in
//that organisation matches the orginal username then make sure it is updated to reflect the latest username.
if (!string.IsNullOrEmpty(originalUsername))
{
await _registerRepository.UpdateEpaOrganisationPrimaryContact(contact.Id, originalUsername);
}
await CheckAndSetPrivileges(contact);
response.EndPointAssessorOrganisationId = organisation.EndPointAssessorOrganisationId;
_logger.LogInformation($"Got Org with ukprn: {organisation.EndPointAssessorUkprn}, Id: {organisation.EndPointAssessorOrganisationId}, Status: {organisation.Status}");
if (organisation.Status == OrganisationStatus.Deleted)
{
_logger.LogInformation(LoggingConstants.SignInEpaoDeleted);
response.Result = LoginResult.NotRegistered;
return(response);
}
else if (organisation.Status == OrganisationStatus.New)
{
_logger.LogInformation(LoggingConstants.SignInEpaoNew);
// Only show true status if contact is marked as being Live
response.Result = (contact.Status is ContactStatus.Live) ? LoginResult.NotActivated : LoginResult.InvitePending;
return(response);
}
else if (organisation.Status == OrganisationStatus.Applying)
{
_logger.LogInformation(LoggingConstants.SignInEpaoNew);
response.Result = (contact.Status is ContactStatus.Live) ? LoginResult.Applying : LoginResult.NotActivated;
return(response);
}
else
{
_logger.LogInformation(LoggingConstants.SignInSuccessful);
var status = contact.Status; //await GetUserStatus(organisation.EndPointAssessorOrganisationId, request.SignInId);
switch (status)
{
case ContactStatus.Live:
response.Result = LoginResult.Valid;
break;
case ContactStatus.InvitePending:
response.Result = LoginResult.InvitePending;
break;
case ContactStatus.Inactive:
response.Result = LoginResult.Rejected;
break;
case ContactStatus.Applying:
response.Result = LoginResult.Applying;
break;
default:
response.Result = LoginResult.NotRegistered;
break;
}
}
return(response);
}
