632 lines
23 KiB
C#
632 lines
23 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.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.IdentityModel.Tokens.Jwt;
|
|
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 ILogger<GainfoService> _logger;
|
|
|
|
public GainfoService(IGainfoStore gainfoStore,
|
|
IDbContext dbContext,
|
|
ICurrentUser currentUser,
|
|
IDevicePermissionService devicePermissionService,
|
|
RedisCache redisCache,
|
|
IServiceProvider serviceProvider,
|
|
IConfiguration configuration,
|
|
ILogger<GainfoService> logger)
|
|
{
|
|
_gainfoStore = gainfoStore;
|
|
_dbContext = dbContext;
|
|
_currentUser = currentUser;
|
|
_devicePermissionService = devicePermissionService;
|
|
_redisCache = redisCache;
|
|
_serviceProvider = serviceProvider;
|
|
_configuration = configuration;
|
|
_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 = LinqExpressionExtension.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;
|
|
}
|
|
|
|
/// <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<CanteenUserEntity>((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,
|
|
MealInfo = new GainfoCurrentMealInfoResponse
|
|
{
|
|
Balance = mealUser.Balance
|
|
}
|
|
})
|
|
.FirstAsync();
|
|
|
|
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<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")
|
|
.LeftJoin<BasicTypeEntity>((ga, de, type, posi, type2, type3, type4) => ga.IdClass == type4.Code && type4.Type == "cls")
|
|
.Where(ga => ga.No == request.No)
|
|
.Select((ga, de, type, posi, type2, type3, type4) => 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 == "Single" ? "未婚" : "已婚",
|
|
CountryName = type2.Display,
|
|
NationName = type3.Display,
|
|
ClassName = type4.Display,
|
|
})
|
|
.FirstAsync();
|
|
|
|
if (info != null)
|
|
{
|
|
if (request.WithFace)
|
|
{
|
|
info.Face = await _dbContext.ChangeDb("face").Queryable<GainfoFaceEntity>().Where(x => x.UserCode == info.Code).Select(x => x.Face).SingleAsync();
|
|
}
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
public async Task<Dictionary<string, Pagination<GainfoDetailResponse>>> GetWeekNumberAsync(WeekNumberRequest request, string token)
|
|
{
|
|
var werks = GetClaimValueFromToken(token, "tenant");
|
|
|
|
//获取近7天并转化为"yyyy-MM-dd"集合
|
|
DateTime currentDate = DateTime.Now;
|
|
List<string> times = new List<string>();
|
|
for (int i = 0; i < 7; i++)
|
|
{
|
|
DateTime date = currentDate.AddDays(-i);
|
|
string dateString = date.ToString("yyyy-MM-dd");
|
|
times.Add(dateString);
|
|
}
|
|
|
|
var dic = new Dictionary<string, Pagination<GainfoDetailResponse>>();
|
|
|
|
foreach (var time in times)
|
|
{
|
|
var infos = await _gainfoStore.Queryable(GainfoStatusEnumType.Working)
|
|
.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.CreateTime.ToString("yyyy-MM-dd") == time && ga.Werks == werks)
|
|
.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,
|
|
}).ToPageListAsync(request);
|
|
|
|
dic[time] = infos;
|
|
}
|
|
return dic;
|
|
}
|
|
|
|
public async Task<Dictionary<string, Pagination<GainfoDetailResponse>>> GetDimissionWeekNumberAsync(WeekNumberRequest request, string token)
|
|
{
|
|
var werks = GetClaimValueFromToken(token, "tenant");
|
|
|
|
//获取近7天并转化为"yyyy-MM-dd"集合
|
|
DateTime currentDate = DateTime.Now;
|
|
List<string> times = new List<string>();
|
|
for (int i = 0; i < 7; i++)
|
|
{
|
|
DateTime date = currentDate.AddDays(-i);
|
|
string dateString = date.ToString("yyyy-MM-dd");
|
|
times.Add(dateString);
|
|
}
|
|
|
|
var dic = new Dictionary<string, Pagination<GainfoDetailResponse>>();
|
|
foreach (var time in times)
|
|
{
|
|
var infos = await _gainfoStore.Queryable(GainfoStatusEnumType.Leave)
|
|
.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.CreateTime.ToString("yyyy-MM-dd") == time && ga.Werks == werks)
|
|
.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,
|
|
}).ToPageListAsync(request);
|
|
dic[time] = infos;
|
|
}
|
|
return dic;
|
|
}
|
|
|
|
public async Task<GainfoGainfoNumbersResponse> GetGainfoNumbersAsync(string token)
|
|
{
|
|
var werks = GetClaimValueFromToken(token, "tenant");
|
|
|
|
//在职人数
|
|
var onlineNumber = await _gainfoStore.Queryable(GainfoStatusEnumType.Working)
|
|
.Where(ga => ga.Werks == werks)
|
|
.CountAsync();
|
|
|
|
//离职人数
|
|
var offlineNumber = await _gainfoStore.Queryable(GainfoStatusEnumType.Leave)
|
|
.Where(ga => ga.Werks == werks)
|
|
.CountAsync();
|
|
|
|
//考勤总人数
|
|
var attendanceNumber = onlineNumber + offlineNumber;
|
|
|
|
var res = new GainfoGainfoNumbersResponse
|
|
{
|
|
OnlineNumber = onlineNumber,
|
|
OfflineNumber = offlineNumber,
|
|
AttendanceNumber = attendanceNumber
|
|
};
|
|
return res;
|
|
}
|
|
|
|
//-------------------------------------------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);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 解析token
|
|
/// </summary>
|
|
/// <param name="token"></param>
|
|
/// <param name="claimType"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="Exception"></exception>
|
|
private string GetClaimValueFromToken(string token, string claimType)
|
|
{
|
|
try
|
|
{
|
|
var handler = new JwtSecurityTokenHandler();
|
|
var jsonToken = handler.ReadToken(token) as JwtSecurityToken;
|
|
|
|
if (jsonToken == null)
|
|
throw new Exception("Invalid JWT Token");
|
|
|
|
var claimValue = jsonToken.Claims.FirstOrDefault(c => c.Type == claimType)?.Value;
|
|
|
|
return claimValue;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
}
|