public Task <TResponse> GetRequest <TResponse>(ICoursesApiClient <CoursesApiConfiguration> client, IGetApiRequest request, string keyName, out bool updateCache)
{
Task <TResponse> itemsTask;
updateCache = false;
var itemFromCache = _cacheStorageService.RetrieveFromCache <TResponse>(keyName).Result;
if (itemFromCache != null)
{
itemsTask = Task.FromResult(itemFromCache);
if (itemFromCache.GetType() == typeof(GetStandardsListResponse))
{
if (itemFromCache is GetStandardsListResponse castItem && castItem.Total < 1)
{
itemsTask = client.Get <TResponse>(request);
updateCache = true;
}
}
}
else
{
itemsTask = client.Get <TResponse>(request);
updateCache = true;
}
return(itemsTask);
}
public async Task <GetRoutesListResponse> GetRoutes()
{
var response = await _cacheStorageService.RetrieveFromCache <GetRoutesListResponse>(nameof(GetRoutesListResponse));
if (response == null)
{
response = await _coursesApiClient.Get <GetRoutesListResponse>(new GetRoutesListRequest());
await _cacheStorageService.SaveToCache(nameof(GetRoutesListResponse), response, 23);
}
return(response);
}
public async Task <GetTrainingCourseProvidersResult> Handle(GetTrainingCourseProvidersQuery request, CancellationToken cancellationToken)
{
var locationTask = _locationLookupService.GetLocationInformation(request.Location, request.Lat, request.Lon);
var courseTask = _coursesApiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.Id));
var shortlistTask = _shortlistService.GetShortlistItemCount(request.ShortlistUserId);
await Task.WhenAll(locationTask, courseTask, shortlistTask);
var showEmployerDemand = _config.EmployerDemandFeatureToggle && await _employerDemandApiClient.GetResponseCode(new GetShowEmployerDemandRequest()) == HttpStatusCode.OK;
var providers = await _courseDeliveryApiClient.Get <GetProvidersListResponse>(new GetProvidersByCourseRequest(
request.Id,
courseTask.Result.SectorSubjectAreaTier2Description,
courseTask.Result.Level,
locationTask.Result?.GeoPoint?.FirstOrDefault(),
locationTask.Result?.GeoPoint?.LastOrDefault(),
request.SortOrder,
request.ShortlistUserId));
return(new GetTrainingCourseProvidersResult
{
Course = courseTask.Result,
Providers = providers.Providers,
Total = providers.TotalResults,
Location = locationTask.Result,
ShortlistItemCount = shortlistTask.Result,
ShowEmployerDemand = showEmployerDemand
});
}
public async Task <GetEmployerCourseProviderDemandQueryResult> Handle(GetEmployerCourseProviderDemandQuery request, CancellationToken cancellationToken)
{
var courseTask = _coursesApiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.CourseId));
var locationTask = _locationLookupService.GetLocationInformation(request.LocationName, 0, 0, true);
var providerCourseInfoTask =
_courseDeliveryApiClient.Get <GetProviderCourseInformation>(
new GetProviderCourseInformationRequest(request.Ukprn, request.CourseId));
await Task.WhenAll(courseTask, locationTask, providerCourseInfoTask);
var radius = locationTask.Result != null ? request.LocationRadius : null;
var demand = await _employerDemandApiClient.Get <GetEmployerCourseProviderListResponse>(
new GetCourseProviderDemandsRequest(request.Ukprn, request.CourseId,
locationTask.Result?.GeoPoint?.FirstOrDefault(), locationTask.Result?.GeoPoint?.LastOrDefault(),
radius));
return(new GetEmployerCourseProviderDemandQueryResult
{
Course = courseTask.Result,
Location = locationTask.Result,
EmployerCourseDemands = demand.EmployerCourseDemands,
Total = demand.Total,
TotalFiltered = demand.TotalFiltered,
ProviderDetail = providerCourseInfoTask.Result
});
}
public async Task <GetTrainingCourseResult> Handle(GetTrainingCourseQuery request, CancellationToken cancellationToken)
{
var location = await _locationLookupService.GetLocationInformation(request.LocationName, request.Lat, request.Lon);
var standardTask = _apiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.Id));
var providersTask = _courseDeliveryApiClient.Get <GetUkprnsForStandardAndLocationResponse>(new GetUkprnsForStandardAndLocationRequest(request.Id, location?.GeoPoint?.First() ?? 0, location?.GeoPoint?.Last() ?? 0));
var levelsTask = _cacheHelper.GetRequest <GetLevelsListResponse>(_apiClient,
new GetLevelsListRequest(), nameof(GetLevelsListResponse), out _);
var shortlistTask = _shortlistService.GetShortlistItemCount(request.ShortlistUserId);
await Task.WhenAll(standardTask, providersTask, levelsTask, shortlistTask);
if (standardTask.Result == null)
{
return(new GetTrainingCourseResult());
}
standardTask.Result.LevelEquivalent = levelsTask.Result.Levels.SingleOrDefault(x => x.Code == standardTask.Result.Level)?.Name;
return(new GetTrainingCourseResult
{
Course = standardTask.Result,
ProvidersCount = providersTask.Result.UkprnsByStandard.ToList().Count,
ProvidersCountAtLocation = providersTask.Result.UkprnsByStandardAndLocation.ToList().Count,
ShortlistItemCount = shortlistTask.Result
});
}
public async Task <GetTrainingCourseResult> Handle(GetTrainingCourseQuery request, CancellationToken cancellationToken)
{
var standardTask = _apiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.Id));
var providersTask = _courseDeliveryApiClient.Get <GetUkprnsForStandardAndLocationResponse>(new GetUkprnsForStandardAndLocationRequest(request.Id, request.Lat, request.Lon));
var levelsTask = _cacheHelper.GetRequest <GetLevelsListResponse>(_apiClient,
new GetLevelsListRequest(), nameof(GetLevelsListResponse), out _);
var shortlistTask = _shortlistService.GetShortlistItemCount(request.ShortlistUserId);
var showEmployerDemand = _config.EmployerDemandFeatureToggle && (await _employerDemandApiClient.GetResponseCode(new GetShowEmployerDemandRequest())) == HttpStatusCode.OK;
await Task.WhenAll(standardTask, providersTask, levelsTask, shortlistTask);
if (standardTask.Result == null)
{
return(new GetTrainingCourseResult());
}
standardTask.Result.LevelEquivalent = levelsTask.Result.Levels.SingleOrDefault(x => x.Code == standardTask.Result.Level)?.Name;
return(new GetTrainingCourseResult
{
Course = standardTask.Result,
ProvidersCount = providersTask.Result.UkprnsByStandard.ToList().Count,
ProvidersCountAtLocation = providersTask.Result.UkprnsByStandardAndLocation.ToList().Count,
ShortlistItemCount = shortlistTask.Result,
ShowEmployerDemand = showEmployerDemand
});
}
public async Task <GetStandardsListItem> Handle(GetStandardQuery request, CancellationToken cancellationToken)
{
var course = await _coursesApiClient.Get <GetStandardsListItem>(
new GetStandardDetailsByIdRequest(request.CourseCode));
return(course);
}
public async Task <GetCourseEpaosResult> Handle(GetCourseEpaosQuery request, CancellationToken cancellationToken)
{
var epaosTask = _assessorsApiClient.GetAll <GetCourseEpaoListItem>(
new GetCourseEpaosRequest
{
CourseId = request.CourseId
});
var courseTask = _coursesApiClient.Get <GetStandardsListItem>(
new GetStandardRequest(request.CourseId));
await Task.WhenAll(epaosTask, courseTask);
_logger.LogDebug($"Found [{epaosTask.Result.Count()}] EPAOs for Course Id:[{request.CourseId}].");
var filteredEpaos = epaosTask.Result
.Where(_courseEpaoIsValidFilterService.IsValidCourseEpao)
.ToList();
_logger.LogDebug($"Found [{filteredEpaos.Count}] EPAOs for Course Id:[{request.CourseId}] after filtering.");
return(new GetCourseEpaosResult
{
Epaos = filteredEpaos.OrderBy(item => item.Name),
Course = courseTask.Result
});
}
public async Task <GetRestartEmployerDemandQueryResult> Handle(GetRestartEmployerDemandQuery request, CancellationToken cancellationToken)
{
var expiredDemandTask =
_demandApiClient.Get <GetEmployerDemandResponse>(
new GetEmployerDemandByExpiredDemandRequest(request.Id));
var demandTask =
_demandApiClient.Get <GetEmployerDemandResponse>(
new GetEmployerDemandRequest(request.Id));
await Task.WhenAll(expiredDemandTask, demandTask);
var coursesResult = await _coursesApiClient.Get <GetStandardsListItem>(new GetStandardRequest(demandTask.Result.Course.Id));
if (expiredDemandTask.Result != null)
{
return(new GetRestartEmployerDemandQueryResult
{
EmployerDemand = expiredDemandTask.Result,
RestartDemandExists = true,
LastStartDate = coursesResult.StandardDates.LastDateStarts
});
}
return(new GetRestartEmployerDemandQueryResult
{
EmployerDemand = demandTask.Result,
RestartDemandExists = false,
LastStartDate = coursesResult.StandardDates.LastDateStarts
});
}
public async Task <GetTrainingProgrammesQueryResult> Handle(GetTrainingProgrammesQuery request, CancellationToken cancellationToken)
{
var frameworksTask = _coursesApiClient.Get <GetFrameworksListResponse>(new GetFrameworksRequest());
var standardsTask = _coursesApiClient.Get <GetStandardsListResponse>(new GetActiveStandardsListRequest());
await Task.WhenAll(frameworksTask, standardsTask);
var trainingProgrammes = new List <TrainingProgramme>();
trainingProgrammes.AddRange(frameworksTask.Result.Frameworks?.Select(item => (TrainingProgramme)item) ?? Array.Empty <TrainingProgramme>());
trainingProgrammes.AddRange(standardsTask.Result.Standards?.Select(item => (TrainingProgramme)item) ?? Array.Empty <TrainingProgramme>());
return(new GetTrainingProgrammesQueryResult
{
TrainingProgrammes = trainingProgrammes
});
}
public async Task <GetStandardsResult> Handle(GetStandardsQuery request, CancellationToken cancellationToken)
{
var standards = await _coursesApiClient.Get <GetStandardsListResponse>(new GetStandardsExportRequest());
return(new GetStandardsResult
{
Standards = standards.Standards
});
}
public async Task <GetStandardsQueryResult> Handle(GetStandardsQuery request, CancellationToken cancellationToken)
{
var response = await _coursesApiClient.Get <GetStandardsListResponse>(new GetActiveStandardsListRequest());
return(new GetStandardsQueryResult
{
Standards = response.Standards
});
}
public async Task <GetTrainingCoursesResult> Handle(GetTrainingCoursesQuery request, CancellationToken cancellationToken)
{
var courses = await _coursesApiClient.Get <GetStandardsListResponse>(new GetStandardsRequest());
return(new GetTrainingCoursesResult
{
Courses = courses.Standards
});
}
public async Task <GetStartCourseDemandQueryResult> Handle(GetStartCourseDemandQuery request, CancellationToken cancellationToken)
{
var result = await _coursesApiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.CourseId));
return(new GetStartCourseDemandQueryResult
{
Course = result
});
}
public async Task <GetFrameworksResult> Handle(GetFrameworksQuery request, CancellationToken cancellationToken)
{
var response = await _coursesApiClient.Get <GetFrameworksListResponse>(new GetFrameworksRequest());
return(new GetFrameworksResult
{
Frameworks = response.Frameworks
});
}
public async Task <GetFrameworkCoursesResult> Handle(GetFrameworkCoursesQuery request, CancellationToken cancellationToken)
{
var frameworks = await _coursesApiClient.Get <GetFrameworksListResponse>(new GetFrameworksRequest());
return(new GetFrameworkCoursesResult
{
Frameworks = frameworks.Frameworks.Where(f => f.IsActiveFramework && f.FundingPeriods.Count > 0)
});
}
private async Task <List <Course> > GetAllCoursesFromApi()
{
var standardsResponseTask = _coursesApiClient.Get <GetStandardsListResponse>(new GetAllStandardsRequest());
var frameworksResponseTask = _coursesApiClient.Get <GetFrameworksListResponse>(new GetFrameworksRequest());
await Task.WhenAll(standardsResponseTask, frameworksResponseTask);
var standardCourses = standardsResponseTask.Result.Standards.Select(x => new Course
{
Id = x.LarsCode.ToString(), Level = x.Level, Title = x.Title
}).ToList();
var frameworkCourses = frameworksResponseTask.Result.Frameworks.Select(x => new Course
{
Id = x.Id, Title = x.Title, Level = x.Level
}).ToList();
return(standardCourses.Union(frameworkCourses).ToList());
}
public async Task <GetStandardsQueryResult> Handle(GetStandardsQuery request, CancellationToken cancellationToken)
{
var sector = await GetSectorId(request.Sector);
if (sector == null)
{
return(new GetStandardsQueryResult());
}
var standardsResponse =
await _coursesApiClient.Get <GetStandardsListResponse>(new GetAvailableToStartStandardsListRequest { RouteIds = new List <int> {
sector.Value
} });
return(new GetStandardsQueryResult
{
Standards = standardsResponse.Standards
});
}
public async Task <GetTrainingCourseResult> Handle(GetTrainingCourseQuery request, CancellationToken cancellationToken)
{
var standardTask = _apiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.Id));
await Task.WhenAll(standardTask);
return(new GetTrainingCourseResult
{
Course = standardTask.Result
});
}
private async Task <List <GetStandardsListItem> > GetStandardsList(string standardId)
{
var standards = new List <GetStandardsListItem>();
if (string.IsNullOrEmpty(standardId))
{
var standardsResponse = await _coursesApiClient.Get <GetStandardsListResponse>(new GetAvailableToStartStandardsListRequest());
standards = standardsResponse.Standards.ToList();
}
else
{
var standard = await _coursesApiClient.Get <GetStandardsListItem>(new GetStandardDetailsByIdRequest(standardId));
standards.Add(standard);
}
return(standards);
}
public async Task <GetStandardDetailsResult> Handle(GetStandardDetailsQuery request, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(request.Id))
{
throw new ArgumentException("Standard Id is required", nameof(GetStandardDetailsQuery.Id));
}
var standardDetails = await _coursesApiClient.Get <StandardDetailResponse>(new GetStandardDetailsByIdRequest(request.Id));
return(new GetStandardDetailsResult(standardDetails));
}
public async Task <CreateApplicationCommandResult> Handle(CreateApplicationCommand request, CancellationToken cancellationToken)
{
_logger.LogInformation($"Creating Application to Pledge {request.PledgeId} for Account {request.EmployerAccountId}");
var accountTask = _levyTransferMatchingService.GetAccount(new GetAccountRequest(request.EmployerAccountId));
var standardTask = _coursesApiClient.Get <GetStandardsListItem>(new GetStandardDetailsByIdRequest(request.StandardId));
await Task.WhenAll(accountTask, standardTask);
var account = accountTask.Result;
var standard = standardTask.Result;
if (account == null)
{
_logger.LogInformation($"Account {request.EmployerAccountId} does not exist - creating");
await CreateAccount(request);
}
var data = new CreateApplicationRequestData
{
EmployerAccountId = request.EmployerAccountId,
Details = request.Details,
StandardId = request.StandardId,
StandardTitle = standard.Title,
StandardLevel = standard.Level,
StandardDuration = standard.TypicalDuration,
StandardMaxFunding = standard.MaxFundingOn(request.StartDate),
StandardRoute = standard.Route,
NumberOfApprentices = request.NumberOfApprentices,
StartDate = request.StartDate,
HasTrainingProvider = request.HasTrainingProvider,
Sectors = request.Sectors,
Locations = request.Locations,
AdditionalLocation = request.AdditionalLocation,
SpecificLocation = request.SpecificLocation,
FirstName = request.FirstName,
LastName = request.LastName,
EmailAddresses = request.EmailAddresses,
BusinessWebsite = request.BusinessWebsite,
UserId = request.UserId,
UserDisplayName = request.UserDisplayName
};
var createApplicationRequest = new CreateApplicationRequest(request.PledgeId, data);
var result = await _levyTransferMatchingService.CreateApplication(createApplicationRequest);
return(new CreateApplicationCommandResult
{
ApplicationId = result.ApplicationId
});
}
public async Task <GetRegisterDemandResult> Handle(GetRegisterDemandQuery request, CancellationToken cancellationToken)
{
var course = _coursesApiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.CourseId));
var location = _locationLookupService.GetLocationInformation(request.LocationName, 0, 0);
await Task.WhenAll(course, location);
return(new GetRegisterDemandResult
{
Course = course.Result,
Location = location.Result
});
}
public async Task <GetTrainingCourseProvidersResult> Handle(GetTrainingCourseProvidersQuery request, CancellationToken cancellationToken)
{
var locationTask = _locationLookupService.GetLocationInformation(request.Location, request.Lat, request.Lon);
var courseTask = _coursesApiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.Id));
var shortlistTask = _shortlistService.GetShortlistItemCount(request.ShortlistUserId);
await Task.WhenAll(locationTask, courseTask, shortlistTask);
var providers = await _courseDeliveryApiClient.Get <GetProvidersListResponse>(new GetProvidersByCourseRequest(
request.Id,
courseTask.Result.SectorSubjectAreaTier2Description,
courseTask.Result.Level,
locationTask.Result?.GeoPoint?.FirstOrDefault(),
locationTask.Result?.GeoPoint?.LastOrDefault(),
request.SortOrder,
request.ShortlistUserId));
if (providers?.Providers.Any() == true)
{
var ukprns = providers.Providers.Select(s => s.Ukprn);
var apprenticeFeedbackRatings =
await _apprenticeFeedbackApiClient.
PostWithResponseCode <IEnumerable <GetApprenticeFeedbackResponse> >(
new PostApprenticeFeedbackRequest
{
Data = new PostApprenticeFeedbackRequestData {
Ukprns = ukprns
}
});
if (apprenticeFeedbackRatings.StatusCode == HttpStatusCode.OK)
{
foreach (var ratingResponse in apprenticeFeedbackRatings.Body)
{
providers.Providers.First(s => s.Ukprn == ratingResponse.Ukprn).ApprenticeFeedback = ratingResponse;
}
}
}
return(new GetTrainingCourseProvidersResult
{
Course = courseTask.Result,
Providers = providers?.Providers,
Total = providers?.TotalResults ?? 0,
Location = locationTask.Result,
ShortlistItemCount = shortlistTask.Result
});
}
public async Task <GetStandardsQueryResult> Handle(GetStandardsQuery request, CancellationToken cancellationToken)
{
var standards = new List <GetStandardsListItem>();
if (string.IsNullOrEmpty(request.StandardId))
{
var standardsResponse = await _coursesApiClient.Get <GetStandardsListResponse>(new GetAvailableToStartStandardsListRequest());
standards = standardsResponse.Standards.ToList();
}
else
{
var standard = await _coursesApiClient.Get <GetStandardsListItem>(new GetStandardDetailsByIdRequest(request.StandardId));
standards.Add(standard);
}
return(new GetStandardsQueryResult
{
Standards = standards
});
}
public async Task <GetTrainingCourseProvidersResult> Handle(GetTrainingCourseProvidersQuery request, CancellationToken cancellationToken)
{
var courseTask = _coursesApiClient.Get <GetStandardsListItem>(new GetStandardRequest(request.Id));
var providersTask = _courseDeliveryApiClient.Get <GetProvidersListResponse>(new GetProvidersByCourseRequest(request.Id));
await Task.WhenAll(courseTask, providersTask);
return(new GetTrainingCourseProvidersResult
{
Course = courseTask.Result,
Providers = providersTask.Result.Providers,
Total = providersTask.Result.TotalResults
});
}
public async Task <GetTrainingCoursesListResult> Handle(GetTrainingCoursesListQuery request, CancellationToken cancellationToken)
{
_taskList = new List <Task>();
var standardsTask = _apiClient.Get <GetStandardsListResponse>(new GetStandardsListRequest
{
Keyword = request.Keyword,
RouteIds = request.RouteIds,
Levels = request.Levels,
OrderBy = request.OrderBy
});
_taskList.Add(standardsTask);
var sectorsTask = GetRequest <GetSectorsListResponse>(new GetSectorsListRequest(), nameof(GetSectorsListResponse), out _saveSectorsToCache);
_taskList.Add(sectorsTask);
var levelsTask = GetRequest <GetLevelsListResponse>(new GetLevelsListRequest(), nameof(GetLevelsListResponse), out _saveLevelsToCache);
_taskList.Add(levelsTask);
await Task.WhenAll(_taskList);
await UpdateCachedItems(sectorsTask, levelsTask);
return(new GetTrainingCoursesListResult
{
Courses = standardsTask.Result.Standards,
Sectors = sectorsTask.Result.Sectors,
Levels = levelsTask.Result.Levels,
Total = standardsTask.Result.Total,
TotalFiltered = standardsTask.Result.TotalFiltered,
OrderBy = request.OrderBy
});
}
public async Task <GetCourseEpaosResult> Handle(GetCourseEpaosQuery request, CancellationToken cancellationToken)
{
var epaosTask = _assessorsApiClient.GetAll <GetCourseEpaoListItem>(
new GetCourseEpaosRequest
{
CourseId = request.CourseId
});
var courseTask = _coursesApiClient.Get <GetStandardsListItem>(
new GetStandardRequest(request.CourseId));
await Task.WhenAll(epaosTask, courseTask);
_logger.LogDebug($"Found [{epaosTask.Result.Count()}] EPAOs for Course Id:[{request.CourseId}].");
var filteredEpaos = epaosTask.Result
.Where(_courseEpaoIsValidFilterService.IsValidCourseEpao)
.ToList();
var epaoTasks = filteredEpaos.
ToDictionary(
t => t.EpaoId,
t => _assessorsApiClient.Get <IEnumerable <GetStandardsExtendedListItem> >(
new GetCourseEpaosStandardVersionsRequest(t.EpaoId, request.CourseId)));
await Task.WhenAll(epaoTasks.Select(x => x.Value).ToArray());
foreach (var filtEpao in filteredEpaos)
{
if (epaoTasks.TryGetValue(filtEpao.EpaoId, out var epaoResponse) && epaoResponse.Result != null)
{
var epaoVersions = epaoResponse.Result
.Where(c => _courseEpaoIsValidFilterService.ValidateVersionDates(c.DateVersionApproved, c.EffectiveFrom, c.EffectiveTo))
.Select(x => x.Version).ToArray();
filtEpao.CourseEpaoDetails.StandardVersions = epaoVersions;
}
}
_logger.LogDebug($"Found [{filteredEpaos.Count}] EPAOs for Course Id:[{request.CourseId}] after filtering.");
return(new GetCourseEpaosResult
{
Epaos = filteredEpaos.Where(x => x.CourseEpaoDetails.StandardVersions.Length > 0)
.OrderBy(item => item.Name),
Course = courseTask.Result
});
}
public async Task <GetStandardsListResponse> GetCourses()
{
var courses = await _cacheStorageService
.RetrieveFromCache <GetStandardsListResponse>(nameof(GetStandardsListResponse));
if (courses != null)
{
return(courses);
}
courses = await _coursesApiClient.Get <GetStandardsListResponse>(new GetActiveStandardsListRequest());
await _cacheStorageService.SaveToCache(nameof(GetStandardsListResponse), courses, DeliveryAreaCacheDurationInHours);
return(courses);
}
public async Task <GetRoutesQueryResult> Handle(GetRoutesQuery request, CancellationToken cancellationToken)
{
var response = await _cacheStorageService.RetrieveFromCache <GetRoutesListResponse>(nameof(GetRoutesListResponse));
if (response == null)
{
response = await _coursesApiClient.Get <GetRoutesListResponse>(new GetRoutesListRequest());
await _cacheStorageService.SaveToCache(nameof(GetRoutesListResponse), response, 23);
}
return(new GetRoutesQueryResult
{
Routes = response.Routes
});
}
