/// <summary>
/// Метод отображает необходимые вакансии для различных ролей
/// </summary>
/// <param name="filter"></param>
/// <param name="options"></param>
/// <returns></returns>
public ActionResult ShowVacancies(VacancyFilter filter, FetchOptions options)
{
var model = new VacancyListViewModel
{
Role = CurrentUser.Role
};
switch (CurrentUser.Role)
{
case Models.Role.Employer:
{
model.Vacancies = employerRepository.ShowMyVacancies(CurrentUser.Id, filter, options);
return(View(model));
}
case Models.Role.Admin:
{
model.Vacancies = employerRepository.GetAllWithSort(options);
return(View(model));
}
case Role.Jobseeker:
{
model.Vacancies = employerRepository.GetAllWithSort(options);
return(View(model));
}
}
return(View());
}
public async Task <ActionResult <DataPage <Vacancy> > > Index([FromQuery] VacancyFilter filter)
{
var result = await _vacancyService.GetFilteredAsync(filter);
if (result.Objects.Any(w => w.Id == 0))
{
var vacancies = result.Objects.GroupBy(v => v.ExternalId).Select(vg => vg.FirstOrDefault()).ToList();
var departments = vacancies.Where(v => v.Department != null).Select(v => v.Department).GroupBy(d => d.ExternalId).Select(dg => dg.FirstOrDefault()).ToList();
foreach (var department in departments)
{
_departmentService.Save(department);
}
var employers = vacancies.Where(v => v.Employer != null).Select(v => v.Employer).GroupBy(e => e.ExternalId).Select(eg => eg.FirstOrDefault()).ToList();
foreach (var employer in employers)
{
_employerService.Save(employer);
}
foreach (var vacancy in vacancies)
{
_vacancyService.Save(vacancy);
}
}
return(result);
}
/// <summary>
/// метод для получения вакансий, соответствующих критериям поиска
/// </summary>
/// <param name="selectedCompany"></param>
/// <param name="selectedExperience"></param>
/// <param name="name"></param>
/// <returns></returns>
public ActionResult GetSelectedItems(string selectedCompany, string selectedExperience, string name)
{
if (long.TryParse(selectedCompany, out long company) != true)
{
company = 0;
}
else
{
company = long.Parse(selectedCompany);
}
List <Experience> experiences = new List <Experience>();
if (long.TryParse(selectedExperience, out long experience) != true)
{
experiences = null;
}
else
{
experiences.Add(experienceRepository.Load(long.Parse(selectedExperience)));
}
VacancyFilter filter = new VacancyFilter
{
CompanyName = companyRepository.Load(company),
Experience = experiences,
SearchString = name
};
IList <Vacancy> vacancies = employerRepository.GetVacanciesFiltered(filter);
var model = new VacancyListViewModel
{
Vacancies = vacancies,
Role = CurrentUser.Role
};
return(PartialView("VacanciesTable", model));
}
public ICollection <Vacancy> SelectFilteredOrdered(VacancyFilter filter,
VacancyOrdering ordering)
{
using (ISession session = NHibernateHelper.OpenSession())
{
var criteria = session.CreateCriteria <Vacancy>();
Util.AddStringRestrictions(criteria, filter.TitleWords, "Title");
Util.AddStringRestrictions(criteria, filter.DescriptionWords, "Descriptions");
criteria.Add(Restrictions.Between
("Salary", filter.SalaryLowerBound, filter.SalaryUpperBound));
if (filter.Company != null)
{
criteria.Add(Restrictions
.Where <Vacancy>(v => v.Employee.Company == filter.Company));
}
if (!ordering.Salary)
{
criteria.AddOrder(Order.Desc("Salary"));
}
if (!ordering.Company)
{
criteria.AddOrder(Order.Desc("Company"));
}
return(criteria.List <Vacancy>());
}
}
public async Task <DataPage <Vacancy> > GetFilteredAsync(VacancyFilter filter)
{
try
{
return(await TryGetFilteredFromHeadHunter(filter));
}
catch (HttpRequestException e)
{
_logger.LogWarning($"HeadHunter.ru недоступен {e.Message}");
}
return(await GetFilteredFromDatabase(filter));
}
public HeadHunterFilterJsonModel(VacancyFilter filter)
{
Text = filter.Text;
SearchFields = filter.SearchFields.Select(sf => sf.ToHeadHunterFormat()).ToList();
AreaExternalId = filter.AreaExternalId;
Experience = filter.Experience.ToHeadHunterFormat();
ScheduleTypes = filter.ScheduleTypes.Select(st => st.ToHeadHunterFormat()).ToList();
MetroExternalId = filter.MetroExternalId;
SpecializationsExternalId = filter.SpecializationExternalIds;
EmployerExternalId = filter.EmployerExternalId;
CurrencyCode = filter.SalaryFilter?.CurrencyCode;
Salary = filter.SalaryFilter?.Salary;
OnlyWithSalary = filter.SalaryFilter?.OnlyWithSalary ?? false;
Period = filter.Period;
DateFrom = filter.DateFrom;
DateTo = filter.DateTo;
Page = filter.Page;
PageSize = filter.PageSize;
}
private async Task <DataPage <Vacancy> > TryGetFilteredFromHeadHunter(VacancyFilter filter)
{
var vacanciesDataPage = new DataPage <Vacancy>();
var headHunterFilter = new HeadHunterFilterJsonModel(filter);
var queryString = await UrlHelper.ToQueryStringAsync(headHunterFilter);
var httpResponse = await _httpClient.GetAsync($"{_settings.EndpointUrl}?{queryString}");
httpResponse.EnsureSuccessStatusCode();
var sResult = await httpResponse.Content.ReadAsStringAsync();
if (_jsonDeserializer.TryDeserializeContent(sResult, out var deserializedVacancies))
{
vacanciesDataPage = deserializedVacancies;
}
return(vacanciesDataPage);
}
private async Task <DataPage <Vacancy> > GetFilteredFromDatabase(VacancyFilter filter)
{
var query = _context.Vacancies.Include(v => v.Employer).AsNoTracking().AsQueryable();
if (!String.IsNullOrWhiteSpace(filter.Text))
{
var predicate = PredicateBuilder.False <Vacancy>();
if (!filter.SearchFields.Any() || filter.SearchFields.Contains(SearchField.CompanyName))
{
predicate = predicate.Or(v => v.Employer.Name.Contains(filter.Text));
}
if (!filter.SearchFields.Any() || filter.SearchFields.Contains(SearchField.Name))
{
predicate = predicate.Or(v => v.Name.Contains(filter.Text));
}
if (!filter.SearchFields.Any() || filter.SearchFields.Contains(SearchField.Description))
{
predicate = predicate.Or(v => v.Description.Contains(filter.Text));
}
query = query.Where(predicate);
}
if (filter.EmploymentTypes.Any())
{
query = query.Where(v => filter.EmploymentTypes.Contains(v.Employment.Value));
}
if (filter.ScheduleTypes.Any())
{
query = query.Where(v => filter.ScheduleTypes.Contains(v.Schedule.Value));
}
if (filter.Experience.HasValue)
{
query = query.Where(v => v.Experience.Equals(filter.Experience));
}
if (filter.SpecializationExternalIds.Any())
{
foreach (var specialization in filter.SpecializationExternalIds)
{
query = query.Where(v => v.VacancySpecializationLinks.Select(vsl => vsl.Specialization.ExternalId).Contains(specialization));
}
}
if (filter.SalaryFilter != null)
{
if (filter.SalaryFilter.OnlyWithSalary)
{
query = query.Where(v => v.Salary.From.HasValue || v.Salary.To.HasValue);
}
if (filter.SalaryFilter.Salary.HasValue)
{
query = query.Where(v =>
(!v.Salary.From.HasValue || v.Salary.From.HasValue && ApplicationContext.ConvertToCurrency(v.Salary.From, filter.SalaryFilter.CurrencyCode) <= filter.SalaryFilter.Salary) &&
(!v.Salary.To.HasValue || v.Salary.To.HasValue && ApplicationContext.ConvertToCurrency(v.Salary.To, filter.SalaryFilter.CurrencyCode) >= filter.SalaryFilter.Salary));
}
}
if (filter.DateFrom.HasValue)
{
query = query.Where(v => v.PublishedAt >= filter.DateFrom);
}
if (filter.DateTo.HasValue)
{
query = query.Where(v => v.PublishedAt <= filter.DateTo);
}
query = query.OrderBy(v => v.Id);
var skip = filter.Page <= 1 ? 0 : (filter.Page - 1) * filter.PageSize;
return(new DataPage <Vacancy>
{
Count = await query.CountAsync(),
Objects = await query.GetPaged(skip, filter.PageSize).ToListAsync(),
});
}
