protected virtual IQueryable <Job> ApplyPaging(IQueryable <Job> query, JobFilterDto input)
{
var pagedInput = input as IPagedResultRequest;
if (pagedInput != null)
{
return(query.PageBy(pagedInput));
}
var limitedInput = input as ILimitedResultRequest;
if (limitedInput != null)
{
return(query.Take(limitedInput.MaxResultCount));
}
return(query);
}
protected virtual IQueryable <Job> ApplySorting(IQueryable <Job> query, JobFilterDto input)
{
var sortInput = input as ISortedResultRequest;
if (sortInput != null)
{
if (sortInput.Sorting.IsNotNullOrEmpty())
{
return(query.OrderBy(sortInput.Sorting));
}
}
if (input is ILimitedResultRequest)
{
return(query.OrderByDescending(e => e.Id));
}
return(query);
}
//[AbpAuthorize(PermissionNames.AdminPage_Job)]
public virtual async Task <PagedResultDto <JobDto> > GetAll(JobFilterDto input)
{
var query = jobRepository.GetAll()
.Include(p => p.JobCategory)
.WhereIf(input.Id != null, p => p.Id == input.Id)
.WhereIf(input.JobCategoryId != null, p => p.JobCategoryId == input.JobCategoryId)
.WhereIf(input.Title != null, p => p.Title == input.Title);
var totalCount = await query.CountAsync();
query = ApplySorting(query, input);
query = ApplyPaging(query, input);
var entities = await query.ToListAsync();
return(new PagedResultDto <JobDto>(
totalCount,
entities.Select(p => p.MapTo <JobDto>())
.ToList()
));
}
public async Task <ListResultDto <JobResultDto> > GetJobsByFilterAsync(JobFilterDto input)
{
var query = _recruitmentRepository.GetAll()
.Include(x => x.ExpertiseRecruitments).ThenInclude(x => x.Expertise)
.WhereIf(!input.SalaryRange.IsNullOrWhiteSpace(), x => x.SalaryRange.ToLower() == input.SalaryRange.ToLower())
.WhereIf(!input.WayOfWork.IsNullOrWhiteSpace(), x => x.WayOfWork.ToLower() == input.WayOfWork.ToLower())
.WhereIf(!input.Name.IsNullOrWhiteSpace(), x => x.Name.ToLower().Contains(input.Name.ToLower()))
.WhereIf(!input.State.IsNullOrWhiteSpace(), x => x.State.ToLower() == input.State.ToLower())
.Join(_recruiterRepository.GetAll(), recruitment => recruitment.CreatorUserId, recruiter => recruiter.IDUser, (recruitment, recruiter) => new { recruitment, recruiter })
.Join(_companyRepository.GetAll(), x => x.recruiter.IDCompany, company => company.Id, (x, company) => new { x.recruiter, x.recruitment, company })
.WhereIf(!input.Province.IsNullOrWhiteSpace(), x => x.company.Address.ToLower().Contains(input.Province.ToLower()));
var localList = await query.ToListAsync();
var result = localList
.WhereIf(!input.Expertises.IsNullOrEmpty(),
x => x.recruitment.ExpertiseRecruitments.Select(ept => ept.Expertise.Name.ToLower()).Intersect(input.Expertises.Select(i => i.ToLower())).Count() > 0)
.Select(x => x.recruitment);
return(new ListResultDto <JobResultDto>(result.Select(x => ObjectMapper.Map <JobResultDto>(x)).ToList()));
}
/// <summary>
/// 获取工作任务列表
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public List <JobDto> GetJobList(JobFilterDto filter)
{
var jobList = JobDomainService.GetJobList(CreateQueryObject(filter));
return(jobList.Select(c => c.MapTo <JobDto>()).ToList());
}
/// <summary>
/// 获取工作任务
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public JobDto GetJob(JobFilterDto filter)
{
var job = JobDomainService.GetJob(CreateQueryObject(filter));
return(job.MapTo <JobDto>());
}
/// <summary>
/// 根据查询条件生成查询对象
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public IQuery CreateQueryObject(JobFilterDto filter)
{
if (filter == null)
{
return(null);
}
IQuery query = QueryFactory.Create <JobQuery>(filter);
#region 筛选条件
if (!filter.Ids.IsNullOrEmpty())
{
query.In <JobQuery>(c => c.Id, filter.Ids);
}
if (!filter.Group.IsNullOrEmpty())
{
query.Equal <JobQuery>(c => c.Group, filter.Group);
}
if (!filter.Name.IsNullOrEmpty())
{
query.Like <JobQuery>(c => c.Name, filter.Name);
}
if (filter.Type.HasValue)
{
query.Equal <JobQuery>(c => c.Type, filter.Type.Value);
}
if (filter.RunType.HasValue)
{
query.Equal <JobQuery>(c => c.RunType, filter.RunType.Value);
}
if (filter.Status.HasValue)
{
query.Equal <JobQuery>(c => c.Status, filter.Status.Value);
}
if (!filter.Description.IsNullOrEmpty())
{
query.Equal <JobQuery>(c => c.Description, filter.Description);
}
if (filter.UpdateDate.HasValue)
{
query.Equal <JobQuery>(c => c.UpdateDate, filter.UpdateDate.Value);
}
if (!filter.JobPath.IsNullOrEmpty())
{
query.Equal <JobQuery>(c => c.JobPath, filter.JobPath);
}
if (!filter.JobFileName.IsNullOrEmpty())
{
query.Equal <JobQuery>(c => c.JobFileName, filter.JobFileName);
}
#endregion
#region 数据加载
if (filter.LoadGroup)
{
query.SetLoadPropertys <Job>(true, c => c.Group);
}
#endregion
return(query);
}
/// <summary>
/// 获取工作任务分页
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public IPaging <JobDto> GetJobPaging(JobFilterDto filter)
{
var jobPaging = JobDomainService.GetJobPaging(CreateQueryObject(filter));
return(jobPaging.ConvertTo <JobDto>());
}
/// <summary>
/// 获取工作任务分页
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public IPaging <JobDto> GetJobPaging(JobFilterDto filter)
{
return(jobBusiness.GetJobPaging(filter));
}
/// <summary>
/// 获取工作任务列表
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public List <JobDto> GetJobList(JobFilterDto filter)
{
return(jobBusiness.GetJobList(filter));
}
/// <summary>
/// 获取工作任务
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public JobDto GetJob(JobFilterDto filter)
{
return(jobBusiness.GetJob(filter));
}
public async Task <ListResultDto <JobResultDto> > Get(JobFilterDto jobFilterDto)
{
return(await _searchJobsAppService.GetJobsByFilterAsync(jobFilterDto));
}
