419 lines
15 KiB
C#
419 lines
15 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 Kurisu.AspNetCore.Scope;
|
|
using Kurisu.AspNetCore.UnifyResultAndValidation;
|
|
using Kurisu.AspNetCore.Utils.Extensions;
|
|
using Kurisu.Core.DataAccess.Dto;
|
|
using Kurisu.Core.User.Abstractions;
|
|
using Kurisu.SqlSugar.Attributes;
|
|
using Kurisu.SqlSugar.Extensions;
|
|
using Kurisu.SqlSugar.Options;
|
|
using Kurisu.SqlSugar.Services;
|
|
using Mapster;
|
|
using Microsoft.AspNetCore.DataProtection;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
|
|
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 ILogger<GainfoService> _logger;
|
|
|
|
public GainfoService(IGainfoStore gainfoStore,
|
|
IDbContext dbContext,
|
|
ICurrentUser currentUser,
|
|
IDevicePermissionService devicePermissionService,
|
|
ILogger<GainfoService> logger)
|
|
{
|
|
_gainfoStore = gainfoStore;
|
|
_dbContext = dbContext;
|
|
_currentUser = currentUser;
|
|
_devicePermissionService = devicePermissionService;
|
|
_logger = logger;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 档案分页
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task<Pagination<GainfoPageResponse>> GetPageAsync(GainfoPageRequest request)
|
|
{
|
|
request.DepartmentNos = await GetRecursionDepartmentNosAsync(request.DepartmentNos);
|
|
|
|
var tenant = _currentUser.GetStringTenantId();
|
|
|
|
var page = await _gainfoStore.Queryable(request.Status)
|
|
.WhereIF(request.DepartmentNos?.Any() == true, gainfo => request.DepartmentNos.Contains(gainfo.DepartmentNo))
|
|
.WhereIF(request.Search.IsPresent(), gainfo =>
|
|
gainfo.Name.Contains(request.Search)
|
|
|| gainfo.Code.Contains(request.Search))
|
|
.Where(gainfo => gainfo.Werks == tenant)
|
|
.Select<GainfoPageResponse>()
|
|
.ToPageListAsync(request);
|
|
|
|
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>
|
|
[Transactional]
|
|
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 gainfo = await _gainfoStore.Queryable(GainfoStatusEnumType.Working)
|
|
.LeftJoin<DepartmentEntity>((ga, department) => ga.DepartmentNo == department.No)
|
|
.LeftJoin<CanteenUserEntity>((ga, department, mealUser) => ga.No == mealUser.UserNo)
|
|
.Where((ga, department) => ga.IdentityUserId == identityId)
|
|
.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,
|
|
MealInfo = new GainfoCurrentMealInfoResponse
|
|
{
|
|
Balance = mealUser.Balance
|
|
}
|
|
})
|
|
.FirstAsync();
|
|
|
|
return gainfo;
|
|
}
|
|
|
|
public async Task<IActionResult> GetFaceAsync(string token)
|
|
{
|
|
return await Scoped.Request.Value.CreateAsync<IActionResult>(async (sp) =>
|
|
{
|
|
var timeLimitedDataProtector = sp.GetService<IDataProtectionProvider>()
|
|
.CreateProtector("down:face")
|
|
.ToTimeLimitedDataProtector();
|
|
|
|
try
|
|
{
|
|
var password = timeLimitedDataProtector.Unprotect(token);
|
|
var userCode = password.Split(':')[1];
|
|
|
|
var configuration = sp.GetService<IConfiguration>();
|
|
var faceConnectionString = configuration.GetSection("SqlSugarOptions:FaceConnectionString").Value;
|
|
if (faceConnectionString.IsEmpty())
|
|
{
|
|
_logger.LogWarning("暂不支持获取人脸");
|
|
return new NotFoundResult();
|
|
}
|
|
|
|
//todo 切换连接字符串
|
|
var dbContext = sp.GetService<IDbContext>();
|
|
dbContext.Client.CurrentConnectionConfig.ConnectionString = faceConnectionString;
|
|
var face = await dbContext.Queryable<GainfoFaceEntity>().Where(x => x.UserCode == userCode).SingleAsync();
|
|
|
|
if (face == null)
|
|
{
|
|
_logger.LogWarning("学工号:{userCode}不存在人脸照片", userCode);
|
|
return new NotFoundResult();
|
|
}
|
|
|
|
return new FileContentResult(Convert.FromBase64String(face.Face), "image/png");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "获取人脸失败:" + 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("人员档案信息不存在");
|
|
|
|
await Scoped.Request.Value.CreateAsync(async (sp) =>
|
|
{
|
|
var configuration = sp.GetService<IConfiguration>();
|
|
var faceConnectionString = configuration.GetSection("SqlSugarOptions:FaceConnectionString").Value;
|
|
if (faceConnectionString.IsEmpty())
|
|
{
|
|
throw new UserFriendlyException("暂不支持人脸上传");
|
|
}
|
|
|
|
var dbContext = sp.GetService<IDbContext>();
|
|
//todo 切换连接字符串
|
|
dbContext.Client.CurrentConnectionConfig.ConnectionString = faceConnectionString;
|
|
var face = await dbContext.Queryable<GainfoFaceEntity>().Where(x => x.UserCode == gainfo.Code).SingleAsync();
|
|
|
|
var taskType = face == null ? DeviceTaskEnumType.Add : DeviceTaskEnumType.Update;
|
|
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}人员信息不存在");
|
|
|
|
return await Scoped.Request.Value.CreateAsync<string>(async (sp) =>
|
|
{
|
|
var configuration = sp.GetService<IConfiguration>();
|
|
|
|
var faceConnectionString = configuration.GetSection($"{nameof(SqlSugarOptions)}:FaceConnectionString").Value;
|
|
if (faceConnectionString.IsEmpty())
|
|
{
|
|
throw new UserFriendlyException("暂不支持获取人脸");
|
|
}
|
|
|
|
var dbContext = sp.GetService<IDbContext>();
|
|
//todo 切换连接字符串
|
|
dbContext.Client.CurrentConnectionConfig.ConnectionString = faceConnectionString;
|
|
|
|
var face = await dbContext.Queryable<GainfoFaceEntity>()
|
|
.Where(x => x.UserCode == userCode)
|
|
.SingleAsync();
|
|
|
|
face.ThrowIfNull("人脸照片尚未录入");
|
|
|
|
var timeLimitedDataProtector = sp.GetService<IDataProtectionProvider>()
|
|
.CreateProtector("down:face")
|
|
.ToTimeLimitedDataProtector();
|
|
|
|
var faceUrl = configuration.GetSection("FaceUrlOptions:Url").Value;
|
|
var limit = configuration.GetSection("FaceUrlOptions:Limit").Get<int>();
|
|
var dataProtectionProvider = sp.GetService<IDataProtectionProvider>();
|
|
|
|
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>> GetGainfoListTaskAsync( 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,
|
|
Employed = ga.Employed
|
|
}).ToPageListAsync(request);
|
|
return page;
|
|
}
|
|
/// <summary>
|
|
/// 档案详情
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task<GainfoDetailResponse> GetGainfoDetailTaskAsync(GainfoDetailRequest request)
|
|
{
|
|
var info = await _gainfoStore.Queryable(request.Status)
|
|
.LeftJoin<DepartmentEntity>((ga, de) => ga.DepartmentNo == de.No)
|
|
.LeftJoin<BasicTypeEntity>((ga,de,type) => ga.Native == type.Code && type.Type == "native")
|
|
.LeftJoin<PositionEntity>((ga, de, type,posi) => ga.Position == posi.Name)
|
|
.LeftJoin<BasicTypeEntity>((ga, de, type, posi,type2) => ga.CountryNo == type2.Code && type2.Type == "country")
|
|
.LeftJoin<BasicTypeEntity>((ga, de, type, posi, type2,type3) => ga.Nation == type3.Code && type3.Type == "nation")
|
|
.Where(ga => ga.No == request.No)
|
|
.Select((ga, de,type,posi,type2, type3) => new GainfoDetailResponse
|
|
{
|
|
No = ga.No,
|
|
SapNo = ga.SapNo,
|
|
Name = ga.Name,
|
|
Code = ga.Code,
|
|
DepartmentName = de.Name,
|
|
IdClass = ga.IdClass,
|
|
IdNo = ga.IdNo,
|
|
Gender = ga.Gender,
|
|
NativeName = type.Display,
|
|
Address = ga.Address,
|
|
Birthday = ga.Birthday,
|
|
Phone = ga.Phone,
|
|
Position = ga.Position,
|
|
Grade = posi.Grade,
|
|
Degree = ga.Degree,
|
|
Werks = ga.Werks,
|
|
CostId = ga.CostId,
|
|
Marital = ga.Marital,
|
|
CountryName = type2.Display,
|
|
NationName = type3.Display,
|
|
IsActive = ga.Employed == "Active" ? true : false,
|
|
}).FirstAsync();
|
|
return info;
|
|
}
|
|
|
|
//-------------------------------------------help methods ------------------------------------------------
|
|
|
|
/// <summary>
|
|
/// 递归获取部门No
|
|
/// </summary>
|
|
/// <param name="departmentNos"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<string>> GetRecursionDepartmentNosAsync(List<string> departmentNos)
|
|
{
|
|
if (departmentNos == null || departmentNos.Count == 0)
|
|
{
|
|
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);
|
|
}
|
|
|
|
foreach (var item in next)
|
|
{
|
|
RecursionGetNext(item.No, departments, result);
|
|
}
|
|
}
|
|
}
|
|
}
|