using FlexJobApi.Core;
|
using Furion.DatabaseAccessor;
|
using Furion.FriendlyException;
|
using Mapster;
|
using MediatR;
|
using Microsoft.EntityFrameworkCore;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
|
namespace FlexJobApi.UserServer.Application
|
{
|
/// <summary>
|
/// 用户简历查询处理器
|
/// </summary>
|
public class UserResumeQueryHandler(
|
IRepository<User> rep,
|
IRepository<TaskInfoUser> repTaskInfoUser
|
) :
|
IRequestHandler<GetOpenUserResumesQuery, GetUserResumesQueryResult>,
|
IRequestHandler<GetUserResumesQuery, GetUserResumesQueryResult>,
|
IRequestHandler<GetUserResumeQuery, GetUserResumeQueryResult>,
|
IRequestHandler<GetUserResumePersonalQuery, GetUserResumePersonalQueryResult>,
|
IRequestHandler<GetUserResumeJobSeekingQuery, GetUserResumeJobSeekingQueryResult>,
|
IRequestHandler<GetUserResumeCredentialsQuery, List<GetUserResumeCredentialsQueryResultItem>>,
|
IRequestHandler<GetUserResumeCredentialQuery, GetUserResumeCredentialQueryResult>,
|
IRequestHandler<GetUserResumeWorkExperienceQuery, GetUserResumeWorkExperienceQueryResult>,
|
IRequestHandler<GetUserResumeDetailQuery, GetUserResumeDetailQueryResult>
|
{
|
private readonly IRepository<User> rep = rep;
|
private readonly IRepository<TaskInfoUser> repTaskInfoUser = repTaskInfoUser;
|
|
/// <summary>
|
/// 查询开放简历分页列表数据
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public Task<GetUserResumesQueryResult> Handle(GetOpenUserResumesQuery request, CancellationToken cancellationToken)
|
{
|
return Handle(request.Adapt<GetUserResumesQuery>(), cancellationToken);
|
}
|
|
/// <summary>
|
/// 查询简历分页列表数据
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public async Task<GetUserResumesQueryResult> Handle(GetUserResumesQuery request, CancellationToken cancellationToken)
|
{
|
var logier = JwtUtils.GetCurrentLogier();
|
var q = rep.AsQueryable().AsNoTracking()
|
.Where(it => it.Type == EnumUserType.Personal);
|
if (request.TaskInfoId.HasValue)
|
{
|
q = q.Where(it => it.EnterpriseEmployees.Any(ee => ee.TaskInfoUsers.Any(tu => tu.TaskInfoId == request.TaskInfoId)));
|
}
|
if (request.UserExpectJobs.IsNotNull())
|
{
|
q = q.Where(it =>
|
it.UserExpectJobs.Any(j =>
|
request.UserExpectJobs.Contains(j.ExpectJobCode)
|
|| j.ExpectJob.ParentId.HasValue
|
&& (request.UserExpectJobs.Contains(j.ExpectJob.Parent.Code))));
|
}
|
if (request.Gender.HasValue)
|
{
|
q = q.Where(it => it.Gender == request.Gender);
|
}
|
if (request.PersonalIdentityCode.IsNotNull())
|
{
|
q = q.Where(it => it.PersonalIdentityCode == request.PersonalIdentityCode);
|
}
|
if (request.AgeMin.HasValue)
|
{
|
q = q.Where(it => it.Age >= request.AgeMin);
|
}
|
if (request.AgeMax.HasValue)
|
{
|
q = q.Where(it => it.Age <= request.AgeMax);
|
}
|
if (request.UserCredentials.IsNotNull())
|
{
|
q = q.Where(it =>
|
it.UserCredentials.Any(c =>
|
request.UserCredentials.Contains(c.TypeCode)));
|
}
|
if (logier != null && logier.Type == EnumUserType.Enterprise && request.IsCollected == true)
|
{
|
q = q.Where(it => it.EnterpriseUserCollects.Any(c => c.EnterpriseId == logier.EnterpriseId && c.IsCollected));
|
}
|
if (logier != null && logier.Type == EnumUserType.Enterprise && request.IsContacted == true)
|
{
|
q = q.Where(it => it.EnterpriseUserCollects.Any(c => c.EnterpriseId == logier.EnterpriseId && c.IsContacted));
|
}
|
var s = q.Select(it => new GetUserResumesQueryResultItem
|
{
|
Id = it.Id,
|
Avatar = it.Avatar,
|
Name = it.Name,
|
Gender = it.Gender,
|
IsReal = it.IsReal,
|
Age = it.Age,
|
PersonalIdentityCode = it.PersonalIdentityCode,
|
PersonalIdentityContent = it.PersonalIdentity.Content,
|
EducationalBackgroundCode = it.EducationalBackgroundCode,
|
EducationalBackgroundContent = it.EducationalBackground.Content,
|
TaskCount = it.EnterpriseEmployees.SelectMany(ee => ee.TaskInfoUsers).Count(tu => tu.HireStatus == EnumTaskUserHireStatus.Pass),
|
WorkSeniority = it.WorkSeniority,
|
WorkExperience = it.WorkExperience,
|
CreatedTime = it.CreatedTime,
|
});
|
var result = await request.PageModel.GetPagedListAsync<GetUserResumesQueryResult, GetUserResumesQueryResultItem>(s, cancellationToken);
|
return result;
|
}
|
|
/// <summary>
|
/// 查询用户简历
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public async Task<GetUserResumeQueryResult> Handle(GetUserResumeQuery request, CancellationToken cancellationToken)
|
{
|
var logier = JwtUtils.GetCurrentLogier();
|
if (logier.Type == EnumUserType.Personal)
|
{
|
request.UserId = logier.Id;
|
}
|
EnterpriseEmployee? enterpriseEmployee = null;
|
if (logier.Type == EnumUserType.Enterprise && request.UserId == null && request.EnterpriseEmployeeId.HasValue)
|
{
|
enterpriseEmployee = await rep.Change<EnterpriseEmployee>().AsQueryable().AsNoTracking()
|
.Where(it => it.EnterpriseId == logier.EnterpriseId && it.Id == request.EnterpriseEmployeeId)
|
.FirstOrDefaultAsync(cancellationToken);
|
if (enterpriseEmployee == null) throw Oops.Oh(EnumErrorCodeType.s404, "该灵工");
|
request.UserId = enterpriseEmployee.UserId;
|
}
|
else if (request.UserId == null) throw Oops.Oh(EnumErrorCodeType.s400, "请选择用户");
|
|
GetUserResumeQueryResult? model = null;
|
if (request.UserId.HasValue)
|
{
|
model = await rep.AsQueryable().AsNoTracking()
|
.Where(it => it.Id == request.UserId)
|
.GetDetail<User, GetUserResumeQueryResult>(cancellationToken);
|
}
|
else if (enterpriseEmployee != null)
|
{
|
model = new GetUserResumeQueryResult
|
{
|
Name = enterpriseEmployee.Name,
|
ContactPhoneNumber = enterpriseEmployee.ContactPhoneNumber,
|
Identity = enterpriseEmployee.Identity,
|
Gender = enterpriseEmployee.Gender,
|
Age = enterpriseEmployee.Age,
|
};
|
}
|
if (model == null) throw Oops.Oh(EnumErrorCodeType.s404, "该信息");
|
|
model.TaskInfoUsers = model.TaskInfoUsers.Where(it => it.SignContractTime.HasValue).ToList();
|
if (model.Id.HasValue)
|
{
|
model.TaskInfoUsers = repTaskInfoUser.AsQueryable().AsNoTracking()
|
.Where(it => it.EnterpriseEmployee.UserId == model.Id && it.EnterpriseEmployee.EnterpriseSignContractTime.HasValue)
|
.Select(it => new GetUserResumeQueryResultExperience
|
{
|
SignContractTime = it.EnterpriseEmployee.EnterpriseSignContractTime,
|
EnterpriseName = it.TaskInfo.Enterprise.EnterpriseName,
|
Name = it.TaskInfo.Name
|
})
|
.ToList();
|
model.TaskCount = await repTaskInfoUser.AsQueryable().AsNoTracking()
|
.Where(it => it.EnterpriseEmployee.UserId == model.Id && it.HireStatus == EnumTaskUserHireStatus.Pass)
|
.CountAsync();
|
if (logier.Type == EnumUserType.Enterprise)
|
{
|
model.IsCollected = await rep.Change<EnterpriseUserCollect>().AsQueryable().AsNoTracking()
|
.Where(it => it.EnterpriseId == logier.EnterpriseId && it.UserId == model.Id)
|
.Select(it => it.IsCollected)
|
.FirstOrDefaultAsync();
|
}
|
}
|
if (model.CityCode.IsNotNull())
|
{
|
model.CompleteRate += 20;
|
}
|
if (model.JobSeekingStatus.HasValue)
|
{
|
model.CompleteRate += 20;
|
}
|
if (model.UserCredentials.IsNotNull())
|
{
|
model.CompleteRate += 20;
|
}
|
if (model.WorkExperience.IsNotNull() || model.WorkSeniority.IsNotNull())
|
{
|
model.CompleteRate += 20;
|
}
|
if (model.Weight.HasValue || model.Height.HasValue || model.Photos.IsNotNull())
|
{
|
model.CompleteRate += 20;
|
}
|
|
return model;
|
}
|
|
/// <summary>
|
/// 查询用户简历-个人信息
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public Task<GetUserResumePersonalQueryResult> Handle(GetUserResumePersonalQuery request, CancellationToken cancellationToken)
|
{
|
return rep.GetPersonalQueryable(false)
|
.GetDetail<User, GetUserResumePersonalQueryResult>(cancellationToken);
|
}
|
|
/// <summary>
|
/// 查询用户简历-求职意向
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public Task<GetUserResumeJobSeekingQueryResult> Handle(GetUserResumeJobSeekingQuery request, CancellationToken cancellationToken)
|
{
|
return rep.GetPersonalQueryable(false)
|
.GetDetail<User, GetUserResumeJobSeekingQueryResult>(cancellationToken);
|
}
|
|
/// <summary>
|
/// 查询用户简历-资格证书列表
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public async Task<List<GetUserResumeCredentialsQueryResultItem>> Handle(GetUserResumeCredentialsQuery request, CancellationToken cancellationToken)
|
{
|
return await rep.GetPersonalQueryable(false)
|
.SelectMany(it => it.UserCredentials)
|
.OrderBy(it => it.CreatedTime)
|
.ProjectToType<GetUserResumeCredentialsQueryResultItem>()
|
.ToListAsync(cancellationToken);
|
}
|
|
/// <summary>
|
/// 查询用户简历-资格证书
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public Task<GetUserResumeCredentialQueryResult> Handle(GetUserResumeCredentialQuery request, CancellationToken cancellationToken)
|
{
|
return rep.GetPersonalQueryable(false)
|
.SelectMany(it => it.UserCredentials)
|
.Where(it => it.Id == request.Id)
|
.GetDetail<UserCredential, GetUserResumeCredentialQueryResult>(cancellationToken);
|
}
|
|
/// <summary>
|
/// 查询用户简历-工作经验
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public Task<GetUserResumeWorkExperienceQueryResult> Handle(GetUserResumeWorkExperienceQuery request, CancellationToken cancellationToken)
|
{
|
return rep.GetPersonalQueryable(false)
|
.GetDetail<User, GetUserResumeWorkExperienceQueryResult>(cancellationToken);
|
}
|
|
/// <summary>
|
/// 查询用户简历-详细信息
|
/// </summary>
|
/// <param name="request"></param>
|
/// <param name="cancellationToken"></param>
|
/// <returns></returns>
|
public Task<GetUserResumeDetailQueryResult> Handle(GetUserResumeDetailQuery request, CancellationToken cancellationToken)
|
{
|
return rep.GetPersonalQueryable(false)
|
.GetDetail<User, GetUserResumeDetailQueryResult>(cancellationToken);
|
}
|
|
}
|
}
|
