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

using Dlhis.Basic.Organization.Request;
using Dlhis.Basic.Organization.Response;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Basic.Enums;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils;
using Kurisu.AspNetCore.Utils.Extensions;
using Mapster;
using SqlSugar;

namespace Dlhis.Basic.Organization.Services.Implements;

public class GainfoOutsourceService : IGainfoOutsourceService
{
    private readonly IDbContext _dbContext;
    private readonly RedisCache _redisCache;

    public GainfoOutsourceService(IDbContext dbContext, RedisCache redisCache)
    {
        _dbContext = dbContext;
        _redisCache = redisCache;
    }

    public async Task SaveAsync(GainfoOutsourceRequest request)
    {
        await CheckDuplicate(request);
        var sapCodeExists = await _dbContext.Queryable<GainfoEntity>()
            .Where(x => x.Code == request.ExternalInfo.SapCode)
            .AnyAsync();
        sapCodeExists.ThrowIfFalse("对接人不存在");
        var isOutsource = await _dbContext.Queryable<OutsourceEntity>()
            .Where(x => x.Code == request.ExternalInfo.SapCode)
            .AnyAsync();
        isOutsource.ThrowIfTrue("对接人不可为外包人员");

        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<GainfoEntity>();
            entity.No = Guid.NewGuid().ToString();
            entity.Type = GainfoUserTypeEnumType.Outsource;
            entity.Code = request.Code.IsPresent()
                ? request.Code
                : await GetOutSourceCodeAsync();

            await _dbContext.InsertAsync(entity);

            if (!await _dbContext.Queryable<OutsourceEntity>().Where(x => x.Code == entity.Code).AnyAsync())
            {
                await _dbContext.InsertAsync(new OutsourceEntity
                {
                    Code = entity.Code,
                    Supplier = request.ExternalInfo.Supplier,
                    SapCode = request.ExternalInfo.SapCode,
                    SapPhone = request.ExternalInfo.SapPhone
                });
            }
        }
        else
        {
            var entity = await _dbContext.Queryable<GainfoEntity>().FirstAsync(x => x.Id == request.Id);
            entity.ThrowIfNull("档案数据不存在");

            var outsource = await _dbContext.Queryable<OutsourceEntity>().FirstAsync(x => x.Code == entity.Code);
            (outsource == null).ThrowIfTrue("不可编辑非外包人员档案数据");

            var idNo = entity.IdNo;
            var phone = entity.Phone;
            request.Adapt(entity);
            entity.IdNo = idNo;
            entity.Phone = phone;

            outsource!.Code = entity.Code;
            request.ExternalInfo.Adapt(outsource);

            await _dbContext.UpdateAsync(entity);
            await _dbContext.UpdateAsync(outsource);
        }
    }


    public async Task<GainfoOutSourceExternalInfoResponse> GetExternalInfoAsync(string userNo)
    {
        return await _dbContext.Queryable<OutsourceEntity>()
            .LeftJoin<GainfoEntity>((a, b) => a.Code == b.Code)
            .LeftJoin<GainfoEntity>((a, b, c) => a.SapCode == c.Code)
            .Where((a, b, c) => b.No == userNo)
            .Select((a, b, c) => new GainfoOutSourceExternalInfoResponse
            {
                Supplier = a.Supplier,
                SapCode = a.SapCode,
                SapPhone = a.SapPhone,
                Name = c.Name,
                EntryDate = b.EntryDate,
                ResignationDate = b.ResignationDate,
                Factory = b.Factory
            })
            .SingleAsync();
    }


    //********************************************************************** help methods ***********************************************************************************

    private async Task<string> GetOutSourceCodeAsync()
    {
        await using var handler = await _redisCache.LockAsync("gainfo:outsource:code-generate", expiry: TimeSpan.FromSeconds(3), retryInterval: TimeSpan.FromSeconds(1), retryCount: 3);
        handler.Acquired.ThrowIfFalse("生成虚拟工号失败");

        int code;
        var entity = await _dbContext.Queryable<OutsourceEntity>().Where(x => x.Code.StartsWith("LS")).OrderBy(x => x.Id, OrderByType.Desc).FirstAsync();
        if (entity == null)
        {
            code = 1;
        }
        else
        {
            code = int.Parse(entity.Code.Replace("LS", "").TrimStart('0')) + 1;
        }

        return "LS" + code.ToString().PadLeft(6, '0');
    }

    /// <summary>
    /// 检查证件号重复
    /// </summary>
    /// <param name="request"></param>
    private async Task CheckDuplicate(GainfoOutsourceRequest request)
    {
        var exists = await _dbContext.Queryable<GainfoEntity>()
            .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
            .Where(x => x.IdNo == request.IdNo).AnyAsync();
        exists.ThrowIfTrue($"证件号{request.IdNo}重复");

        if (request.Code.IsPresent())
        {
            exists = await _dbContext.Queryable<GainfoEntity>()
                .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
                .Where(x => x.Code == request.Code).AnyAsync();
            exists.ThrowIfTrue($"工号{request.Code}重复");
        }
    }
}