555 lines
20 KiB
C#
555 lines
20 KiB
C#
using Dlhis.Basic.Device.Services;
|
|
using Dlhis.Basic.Organization.Request;
|
|
using Dlhis.Basic.Organization.Response;
|
|
using Dlhis.Entity.Basic.Entity;
|
|
using Dlhis.Entity.Basic.Enums;
|
|
using Dlhis.Entity.Device.Enums;
|
|
using Dlhis.Sys.Api;
|
|
using Kurisu.AspNetCore.Utils;
|
|
using Kurisu.AspNetCore.Utils.Extensions;
|
|
using Kurisu.Core.DataAccess.Dto;
|
|
using Kurisu.Core.User.Abstractions;
|
|
using Kurisu.SqlSugar.Extensions;
|
|
using Kurisu.SqlSugar.Services;
|
|
using Mapster;
|
|
using Microsoft.AspNetCore.DataProtection;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using System.Linq.Expressions;
|
|
|
|
namespace Dlhis.Basic.Organization.Services.Implements;
|
|
|
|
public class GainfoService : IGainfoService
|
|
{
|
|
private readonly IGainfoStore _gainfoStore;
|
|
private readonly IDbContext _dbContext;
|
|
private readonly ICurrentUser _currentUser;
|
|
private readonly IDevicePermissionService _devicePermissionService;
|
|
private readonly RedisCache _redisCache;
|
|
private readonly IServiceProvider _serviceProvider;
|
|
private readonly IConfiguration _configuration;
|
|
private readonly ITenantApi _tenantApi;
|
|
private readonly ILogger<GainfoService> _logger;
|
|
|
|
public GainfoService(IGainfoStore gainfoStore,
|
|
IDbContext dbContext,
|
|
ICurrentUser currentUser,
|
|
IDevicePermissionService devicePermissionService,
|
|
RedisCache redisCache,
|
|
IServiceProvider serviceProvider,
|
|
IConfiguration configuration,
|
|
ITenantApi tenantApi,
|
|
ILogger<GainfoService> logger)
|
|
{
|
|
_gainfoStore = gainfoStore;
|
|
_dbContext = dbContext;
|
|
_currentUser = currentUser;
|
|
_devicePermissionService = devicePermissionService;
|
|
_redisCache = redisCache;
|
|
_serviceProvider = serviceProvider;
|
|
_configuration = configuration;
|
|
_tenantApi = tenantApi;
|
|
_logger = logger;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 档案分页
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task<Pagination<GainfoPageResponse>> GetPageAsync(GainfoPageRequest request)
|
|
{
|
|
var currentTenantId = _currentUser.GetStringTenantId();
|
|
|
|
//根据组织架构搜索档案
|
|
Expression<Func<GainfoEntity, bool>> where = LinqExpressionExtensions.False<GainfoEntity>();
|
|
foreach (var item in request.DepartmentSelections)
|
|
{
|
|
var depts = await GetRecursionDepartmentNosAsync(item.DepartmentNos);
|
|
if (depts.Any())
|
|
where = where.Or(gainfo => gainfo.Factory == item.Tenant && depts.Contains(gainfo.DepartmentNo));
|
|
else
|
|
where = where.Or(gainfo => gainfo.Factory == item.Tenant);
|
|
}
|
|
|
|
var page = await _gainfoStore.Queryable(request.Status)
|
|
.WhereIF(request.DepartmentSelections.IsPresent(), where)
|
|
.WhereIF(request.DepartmentSelections.IsEmpty(), gainfo => gainfo.Factory == currentTenantId)
|
|
.WhereIF(request.Search.IsPresent(), gainfo =>
|
|
gainfo.Name.Contains(request.Search)
|
|
|| gainfo.Code.Contains(request.Search)
|
|
|| gainfo.IdNo.Contains(request.Search)
|
|
|| gainfo.Werks.Contains(request.Search)
|
|
)
|
|
.Select<GainfoPageResponse>()
|
|
.ToPageListAsync(request);
|
|
|
|
return page;
|
|
}
|
|
|
|
public async Task<Pagination<GainfoAllPageResponse>> GetPageByCodeAsync(string code)
|
|
{
|
|
var page = await _gainfoStore.Queryable()
|
|
.Where(x => x.Code == code)
|
|
.Select<GainfoAllPageResponse>()
|
|
.ToPageListAsync(new PageDto { PageIndex = 1, PageSize = 1 });
|
|
|
|
|
|
var tenantsResult = await _tenantApi.GetTenantsInternalAsync();
|
|
var tenants = tenantsResult.Data;
|
|
|
|
page.Data.ForEach(x =>
|
|
{
|
|
x.Workplace = tenants.FirstOrDefault(item => item.Code == x.Workplace)?.Name;
|
|
x.Factory = tenants.FirstOrDefault(item => item.Code == x.Factory)?.Name;
|
|
});
|
|
|
|
return page;
|
|
}
|
|
|
|
/// <summary>
|
|
///保存档案号
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task SaveAsync(List<GainfoSaveRequest> request)
|
|
{
|
|
//todo check
|
|
var entities = request.Adapt<List<GainfoEntity>>();
|
|
entities.ForEach(x =>
|
|
{
|
|
if (x.No.IsEmpty())
|
|
{
|
|
x.No = "F" + Guid.NewGuid().ToString();
|
|
}
|
|
});
|
|
|
|
await _gainfoStore.InsertAsync(entities);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
///修改档案号
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task UpdateAsync(GainfoSaveRequest request)
|
|
{
|
|
var gainfo = await _gainfoStore.Queryable(request.GainfoStatus).Where(x => x.Id == request.Id).FirstAsync();
|
|
gainfo.ThrowIfNull("档案数据不存在,无法更新");
|
|
|
|
request.Adapt(gainfo);
|
|
await _gainfoStore.UpdateAsync(gainfo);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 正式转离职
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task DimissionAsync(GainfoDimissionRequest request)
|
|
{
|
|
var gainfo = await _gainfoStore.Queryable(GainfoStatusEnumType.Working)
|
|
.Where(x => x.No == request.UserNo)
|
|
.FirstAsync();
|
|
|
|
gainfo.ThrowIfNull("该档案不存在");
|
|
|
|
//添加到离职表
|
|
await _gainfoStore.InsertAsync(gainfo, GainfoStatusEnumType.Leave);
|
|
//删除原数据
|
|
await _gainfoStore.DeleteAsync(gainfo, GainfoStatusEnumType.Working);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 临时转正式
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="NotImplementedException"></exception>
|
|
public async Task OnboardingAsync(GainfoDimissionRequest request)
|
|
{
|
|
var gainfo = await _gainfoStore.Queryable(GainfoStatusEnumType.External)
|
|
.Where(x => x.No == request.UserNo)
|
|
.FirstAsync();
|
|
|
|
gainfo.ThrowIfNull($"该档案不存在");
|
|
|
|
//添加到正式表,不删除原数据,留档处理
|
|
await _gainfoStore.InsertAsync(gainfo);
|
|
}
|
|
|
|
public async Task<GainfoCurrentResponse> CurrentUserInfoAsync()
|
|
{
|
|
var identityId = _currentUser.GetIntSubjectId();
|
|
var code = _currentUser.GetUserClaim("jinko-code");
|
|
var gainfo = await _gainfoStore.Queryable().Where(x => x.Code == code).FirstAsync()
|
|
?? await _gainfoStore.Queryable().Where(x => x.IdentityUserId == identityId).FirstAsync();
|
|
|
|
if (gainfo == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var info = await _gainfoStore.Queryable(GainfoStatusEnumType.Working)
|
|
.LeftJoin<DepartmentEntity>((ga, department) => ga.DepartmentNo == department.No)
|
|
.LeftJoin<GainfoMealEntity>((ga, department, mealUser) => ga.No == mealUser.UserNo)
|
|
.Where((ga, department) => ga.Id == gainfo.Id)
|
|
.Select((ga, department, mealUser) => new GainfoCurrentResponse
|
|
{
|
|
UserNo = ga.No,
|
|
Birthday = ga.Birthday,
|
|
DepartmentNo = department.No,
|
|
DepartmentName = department.Name,
|
|
Gender = ga.Gender,
|
|
UserCode = ga.Code,
|
|
UserName = ga.Name,
|
|
Factory = ga.Factory,
|
|
MealInfo = new GainfoCurrentMealInfoResponse
|
|
{
|
|
Balance = mealUser.Balance
|
|
}
|
|
})
|
|
.FirstAsync();
|
|
|
|
if (info != null)
|
|
{
|
|
var tenantResult = await _tenantApi.GetTenantByCodeAsync(info.Factory);
|
|
if (tenantResult != null && tenantResult.Data != null)
|
|
{
|
|
info.Factory = tenantResult.Data.Name;
|
|
}
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
public async Task<IActionResult> GetFaceAsync(string token)
|
|
{
|
|
var timeLimitedDataProtector = _serviceProvider.GetService<IDataProtectionProvider>()
|
|
.CreateProtector("down:face")
|
|
.ToTimeLimitedDataProtector();
|
|
|
|
try
|
|
{
|
|
var password = timeLimitedDataProtector.Unprotect(token);
|
|
var userCode = password.Split(':')[1];
|
|
|
|
var faceCache = await _redisCache.HashGetAsync("faces", userCode);
|
|
if (faceCache.HasValue)
|
|
{
|
|
return new FileContentResult(Convert.FromBase64String(faceCache), "image/png");
|
|
}
|
|
|
|
var dbContext = _dbContext.ChangeDb("face");
|
|
var face = await dbContext.Queryable<GainfoFaceEntity>().Where(x => x.UserCode == userCode).SingleAsync();
|
|
|
|
if (face == null)
|
|
{
|
|
_logger.LogWarning("学工号:{userCode}不存在人脸照片", userCode);
|
|
return new NotFoundResult();
|
|
}
|
|
|
|
await _redisCache.HashSetAsync("faces", userCode, face.Face);
|
|
return new FileContentResult(Convert.FromBase64String(face.Face), "image/png");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "获取人脸失败:{message}", ex.Message);
|
|
return new NotFoundResult();
|
|
}
|
|
}
|
|
|
|
public async Task UploadFaceAsync(GainfoUploadFaceRequest request)
|
|
{
|
|
var gainfo = await _gainfoStore.Queryable(GainfoStatusEnumType.Working).Where(x => x.No == request.UserNo).FirstAsync();
|
|
gainfo ??= await _gainfoStore.Queryable(GainfoStatusEnumType.External).Where(x => x.No == request.UserNo).FirstAsync();
|
|
|
|
gainfo.ThrowIfNull("人员档案信息不存在");
|
|
|
|
|
|
var userId = _currentUser.GetIntSubjectId();
|
|
|
|
var faceContext = _dbContext.ChangeDb("face");
|
|
var face = await faceContext.Queryable<GainfoFaceEntity>().Where(x => x.UserCode == gainfo.Code).SingleAsync();
|
|
|
|
var taskType = face == null ? DeviceTaskEnumType.Add : DeviceTaskEnumType.Update;
|
|
|
|
await _redisCache.HashSetAsync("faces", gainfo.Code, request.Face);
|
|
if (face == null)
|
|
{
|
|
face = new GainfoFaceEntity
|
|
{
|
|
UserCode = gainfo.Code,
|
|
Face = request.Face,
|
|
CreateTime = DateTime.Now,
|
|
ModifiedTime = DateTime.Now,
|
|
CreatedBy = userId,
|
|
ModifiedBy = userId
|
|
};
|
|
|
|
await faceContext.InsertAsync(face);
|
|
}
|
|
else
|
|
{
|
|
if (face.Face == request.Face)
|
|
{
|
|
_logger.LogWarning("相同的人脸照片更新忽略");
|
|
return;
|
|
}
|
|
|
|
face.Face = request.Face;
|
|
face.ModifiedBy = userId;
|
|
face.ModifiedTime = DateTime.Now;
|
|
await faceContext.UpdateAsync(face);
|
|
}
|
|
|
|
//生成任务
|
|
await _devicePermissionService.GenerateDeviceTasksAsync(gainfo.No, taskType);
|
|
}
|
|
|
|
public async Task UploadFacesAsync(List<GainfoUploadFaceRequest> requests)
|
|
{
|
|
foreach (var request in requests)
|
|
{
|
|
var gainfo = await _gainfoStore.Queryable(GainfoStatusEnumType.Working).Where(x => x.No == request.UserNo).FirstAsync();
|
|
gainfo ??= await _gainfoStore.Queryable(GainfoStatusEnumType.External).Where(x => x.No == request.UserNo).FirstAsync();
|
|
|
|
gainfo.ThrowIfNull("人员档案信息不存在");
|
|
|
|
var dbContext = _dbContext.ChangeDb("face");
|
|
var face = await dbContext.Queryable<GainfoFaceEntity>().Where(x => x.UserCode == gainfo.Code).SingleAsync();
|
|
|
|
var taskType = face == null ? DeviceTaskEnumType.Add : DeviceTaskEnumType.Update;
|
|
|
|
await _redisCache.HashSetAsync("faces", gainfo.Code, request.Face);
|
|
if (face == null)
|
|
{
|
|
face = new GainfoFaceEntity
|
|
{
|
|
UserCode = gainfo.Code,
|
|
Face = request.Face
|
|
};
|
|
|
|
await dbContext.InsertAsync(face);
|
|
}
|
|
else
|
|
{
|
|
if (face.Face == request.Face)
|
|
{
|
|
_logger.LogWarning("相同的人脸照片更新忽略");
|
|
return;
|
|
}
|
|
|
|
face.Face = request.Face;
|
|
await dbContext.UpdateAsync(face);
|
|
}
|
|
|
|
//生成任务
|
|
await _devicePermissionService.GenerateDeviceTasksAsync(gainfo.No, taskType);
|
|
}
|
|
}
|
|
|
|
public async Task<string> GetFaceByUserCodeAsync(string userCode)
|
|
{
|
|
var gainfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == userCode).SingleAsync();
|
|
gainfo.ThrowIfNull($"{userCode}人员信息不存在");
|
|
|
|
var dbContext = _dbContext.ChangeDb("face");
|
|
|
|
var face = await dbContext.Queryable<GainfoFaceEntity>()
|
|
.Where(x => x.UserCode == userCode)
|
|
.SingleAsync();
|
|
|
|
face.ThrowIfNull("人脸照片尚未录入");
|
|
|
|
var timeLimitedDataProtector = _serviceProvider.GetService<IDataProtectionProvider>()
|
|
.CreateProtector("down:face")
|
|
.ToTimeLimitedDataProtector();
|
|
|
|
var faceUrl = _configuration.GetSection("FaceUrlOptions:Url").Value;
|
|
var limit = _configuration.GetSection("FaceUrlOptions:Limit").Get<int>();
|
|
|
|
var key = $"face:{userCode}";
|
|
var token = timeLimitedDataProtector.Protect(key, TimeSpan.FromSeconds(limit));
|
|
|
|
return faceUrl + token;
|
|
}
|
|
|
|
public async Task<Dictionary<string, string>> GetFaceByUserCodesAsync(GetFaceByUserCodesRequest request)
|
|
{
|
|
var faceDictionary = new Dictionary<string, string>();
|
|
|
|
foreach (var userCode in request.UserCodes)
|
|
{
|
|
var faceUrl = await GetFaceByUserCodeAsync(userCode);
|
|
faceDictionary.Add(userCode, faceUrl);
|
|
}
|
|
return faceDictionary;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 档案列表
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task<Pagination<GainfoListResponse>> GetGainfoListAsync(GainfoListRequest request)
|
|
{
|
|
var page = await _gainfoStore.Queryable(request.Status)
|
|
.LeftJoin<DepartmentEntity>((ga, de) => ga.DepartmentNo == de.No)
|
|
.WhereIF(!request.Name.IsEmpty(), ga => ga.Name == request.Name)
|
|
.WhereIF(!request.IdNo.IsEmpty(), ga => ga.IdNo == request.IdNo)
|
|
.WhereIF(!request.DepartmentNo.IsEmpty(), ga => ga.DepartmentNo == request.DepartmentNo)
|
|
.WhereIF(!request.Code.IsEmpty(), ga => ga.Code == request.Code)
|
|
.Select((ga, de) => new GainfoListResponse
|
|
{
|
|
No = ga.No,
|
|
Name = ga.Name,
|
|
Code = ga.Code,
|
|
IdNo = ga.IdNo,
|
|
Gender = ga.Gender,
|
|
Phone = ga.Phone,
|
|
DepartmentNo = de.No,
|
|
DepartmentName = de.Name,
|
|
Address = ga.Address,
|
|
}).ToPageListAsync(request);
|
|
return page;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 档案详情
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task<GainfoDetailResponse> GetGainfoDetailAsync(GainfoDetailRequest request)
|
|
{
|
|
var info = await _gainfoStore.Queryable(request.Status)
|
|
.LeftJoin<DepartmentEntity>((ga, de) => ga.DepartmentNo == de.No)
|
|
.LeftJoin<PositionEntity>((ga, de, pos) => ga.PositionNo == pos.No)
|
|
.Where(ga => ga.No == request.No)
|
|
.Select((ga, de, pos) => new GainfoDetailResponse
|
|
{
|
|
No = ga.No,
|
|
SapNo = ga.SapNo,
|
|
Name = ga.Name,
|
|
Code = ga.Code,
|
|
IdClass = ga.IdClass,
|
|
IdNo = ga.IdNo,
|
|
Gender = ga.Gender,
|
|
Address = ga.Address,
|
|
Birthday = ga.Birthday,
|
|
Phone = ga.Phone,
|
|
Grade = ga.Grade,
|
|
Title = ga.Title,
|
|
Degree = ga.Degree,
|
|
Werks = ga.Werks,
|
|
CostId = ga.CostId,
|
|
Marital = "未知",
|
|
NativeName = ga.Native,
|
|
CountryName = ga.CountryNo,
|
|
NationName = ga.Nation,
|
|
ClassName = ga.IdClass,
|
|
Factory = ga.Factory,
|
|
OnboardingDate = ga.CreateTime,
|
|
|
|
DepartmentName = de.Name,
|
|
Position = pos.Name,
|
|
})
|
|
.SingleAsync();
|
|
|
|
if (info != null)
|
|
{
|
|
var searchTypes = new List<string>() { "native", "country", "nation", "cls" };
|
|
var types = await _dbContext.Queryable<BasicTypeEntity>().Where(x => searchTypes.Contains(x.Type)).ToListAsync();
|
|
|
|
info.NativeName = types.Where(x => x.Type == "native").FirstOrDefault(x => x.Code == info.NativeName)?.Display;
|
|
info.CountryName = types.Where(x => x.Type == "country").FirstOrDefault(x => x.Code == info.CountryName)?.Display ?? "中国";
|
|
info.NationName = types.Where(x => x.Type == "nation").FirstOrDefault(x => x.Code == info.NationName)?.Display;
|
|
info.ClassName = types.Where(x => x.Type == "cls").FirstOrDefault(x => x.Code == info.ClassName)?.Display ?? "身份证";
|
|
|
|
if (request.WithFace)
|
|
{
|
|
info.Face = await _dbContext.ChangeDb("face").Queryable<GainfoFaceEntity>().Where(x => x.UserCode == info.Code).Select(x => x.Face).SingleAsync();
|
|
}
|
|
|
|
var tenantsResult = await _tenantApi.GetTenantsInternalAsync();
|
|
var tenants = tenantsResult.Data;
|
|
info.FactoryName = tenants.FirstOrDefault(x => x.Code == info.Factory)?.Name;
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
public async Task MigrationAsync(MigrationRequest request)
|
|
{
|
|
//档案数据
|
|
var gainfo = await _gainfoStore.Queryable().Where(x => x.Code == request.Code).FirstAsync();
|
|
if (gainfo == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//卡号为空则更新
|
|
if (gainfo.CardNo.IsEmpty())
|
|
{
|
|
gainfo.CardNo = request.CardNo;
|
|
await _gainfoStore.UpdateAsync(gainfo);
|
|
}
|
|
|
|
//外部传入人脸
|
|
if (request.Face.IsPresent())
|
|
{
|
|
var faceDbContext = _dbContext.ChangeDb("face");
|
|
var exists = await faceDbContext.Queryable<GainfoFaceEntity>().AnyAsync(x => x.UserCode == gainfo.Code);
|
|
//人脸不存在则写入
|
|
if (!exists)
|
|
{
|
|
await faceDbContext.InsertAsync(new GainfoFaceEntity
|
|
{
|
|
CreatedBy = 1,
|
|
CreateTime = DateTime.Now,
|
|
ModifiedBy = 1,
|
|
ModifiedTime = DateTime.Now,
|
|
UserCode = gainfo.Code,
|
|
Face = request.Face,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------help methods ------------------------------------------------
|
|
|
|
/// <summary>
|
|
/// 递归获取部门No
|
|
/// </summary>
|
|
/// <param name="departmentNos"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<string>> GetRecursionDepartmentNosAsync(List<string> departmentNos)
|
|
{
|
|
if (departmentNos.IsEmpty())
|
|
{
|
|
return new List<string>();
|
|
}
|
|
|
|
var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();
|
|
var currentNos = departments.Where(x => departmentNos.Contains(x.No)).ToList();
|
|
|
|
foreach (var item in currentNos)
|
|
{
|
|
RecursionGetNext(item.No, departments, departmentNos);
|
|
}
|
|
|
|
return departmentNos.Distinct().ToList();
|
|
|
|
void RecursionGetNext(string currentCode, List<DepartmentEntity> departments, List<string> result)
|
|
{
|
|
var next = departments.Where(x => x.PNo == currentCode).ToList();
|
|
|
|
foreach (var item in next)
|
|
{
|
|
result.Add(item.No);
|
|
RecursionGetNext(item.No, departments, result);
|
|
}
|
|
}
|
|
}
|
|
}
|