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

using System.Text.RegularExpressions;
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.Scheduled.Api;
using Dlhis.Scheduled.Api.Request;
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 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 IDataProtectionProvider _dataProtectionProvider;
    private readonly ICurrentUser _currentUser;
    private readonly IDevicePermissionService _devicePermissionService;
    private readonly RedisCache _redisCache;
    private readonly IConfiguration _configuration;
    private readonly ITenantApi _tenantApi;
    private readonly IHangfireApi _hangfireApi;
    private readonly ILogger<GainfoService> _logger;

    public GainfoService(IGainfoStore gainfoStore,
        IDbContext dbContext,
        IDataProtectionProvider dataProtectionProvider,
        ICurrentUser currentUser,
        IDevicePermissionService devicePermissionService,
        RedisCache redisCache,
        IConfiguration configuration,
        ITenantApi tenantApi,
        IHangfireApi hangfireApi,
        ILogger<GainfoService> logger)
    {
        _gainfoStore = gainfoStore;
        _dbContext = dbContext;
        _dataProtectionProvider = dataProtectionProvider;
        _currentUser = currentUser;
        _devicePermissionService = devicePermissionService;
        _redisCache = redisCache;
        _configuration = configuration;
        _tenantApi = tenantApi;
        _hangfireApi = hangfireApi;
        _logger = logger;
    }

    /// <summary>
    /// 档案分页
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    public async Task<Pagination<GainfoPageResponse>> GetPageAsync(GainfoPageRequest request)
    {
        var currentTenantId = _currentUser.GetStringTenantId();

        //根据组织架构搜索档案
        var 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 == request.Search
            || gainfo.IdNo == 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;
    }

    public async Task<GainfoCurrentResponse> CurrentUserInfoAsync()
    {
        var code = _currentUser.GetUserClaim("jinko-code");
        if (code.IsEmpty())
        {
            _logger.LogWarning("工号为空尝试获取人员信息");
            return null;
        }
        var gainfo = await _gainfoStore.Queryable().Where(x => x.Code == code).SingleAsync();

        if (gainfo == null)
        {
            //开启同步处理
            await _hangfireApi.SyncSapPersonAsync(new SapNoRequest { Code = code });
            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)
        {
            try
            {
                var tenantResult = await _tenantApi.GetTenantByCodeAsync(info.Factory);
                if (tenantResult != null && tenantResult.Data != null)
                {
                    info.Factory = tenantResult.Data.Name;
                }
            }
            catch (Exception)
            {
            }
        }

        return info;
    }

    public async Task<IActionResult> GetFaceAsync(string token)
    {
        var timeLimitedDataProtector = _dataProtectionProvider.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();
            }

            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().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 = _dataProtectionProvider.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)
        {
            try
            {
                var faceUrl = await GetFaceByUserCodeAsync(userCode);
                faceDictionary.Add(userCode, faceUrl);
            }
            catch (Exception)
            {
            }
        }
        return faceDictionary;
    }


    public async Task<string> CheckIdNoAndNameMatchAsync(GainfoCheckIdNoAndNameRequest request)
    {
        var match = await _gainfoStore.Queryable(GainfoStatusEnumType.External).AnyAsync(x => x.IdNo == request.IdNo && x.Name == request.Name);
        if (!match)
        {
            match = await _gainfoStore.Queryable(GainfoStatusEnumType.Working).AnyAsync(x => x.IdNo == request.IdNo && x.Name == request.Name);
        }

        match.ThrowIfFalse("验证失败!");

        return request.IdNo;
    }

    /// <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,
                NativeName = ga.Native,
                CountryName = ga.CountryNo,
                NationName = ga.Nation,
                ClassName = ga.IdClass,

                EntryDate = ga.EntryDate,

                Workplace = ga.Workplace,
                Factory = ga.Factory,

                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();
            }

            try
            {
                var tenantsResult = await _tenantApi.GetTenantsInternalAsync();
                var tenants = tenantsResult.Data;

                info.Workplace = tenants.FirstOrDefault(x => x.Code == info.Workplace)?.Name;
                info.Factory = tenants.FirstOrDefault(x => x.Code == info.Factory)?.Name;
            }
            catch (Exception)
            {

            }
        }

        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();

        //local method
        void RecursionGetNext(string currentNo, List<DepartmentEntity> departments, List<string> result)
        {
            var next = departments.Where(x => x.PNo == currentNo).ToList();

            foreach (var item in next)
            {
                result.Add(item.No);
                RecursionGetNext(item.No, departments, result);
            }
        }
    }
}