public async Task <CachedReservation> GetProviderReservation(Guid id, uint ukPrn)
{
if (string.IsNullOrEmpty(id.ToString()) || id == Guid.Empty)
{
throw new ArgumentException("GUID is not set", nameof(id));
}
if (ukPrn == default(uint))
{
throw new ArgumentException("ukPrn is not set", nameof(ukPrn));
}
var cachedReservation = await _cacheStorage.RetrieveFromCache <CachedReservation>(id.ToString());
if (cachedReservation == null)
{
throw new CachedReservationNotFoundException(id);
}
if (!_authorisationService.ProviderReservationAccessAllowed(ukPrn, cachedReservation))
{
throw new UnauthorizedAccessException();
}
return(cachedReservation);
}
public async Task <OutcomeViewModel> GetOversightDetailsViewModel(Guid applicationId, Guid?outcomeKey)
{
var applicationDetailsTask = _applyApiClient.GetApplicationDetails(applicationId);
var oversightReviewTask = _applyApiClient.GetOversightReview(applicationId);
await Task.WhenAll(applicationDetailsTask, oversightReviewTask);
var applicationDetails = _applyApiClient.GetApplicationDetails(applicationId).Result;
var oversightReview = _applyApiClient.GetOversightReview(applicationId).Result;
GetAppealResponse appealResponse = null;
if (oversightReview != null)
{
appealResponse = await _applyApiClient.GetAppeal(applicationId, oversightReview.Id);
}
var viewModel = new OutcomeViewModel
{
IsNew = oversightReview == null,
ApplicationSummary = CreateApplicationSummaryViewModel(applicationDetails),
GatewayOutcome = CreateGatewayOutcomeViewModel(applicationDetails, oversightReview),
FinancialHealthOutcome = CreateFinancialHealthOutcomeViewModel(applicationDetails),
ModerationOutcome = CreateModerationOutcomeViewModel(applicationDetails, oversightReview),
InProgressDetails = CreateInProgressDetailsViewModel(oversightReview),
OverallOutcome = CreateOverallOutcomeViewModel(oversightReview),
AppealViewModel = appealResponse == null ? null : CreateAppealViewModel(applicationDetails, appealResponse),
ShowAppealLink = oversightReview != null && oversightReview.Status == OversightReviewStatus.Unsuccessful && appealResponse == null,
ShowInProgressDetails = oversightReview?.InProgressDate != null,
OversightStatus = oversightReview?.Status ?? OversightReviewStatus.None,
ApproveGateway = GetStringValueForApprovalStatusBoolean(oversightReview?.GatewayApproved),
ApproveModeration = GetStringValueForApprovalStatusBoolean(oversightReview?.ModerationApproved),
IsGatewayRemoved = applicationDetails.ApplicationStatus == ApplicationStatus.Removed,
IsGatewayFail = applicationDetails.GatewayReviewStatus == GatewayReviewStatus.Fail,
HasFinalOutcome = oversightReview != null && oversightReview.Status != OversightReviewStatus.None && oversightReview.Status != OversightReviewStatus.InProgress
};
if (oversightReview == null || oversightReview.Status == OversightReviewStatus.InProgress)
{
var cachedItem = await _cacheStorageService.RetrieveFromCache <OutcomePostRequest>(outcomeKey.ToString());
if (cachedItem == null)
{
return(viewModel);
}
viewModel.OversightStatus = cachedItem.OversightStatus;
viewModel.ApproveGateway = cachedItem.ApproveGateway;
viewModel.ApproveModeration = cachedItem.ApproveModeration;
viewModel.SuccessfulText = cachedItem.SuccessfulText;
viewModel.SuccessfulAlreadyActiveText = cachedItem.SuccessfulAlreadyActiveText;
viewModel.SuccessfulFitnessForFundingText = cachedItem.SuccessfulFitnessForFundingText;
viewModel.UnsuccessfulText = cachedItem.UnsuccessfulText;
viewModel.UnsuccessfulExternalText = cachedItem.UnsuccessfulExternalText;
viewModel.InProgressInternalText = cachedItem.InProgressInternalText;
viewModel.InProgressExternalText = cachedItem.InProgressExternalText;
}
return(viewModel);
}
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 <FrameworkDetailsViewModel> GetFramework(string id)
{
var cacheKey = $"FatComponentsCache-Apprenticeship_details-{id}";
var cacheEntry = await _cacheService.RetrieveFromCache <FrameworkDetailsViewModel>(cacheKey);
if (cacheEntry == null)
{
var response = await _mediator.Send(new GetFrameworkQuery { Id = id });
string message;
switch (response.StatusCode)
{
case GetFrameworkResponse.ResponseCodes.InvalidFrameworkId:
_logger.Info("404 - Framework id has wrong format");
throw new ArgumentException($"Framework id: {id} has wrong format");
case GetFrameworkResponse.ResponseCodes.FrameworkNotFound:
message = $"Cannot find framework: {id}";
_logger.Warn($"404 - {message}");
throw new ArgumentException(message);
case GetFrameworkResponse.ResponseCodes.Gone:
message = $"Expired framework request: {id}";
_logger.Warn($"410 - {message}");
throw new ArgumentException(message);
case GetFrameworkResponse.ResponseCodes.Success:
_logger.Info($"mapping framework {id}");
cacheEntry = _frameworkDetailsViewModelMapper.Map(response.Framework);
_logger.Info($"Saving to cache");
await _cacheService.SaveToCache(cacheKey, cacheEntry, new TimeSpan(_cacheSettings.CacheAbsoluteExpirationDays, 0, 0, 0), new TimeSpan(_cacheSettings.CacheSlidingExpirationDays, 0, 0, 0));
break;
default:
_logger.Info($"Cannot handle GetFrameworkQuery response: {response.StatusCode.ToString()}");
throw new ArgumentOutOfRangeException();
}
}
return(cacheEntry);
}
public async Task <TrainingProviderDetailsViewModel> GetDetails(TrainingProviderDetailQueryViewModel detailsQueryModel)
{
var cacheKey = $"FatComponentsCache-providerdetails-{detailsQueryModel.Ukprn}-{detailsQueryModel.LocationId}-{detailsQueryModel.ApprenticeshipId}";
var cacheEntry = await _cacheService.RetrieveFromCache <TrainingProviderDetailsViewModel>(cacheKey);
if (cacheEntry == null)
{
var response = await _mediator.Send(new ApprenticeshipProviderDetailQuery()
{
UkPrn = Convert.ToInt32(detailsQueryModel.Ukprn), ApprenticeshipId = detailsQueryModel.ApprenticeshipId, ApprenticeshipType = detailsQueryModel.ApprenticeshipType, LocationId = detailsQueryModel.LocationId
});
if (response.StatusCode == ApprenticeshipProviderDetailResponse.ResponseCodes.ApprenticeshipProviderNotFound)
{
var message = $"Cannot find provider: {detailsQueryModel.Ukprn}";
_logger.Warn($"404 - {message}");
throw new HttpRequestException(message);
}
if (response.StatusCode == ApprenticeshipProviderDetailResponse.ResponseCodes.InvalidInput)
{
var message = $"Not able to call the apprenticeship service.";
_logger.Warn($"{response.StatusCode} - {message}");
throw new HttpRequestException(message);
}
cacheEntry = _trainingProviderDetailsViewModelMapper.Map(response, detailsQueryModel.ApprenticeshipId);
await _cacheService.SaveToCache(cacheKey, cacheEntry, new TimeSpan(_cacheSettings.CacheAbsoluteExpirationDays, 0, 0, 0), new TimeSpan(_cacheSettings.CacheSlidingExpirationDays, 0, 0, 0));
}
return(cacheEntry);
}
private async Task <int?> GetSectorId(string sector)
{
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.Routes.FirstOrDefault(c => c.Name.Equals(sector, StringComparison.CurrentCultureIgnoreCase))?.Id);
}
private async Task <List <ReferenceDataItem> > GetFromApiWithCache(IGetAllApiRequest request)
{
var result = await _cacheStorageService.RetrieveFromCache <List <ReferenceDataItem> >($"{CacheKeyPrefix}{request.GetAllUrl}");
if (result != null)
{
return(result);
}
var response = (await _levyTransferMatchingApiClient.GetAll <ReferenceDataItem>(request)).ToList();
await _cacheStorageService.SaveToCache($"{CacheKeyPrefix}{request.GetAllUrl}", response, CacheExpiryInHours);
return(response);
}
public async Task <T> GetData <T>(IGetApiRequest request, string cacheKey, Func <ApiResponse <T>, bool> requestCheck)
{
var cachedItem = await _cacheStorageService.RetrieveFromCache <T>(cacheKey);
if (cachedItem != null)
{
return(cachedItem);
}
var requestData = await _client.GetWithResponseCode <T>(request);
if (requestData.StatusCode == HttpStatusCode.NotFound || !requestCheck(requestData))
{
return(default);
public async Task <IReadOnlyList <GetDeliveryAreaListItem> > GetDeliveryAreas()
{
var deliveryAreas = await _cacheStorageService
.RetrieveFromCache <IReadOnlyList <GetDeliveryAreaListItem> >(nameof(GetDeliveryAreasRequest));
if (deliveryAreas != null)
{
return(deliveryAreas);
}
deliveryAreas = (await _assessorsApiClient.GetAll <GetDeliveryAreaListItem>(new GetDeliveryAreasRequest())).ToList();
await _cacheStorageService.SaveToCache(nameof(GetDeliveryAreasRequest), deliveryAreas, DeliveryAreaCacheDurationInHours);
return(deliveryAreas);
}
public async Task <List <Course> > GetAllCourses()
{
var cacheResult = await _cacheStorageService.RetrieveFromCache <List <Course> >($"{CacheKey}");
if (cacheResult != null)
{
return(cacheResult);
}
var result = await GetAllCoursesFromApi();
await _cacheStorageService.SaveToCache($"{CacheKey}", result, CacheExpiryInHours);
return(result);
}
public async Task <CourseList> GetCourses()
{
var cachedCourseList = await _cacheStorageService.RetrieveFromCache <CourseList>(nameof(CourseList));
if (cachedCourseList != default)
{
return(cachedCourseList);
}
var apiRequest = new GetCoursesApiRequest();
var courseList = await _apiClient.Get <CourseList>(apiRequest);
await _cacheStorageService.SaveToCache(nameof(CourseList), courseList, CacheDurationInHours);
return(courseList);
}
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 <DeliveryAreaList> GetDeliveryAreas()
{
var cachedDeliveryAreas = await _cacheStorageService.RetrieveFromCache <DeliveryAreaList>(nameof(DeliveryAreaList));
if (cachedDeliveryAreas != default)
{
return(cachedDeliveryAreas);
}
var apiRequest = new GetDeliveryAreasApiRequest();
var deliveryAreas = await _apiClient.Get <DeliveryAreaList>(apiRequest);
await _cacheStorageService.SaveToCache(nameof(DeliveryAreaList), deliveryAreas, CacheDurationInHours);
return(deliveryAreas);
}
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
});
}
private async Task <BasketViewModel <ApprenticeshipBasketItemViewModel> > GetBasket(Guid basketId, bool fromCache)
{
if (fromCache)
{
var cacheKey = $"FatComponentsCache-Basket-{basketId.ToString()}";
var cachedBasket = await _cacheService.RetrieveFromCache <BasketViewModel <ApprenticeshipBasketItemViewModel> >(cacheKey);
if (cachedBasket != null)
{
return(cachedBasket);
}
}
var basket = await _mediator.Send(new GetBasketQuery { BasketId = basketId });
return(_basketViewModelMapper.Map(basket, basketId));
}
public async Task <GetAvailableApiProductsResponse> GetAvailableProducts(string accountType)
{
var cachedProducts = await _cacheStorageService.RetrieveFromCache <GetAvailableApiProductsResponse>($"{accountType}-{nameof(GetAvailableApiProductsResponse)}");
if (cachedProducts != null)
{
return(cachedProducts);
}
var products =
await _apimDeveloperApiClient.Get <GetAvailableApiProductsResponse>(
new GetAvailableApiProductsRequest(accountType));
await _cacheStorageService.SaveToCache($"{accountType}-{nameof(GetAvailableApiProductsResponse)}", products,
CachedProductExpiryTimeInHours);
return(products);
}
private Task <TResponse> GetRequest <TResponse>(IGetApiRequest request, string keyName, out bool updateCache)
{
Task <TResponse> levelsTask;
updateCache = false;
var itemFromCache =
_cacheStorageService.RetrieveFromCache <TResponse>(keyName).Result;
if (itemFromCache != null)
{
levelsTask = Task.FromResult(itemFromCache);
}
else
{
levelsTask = _apiClient.Get <TResponse>(request);
updateCache = true;
}
return(levelsTask);
}
public async Task <GetCandidateSkillsQueryResponse> Handle(GetCandidateSkillsQuery request, CancellationToken cancellationToken)
{
var cachedSkills = await _cacheStorageService.RetrieveFromCache <List <string> >(CacheKey);
if (cachedSkills != null)
{
return(new GetCandidateSkillsQueryResponse
{
CandidateSkills = cachedSkills
});
}
var response =
await _apiClient.Get <List <string> >(new GetCandidateSkillsRequest());
await _cacheStorageService.SaveToCache(CacheKey, response, CacheDurationInHours);
return(new GetCandidateSkillsQueryResponse()
{
CandidateSkills = response
});
}
public async Task <GetTrainingCoursesQueryResult> Handle(GetTrainingCoursesQuery request, CancellationToken cancellationToken)
{
var courses =
await _cacheStorageService.RetrieveFromCache <GetStandardsListResponse>(
nameof(GetStandardsListResponse));
if (courses != null)
{
return(new GetTrainingCoursesQueryResult
{
TrainingCourses = courses.Standards
});
}
courses = await _coursesApiClient.Get <GetStandardsListResponse>(new GetActiveStandardsListRequest());
await _cacheStorageService.SaveToCache(nameof(GetStandardsListResponse), courses, CourseCacheDurationInHours);
return(new GetTrainingCoursesQueryResult
{
TrainingCourses = courses.Standards
});
}
public async Task <FatSearchResultsViewModel> GetSearchResults(SearchQueryViewModel searchQueryModel)
{
var cacheKey = $"FatComponentsCache-searchresults-{searchQueryModel.Keywords}-{searchQueryModel.Page}-{searchQueryModel.ResultsToTake}-{searchQueryModel.SortOrder}";
foreach (var level in searchQueryModel.SelectedLevels)
{
cacheKey += $"-{level}";
}
var model = await _cacheService.RetrieveFromCache <FatSearchResultsViewModel>(cacheKey);
if (model == null)
{
var results = _apprenticeshipSearchService.SearchByKeyword(searchQueryModel.Keywords, searchQueryModel.Page, searchQueryModel.ResultsToTake, searchQueryModel.SortOrder, searchQueryModel.SelectedLevels);
model = _fatSearchResultsViewModelMapper.Map(await results);
await _cacheService.SaveToCache(cacheKey, model, new TimeSpan(_cacheSettings.CacheAbsoluteExpirationDays, 0, 0, 0), new TimeSpan(_cacheSettings.CacheSlidingExpirationDays, 0, 0, 0));
}
model.SearchQuery.AddRemoveBasketResponse = searchQueryModel.AddRemoveBasketResponse;
return(model);
}
public async Task <CourseDemandRequest> GetCachedCourseDemand(Guid itemKey)
{
var result = await _cacheStorageService.RetrieveFromCache <CourseDemandRequest>(itemKey.ToString());
return(result);
}
public async Task <GetApprenticeshipsFilterValuesQueryResult> Handle(GetApprenticeshipsFilterValuesQuery query, CancellationToken cancellationToken)
{
var cacheKey = "";
if (query.ProviderId.HasValue)
{
cacheKey = $"{nameof(GetApprenticeshipsFilterValuesQueryResult)}-{query.ProviderId}";
}
if (query.EmployerAccountId.HasValue)
{
cacheKey = $"{nameof(GetApprenticeshipsFilterValuesQueryResult)}-{query.EmployerAccountId}";
}
if (!string.IsNullOrWhiteSpace(cacheKey))
{
var result =
await _cacheStorageService.RetrieveFromCache <GetApprenticeshipsFilterValuesQueryResult>(cacheKey);
if (result != null)
{
return(result);
}
}
var stringDbTasks = new List <Task <List <string> > >();
if (query.ProviderId.HasValue)
{
stringDbTasks.Add(GetDistinctEmployerNames(query, cancellationToken));
}
if (query.EmployerAccountId.HasValue)
{
stringDbTasks.Add(GetDistinctProviderNames(query, cancellationToken));
}
stringDbTasks.Add(GetDistinctCourseNames(query, cancellationToken));
var dateDbTasks = new[] {
GetDistinctStartDates(query, cancellationToken),
GetDistinctEndDates(query, cancellationToken)
};
var dbTasks = new List <Task>();
dbTasks.AddRange(stringDbTasks);
dbTasks.AddRange(dateDbTasks);
Task.WaitAll(dbTasks.ToArray <Task>());
var queryResult = await Task.FromResult(new GetApprenticeshipsFilterValuesQueryResult
{
StartDates = dateDbTasks[0].Result,
EndDates = dateDbTasks[1].Result
});
if (query.ProviderId.HasValue)
{
queryResult.EmployerNames = stringDbTasks[0].Result;
queryResult.CourseNames = stringDbTasks[1].Result;
}
else if (query.EmployerAccountId.HasValue)
{
queryResult.ProviderNames = stringDbTasks[0].Result;
queryResult.CourseNames = stringDbTasks[1].Result;
}
else
{
queryResult.CourseNames = stringDbTasks[1].Result;
}
await _cacheStorageService.SaveToCache(cacheKey, queryResult, 1);
return(queryResult);
}
private async Task <IDictionary <string, Course> > GetCachedLookup()
{
var lookup = await _cacheService.RetrieveFromCache <IDictionary <string, Course> >(nameof(CourseService)) ?? await CacheCoursesFromApi();
return(lookup);
}