jinko.yikatong/Src/Dlhis.Basic/Organization/Services/Implements/GainfoService.cs

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.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,
        IDepartmentService departmentService)
    {
        _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<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,
                   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,
                Factory = ga.Factory,
                OnboardingDate = ga.CreateTime,
            })
            .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 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);
            }
        }
    }

}