579 lines
21 KiB
C#
579 lines
21 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;
|
|
using System.IdentityModel.Tokens.Jwt;
|
|
|
|
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.IsPresent(), 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,
|
|
}).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,
|
|
}).FirstAsync();
|
|
|
|
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);
|
|
}
|
|
|
|
foreach (var item in next)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|