public async Task <IEnumerable <VacancyElasticModel> > Search(int skip, int amount,
VacancySearchModel searchModel, VacancySortModel sortModel)
{
var result = await Task.Run(() => _vacancyElasticRepository.Search(skip, amount, searchModel, sortModel));
return(result);
}
public async Task <HttpContent> GetExcelByVacancies(int skip, int amount,
VacancySearchModel searchModel, VacancySortModel sortModel)
{
var stream = new MemoryStream(await AddToExcelVacancy(skip, amount, searchModel, sortModel));
var result = CreateContent(stream, "Vacancies.xlsx");
return(result);
}
public async Task <byte[]> AddToExcelVacancy(int skip, int amount,
VacancySearchModel searchModel, VacancySortModel sortModel)
{
var vacancies = await vacancyService.Search(skip, amount, searchModel, sortModel);
var excelVacancyList = vacancies.Select(ConvertToExcelModel).ToList();
var result = ExcelCreator.GenerateExcel(excelVacancyList);
return(result);
}
public ActionResult Index(VacancySearchModel vacancySearchModel, string sortString)
{
if (!ModelState.IsValid)
{
return(View());
}
var dto = mapper.Map <SearchVacancyDTO>(vacancySearchModel);
if (User.IsInRole(RoleNames.Jobseeker) || User.IsInRole(RoleNames.Hr))
{
dto.IsActive = true;
}
else
{
dto.IsActive = false;
}
if (User.IsInRole(RoleNames.Employee))
{
dto.EmployeeId = employeeAppService.GetByUser(User.Identity.Name).Id;
}
ICollection <VacancyDTO> vacancies;
switch (sortString)
{
case SortStrings.DontSort:
vacancies = vacancyAppService.Search(dto);
break;
case SortStrings.SortByVacancyName:
vacancies = vacancyAppService.Search(dto).OrderBy(v => v.Name).ToList();
break;
case SortStrings.SortByProfessionlField:
vacancies = vacancyAppService.Search(dto).OrderBy(v => v.ProfessionalField).ToList();
break;
case SortStrings.SortByDescription:
vacancies = vacancyAppService.Search(dto).OrderBy(v => v.Description).ToList();
break;
case SortStrings.SortByReqirements:
vacancies = vacancyAppService.Search(dto).OrderBy(v => v.Requierements).ToList();
break;
case SortStrings.SortBySalary:
vacancies = vacancyAppService.Search(dto).OrderBy(v => v.SalaryFrom).ToList();
break;
default: vacancies = vacancyAppService.Search(dto);
break;
}
return(PartialView(ViewStrings.SearchResultsView, mapper.Map <ICollection <VacancyModel> >(vacancies)));
}
public async Task <ICollection <Vacancy> > Search(int skip, int amount, VacancySearchModel searchModel, VacancySortModel sortModel)
{
IQueryable <Vacancy> vacancies;
vacancies = searchModel == null?vacancyRepository.ReadAll() : vacancyRepository.Find(searchModel);
var res = Sorting(vacancies, sortModel).Skip(skip).Take(amount);
var vacancyList = await Task.Run(() => res.ToList());
return(vacancyList);
}
public IQueryable <Vacancy> Find(VacancySearchModel searchModel)
{
IQueryable <Vacancy> query = dbSet.AsNoTracking();
if (searchModel.Status != 0)
{
query = query.Where(vac => vac.Status == searchModel.Status);
}
if (searchModel.City != 0)
{
query = query.Where(vac => vac.City == searchModel.City);
}
if (searchModel.PrimarySkill != null)
{
if (searchModel.PrimarySkill.Id != 0)
{
query = query.Where(vac => vac.VacancyPrimarySkill.TechSkill == searchModel.PrimarySkill.Id);
}
if (searchModel.PrimarySkill.Level != 0)
{
query = query.Where(vac => vac.VacancyPrimarySkill.Level == searchModel.PrimarySkill.Level);
}
}
if (searchModel.ProjectName != null)
{
query = query.Where(vac => vac.ProjectName == searchModel.ProjectName);
}
if (searchModel.RequestDate != DateTime.MinValue)
{
query = query.Where(vac => vac.RequestDate == searchModel.RequestDate);
}
if (searchModel.StartDate != DateTime.MinValue)
{
query = query.Where(vac => vac.StartDate == searchModel.StartDate);
}
if (searchModel.VacancyName != null)
{
query = query.Where(vac => vac.VacancyName == searchModel.VacancyName);
}
return(query);
}
public static bool Filter(VacancySearchModel vsm, Vacancy v)
{
if (vsm == null)
{
return(true);
}
if (vsm.City != 0)
{
if (v.City != null)
{
if (v.City.Value != vsm.City)
{
return(false);
}
}
else
{
return(false);
}
}
if (vsm.Status != 0)
{
if (v.Status != vsm.Status)
{
return(false);
}
}
if (vsm.PrimarySkill != null)
{
if (v.VacancyPrimarySkill != null)
{
if (vsm.PrimarySkill.Id != 0)
{
if (v.VacancyPrimarySkill.TechSkill != vsm.PrimarySkill.Id)
{
return(false);
}
}
if (vsm.PrimarySkill.Level != 0)
{
if (v.VacancyPrimarySkill.Level != vsm.PrimarySkill.Level)
{
return(false);
}
}
}
else
{
return(false);
}
}
if (vsm.StartDate != null)
{
if (v.StartDate != null)
{
if (DateTime.Compare(v.StartDate.Value, vsm.StartDate) < 0)
{
return(false);
}
}
else
{
return(false);
}
}
if (vsm.RequestDate != null)
{
if (v.RequestDate != null)
{
if (DateTime.Compare(v.RequestDate.Value, vsm.RequestDate) < 0)
{
return(false);
}
}
else
{
return(false);
}
}
if (vsm.ProjectName != null)
{
if (v.ProjectName != null)
{
var vacWords = v.ProjectName.Split(' ');
var searchWords = vsm.ProjectName.Split(' ');
if (LevenshteinDistanceCalculator.GetDistance(vsm.ProjectName, v.ProjectName) > LevenshteinDistanceCalculator.MaxAllowedDistance)
{
return(false);
}
}
else
{
return(false);
}
}
if (vsm.VacancyName != null)
{
if (v.VacancyName != null)
{
if (LevenshteinDistanceCalculator.GetDistance(v.VacancyName, vsm.VacancyName) > LevenshteinDistanceCalculator.MaxAllowedDistance)
{
return(false);
}
}
else
{
return(false);
}
}
return(true);
}
public IEnumerable <VacancyElasticModel> Search(int skip, int amount,
VacancySearchModel searchModel, VacancySortModel sortModel)
{
var sort = Sort(sortModel);
searchModel = searchModel ?? new VacancySearchModel();
return(_client.Search <VacancyElasticModel>(s =>
s.Index(IndexName)
.Skip(skip)
.Take(amount)
.Query(q =>
{
QueryContainer queryContainer = null;
if (searchModel.City != 0)
{
queryContainer &= q.Nested(ns => ns
.Path(p => p.City)
.Query(qr => qr
.Term(x => x.City.Id, searchModel.City)
));
}
if (searchModel.Status != 0)
{
queryContainer &= q.Nested(ns => ns
.Path(p => p.Status)
.Query(qr => qr
.Term(x => x.Status.Id, searchModel.Status)
));
}
if (searchModel.PrimarySkill != null)
{
if (searchModel.PrimarySkill.Id != 0)
{
queryContainer &= q.Nested(ns => ns
.Path(p => p.PrimarySkill)
.Query(qr => qr
.Term(v => v.PrimarySkill.TechSkill, searchModel.PrimarySkill.Id)
));
}
if (searchModel.PrimarySkill.Level != 0)
{
queryContainer &= q.Nested(ns => ns
.Path(p => p.PrimarySkill)
.Query(qr => qr
.Term(v => v.PrimarySkill.Level, searchModel.PrimarySkill.Level)));
}
}
if (searchModel.RequestDate != DateTime.MinValue)
{
queryContainer &= q.Term(v => v.RequestDate, searchModel.RequestDate);
}
if (searchModel.StartDate != DateTime.MinValue)
{
queryContainer &= q.Term(v => v.StartDate, searchModel.StartDate);
}
//queryContainer &= q.MatchPhrase(fr => fr
// .Field(z => z.ProjectName)
// .Query(searchModel.ProjectName)
// .Fuzziness(Fuzziness.Auto)
// .FuzzyTranspositions()
// .MaxExpansions(2)
// .MinimumShouldMatch(2)
// .PrefixLength(2)
// .Operator(Operator.Or)
// .Slop(2)
// .Boost(2));
if (searchModel.ProjectName != null)
{
var projectNames = searchModel.ProjectName.Split(' ');
foreach (var projectName in projectNames)
{
queryContainer &= q.MatchPhrase(mp =>
mp.Field(f => f.ProjectName).Query(projectName)
.Fuzziness(Fuzziness.EditDistance(2)));
}
}
if (searchModel.VacancyName != null)
{
var vacancyNames = searchModel.VacancyName.Split(' ');
foreach (var vacancyName in vacancyNames)
{
queryContainer &= q.MatchPhrase(mp =>
mp.Field(f => f.VacancyName).Query(vacancyName)
.Fuzziness(Fuzziness.EditDistance(2)));
}
}
//queryContainer &= q.Fuzzy(x => x
// .Field(z => z.ProjectName)
// .Value(searchModel.ProjectName)
// .Fuzziness(Fuzziness.Auto)
//);
//queryContainer &= q.Fuzzy(x => x
// .Field(z => z.VacancyName)
// .Value(searchModel.VacancyName)
// .Fuzziness(Fuzziness.Auto)
// );
return queryContainer;
}
)
.Sort(p => p = sort)
).Documents);
}
public async Task SearchTest()
{
Vacancy vacancy1 = new Vacancy()
{
Id = 22,
Status = 1,
ProjectName = "Some project name",
City = 4
};
Vacancy vacancy2 = new Vacancy()
{
Id = 2,
Status = 4,
ProjectName = "Another project name",
City = 2
};
VacancySearchModel searchModel = new VacancySearchModel()
{
VacancyName = "JavaScript Junior Developer",
City = 3,
Status = 2,
RequestDate = new DateTime(2017, 8, 8)
};
IQueryable <Vacancy> vacancyFindList = new List <Vacancy>().AsQueryable();
IQueryable <Vacancy> vacancyReadList = new List <Vacancy>()
{
vacancy1, vacancy2
}.AsQueryable();
mockVacancyRepository.Setup(x => x.Find(It.IsAny <VacancySearchModel>())).Returns(vacancyFindList);
mockVacancyRepository.Setup(x => x.ReadAll()).Returns(vacancyReadList);
var candidateRepository = mockCandidateRepository.Object;
var unitOfWork = mockUnitOfWork.Object;
var candidateService = mockCandidateService.Object;
var techSkillRepository = mockTechSkillRepository.Object;
var vacancyRepository = mockVacancyRepository.Object;
var eventService = mockEventService.Object;
var vacancyService = new VacancyService(unitOfWork, vacancyRepository, candidateRepository, techSkillRepository,
candidateService, eventService);
var result = await vacancyService.Search(0, 5, searchModel, null);
Assert.AreEqual(0, result.Count);
var actual = await vacancyService.Search(0, 5, null, null);
Assert.AreEqual(2, actual.Count);
}
