public Task <List <CommonRecruitmentPostDataset> > GetAppliedJobs([FromQuery] RecruitmentPostRequestParam param)
{
int id = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
return(_employeeService.GetAppliedJobs(id, param));
}
public async Task <ActionResult <List <CommonRecruitmentPostDataset> > > GetClassificatedRecruitmentPosts([FromQuery] RecruitmentPostRequestParam param)
{
if (!param.ValidateSalary)
{
return(BadRequest(new { message = "Max salary must greater or equal to Min salary" }));
}
return(Ok(await _recruitmentService.GetListRecruitmentPost(param)));
}
public async Task <List <CommonRecruitmentPostDataset> > GetListRecruitmentPost(RecruitmentPostRequestParam param)
{
Expression <Func <Models.RecruitmentPost, bool> > filter = post => (post.Company.CompanyName.Contains(param.CompanyName) &&
post.Location.Contains(param.Location) &&
(param.CompanyId == 0 || post.CompanyId == param.CompanyId) &&
(param.MajorId == 0 || post.MajorId == param.MajorId) &&
(param.IsExpired || post.DueDate >= DateTime.UtcNow));
Func <IQueryable <RecruitmentPost>, IOrderedQueryable <RecruitmentPost> > order;
switch (param.OrderBy)
{
case "+created":
order = post => post.OrderBy(post => post.Created);
break;
case "+salary":
order = post => post.OrderBy(post => post.MaxSalary);
break;
case "-salary":
order = post => post.OrderByDescending(post => post.MaxSalary);
break;
default:
order = post => post.OrderByDescending(post => post.Created);
break;
}
IEnumerable <Models.RecruitmentPost> list = await _uow.RecruitmentRepository.Get(filter : filter,
offset : param.Offset,
first : param.Limit,
includeProperties : "Company,Company.Account",
orderBy : order);
IEnumerable <Translation> trans = await _uow.TranslationRepository.Get(filter : t => t.MajorId != null && t.Language == param.Lang);
List <CommonRecruitmentPostDataset> result = (from r in list
join t in trans on r.MajorId equals t.MajorId
select new CommonRecruitmentPostDataset()
{
PostId = r.PostId,
Company = _mapper.Map <CompanyDataset>(r.Company),
Created = r.Created,
DueDate = r.DueDate,
ExpectedNumber = r.ExpectedNumber,
JobBenefit = r.JobBenefit,
JobDescription = r.JobDescription,
JobRequirement = r.JobRequirement,
Location = r.Location,
Major = new Datasets.Major.MajorDataset()
{
MajorId = r.MajorId,
MajorName = t.Text
},
MaxSalary = r.MaxSalary,
MinSalary = r.MinSalary,
Title = r.Title
}).ToList();
return(result);
}
public async Task <List <CommonRecruitmentPostDataset> > GetAppliedJobs(int id, RecruitmentPostRequestParam param)
{
Expression <Func <Models.Application, bool> > filter = cv => (cv.RecruitmentPost.Company.CompanyName.Contains(param.CompanyName) &&
cv.RecruitmentPost.Location.Contains(param.Location) &&
(param.CompanyId == 0 || cv.RecruitmentPost.CompanyId == param.CompanyId) &&
(param.MajorId == 0 || cv.RecruitmentPost.MajorId == param.MajorId) &&
cv.CV.EmployeeId == id);
Func <IQueryable <Application>, IOrderedQueryable <Application> > order;
switch (param.OrderBy)
{
case "+created":
order = cv => cv.OrderBy(cv => cv.RecruitmentPost.Created);
break;
case "+salary":
order = cv => cv.OrderBy(cv => cv.RecruitmentPost.MaxSalary);
break;
case "-salary":
order = cv => cv.OrderByDescending(cv => cv.RecruitmentPost.MaxSalary);
break;
default:
order = cv => cv.OrderByDescending(cv => cv.RecruitmentPost.Created);
break;
}
IEnumerable <Application> appliedCVs = await _uow.AppliedCVRepository.Get(filter : filter,
orderBy : order,
includeProperties : "RecruitmentPost,RecruitmentPost.Company,RecruitmentPost.Major,RecruitmentPost.Company.Account,CV",
first : param.Limit,
offset : param.Offset);
IEnumerable <RecruitmentPost> listAppliedJobs = appliedCVs.Select(cv => cv.RecruitmentPost);
return(_mapper.Map <List <CommonRecruitmentPostDataset> >(listAppliedJobs));
}
