Ejemplo n.º 1
0
        public async Task <CreateVacancyCommandResponse> Handle(CreateVacancyCommand request, CancellationToken cancellationToken)
        {
            var accountLegalEntity = await _accountLegalEntityPermissionService.GetAccountLegalEntity(
                request.AccountIdentifier, request.PostVacancyRequestData.AccountLegalEntityPublicHashedId);

            if (accountLegalEntity == null)
            {
                throw new SecurityException();
            }

            request.PostVacancyRequestData.LegalEntityName = accountLegalEntity.Name;

            if (request.AccountIdentifier.AccountType == AccountType.Provider)
            {
                request.PostVacancyRequestData.EmployerAccountId = accountLegalEntity.AccountHashedId;
            }

            if (request.PostVacancyRequestData.EmployerNameOption == EmployerNameOption.RegisteredName)
            {
                request.PostVacancyRequestData.EmployerName = accountLegalEntity.Name;
            }

            IPostApiRequest apiRequest;

            if (request.IsSandbox)
            {
                apiRequest = new PostValidateVacancyRequest(request.Id, request.PostVacancyRequestData);
            }
            else
            {
                if (request.AccountIdentifier.AccountType == AccountType.Provider)
                {
                    apiRequest = new PostVacancyRequest(request.Id, request.PostVacancyRequestData.User.Ukprn, "", request.PostVacancyRequestData);
                }
                else
                {
                    apiRequest = new PostVacancyRequest(request.Id, request.PostVacancyRequestData.User.Ukprn, request.PostVacancyRequestData.User.Email, request.PostVacancyRequestData);
                }
            }

            var result = await _recruitApiClient.PostWithResponseCode <string>(apiRequest);

            if (!((int)result.StatusCode >= 200 && (int)result.StatusCode <= 299))
            {
                if (result.StatusCode.Equals(HttpStatusCode.BadRequest))
                {
                    throw new HttpRequestContentException($"Response status code does not indicate success: {(int)result.StatusCode} ({result.StatusCode})", result.StatusCode, result.ErrorContent);
                }

                throw new Exception(
                          $"Response status code does not indicate success: {(int) result.StatusCode} ({result.StatusCode})");
            }

            return(new CreateVacancyCommandResponse
            {
                VacancyReference = result.Body
            });
        }
Ejemplo n.º 2
0
        public async Task <GetVacanciesQueryResult> Handle(GetVacanciesQuery request, CancellationToken cancellationToken)
        {
            if (!string.IsNullOrEmpty(request.AccountLegalEntityPublicHashedId))
            {
                switch (request.AccountIdentifier.AccountType)
                {
                case AccountType.Unknown:
                    throw new SecurityException();

                case AccountType.External:
                    request.AccountLegalEntityPublicHashedId = string.Empty;
                    request.AccountPublicHashedId            = string.Empty;
                    break;

                default:
                {
                    var accountLegalEntity = await _accountLegalEntityPermissionService.GetAccountLegalEntity(request.AccountIdentifier,
                                                                                                              request.AccountLegalEntityPublicHashedId);

                    if (accountLegalEntity == null)
                    {
                        throw new SecurityException();
                    }
                    break;
                }
                }
            }

            var categories = _courseService.MapRoutesToCategories(request.Routes);

            var vacanciesTask = _findApprenticeshipApiClient.Get <GetVacanciesResponse>(new GetVacanciesRequest(
                                                                                            request.PageNumber, request.PageSize, request.AccountLegalEntityPublicHashedId,
                                                                                            request.Ukprn, request.AccountPublicHashedId, request.StandardLarsCode, request.NationWideOnly,
                                                                                            request.Lat, request.Lon, request.DistanceInMiles, categories, request.PostedInLastNumberOfDays, request.Sort));
            var standardsTask = _courseService.GetActiveStandards <GetStandardsListResponse>(nameof(GetStandardsListResponse));

            await Task.WhenAll(vacanciesTask, standardsTask);

            foreach (var vacanciesItem in vacanciesTask.Result.ApprenticeshipVacancies)
            {
                if (vacanciesItem.StandardLarsCode == null)
                {
                    continue;
                }

                var standard =
                    standardsTask.Result.Standards.FirstOrDefault(
                        c => c.LarsCode.Equals(vacanciesItem.StandardLarsCode));
                if (standard != null)
                {
                    vacanciesItem.CourseTitle = standard.Title;
                    vacanciesItem.Route       = standard.Route;
                    vacanciesItem.CourseLevel = standard.Level;
                }

                vacanciesItem.VacancyUrl = $"{_vacanciesConfiguration.FindAnApprenticeshipBaseUrl}/apprenticeship/reference/{vacanciesItem.VacancyReference}";
            }

            return(new GetVacanciesQueryResult()
            {
                Vacancies = vacanciesTask.Result.ApprenticeshipVacancies.Where(c => c.StandardLarsCode != null).ToList(),
                Total = vacanciesTask.Result.Total,
                TotalFiltered = vacanciesTask.Result.TotalFound,
                TotalPages = request.PageSize != 0 ? (int)Math.Ceiling((decimal)vacanciesTask.Result.TotalFound / request.PageSize) : 0
            });
        }