feat:开发

sunpengfei

2025-08-21 1aeaabb680b44b8ef960c4471f2f2903cbfe4805

 FlexJobApi.UserServer.Application/ElectronSign/Commands/ContractTemplateCommandHandler.cs

@@ -1,4 +1,10 @@
using FlexJobApi.Core;
using Azure.Core;
using FlexJobApi.Core;
using FlexJobApi.Core.Models.ElectronSignServer.Common;
using FlexJobApi.Core.Models.ElectronSignServer.ContractTemplates;
using FlexJobApi.Core.Models.ElectronSignServer.PersonalUserReals;
using FlexJobApi.Core.Models.ElectronSignServer.Users;
using Furion;
using Furion.DatabaseAccessor;
using Furion.FriendlyException;
using Mapster;
@@ -9,6 +15,7 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace FlexJobApi.UserServer.Application
{
@@ -16,12 +23,15 @@
    /// 合同模板命令处理器
    /// </summary>
    public class ContractTemplateCommandHandler(
            IRepository<ContractTemplate> rep
            IRepository<ContractTemplate> rep,
            WxmpUtils wxmpUtils
        ) :
        IRequestHandler<SaveContractTemplateCommand, Guid>,
        IRequestHandler<SaveContractTemplateValuesCommand, Guid>,
        IRequestHandler<SetIsDisabledContractTemplateCommand, int>
    {
        private readonly IRepository<ContractTemplate> rep = rep;
        private readonly WxmpUtils wxmpUtils = wxmpUtils;

        /// <summary>
        /// 保存合同模板
@@ -38,11 +48,63 @@
            }
            if (request.EnterpriseId == null) throw Oops.Oh(EnumErrorCodeType.s400, "请选择企业");

            return await request.SaveData<ContractTemplate, SaveContractTemplateCommand>(
            var existCode = await rep.AsQueryable().AsNoTracking()
                .AnyAsync(it => it.Code == request.Code && !it.IsDisabled && it.Id != request.Id);
            if (existCode) throw Oops.Oh(EnumErrorCodeType.s405, "业务编码");

            var entity = await request.SaveData<ContractTemplate, SaveContractTemplateCommand>(
                 q => q
                    .Include(it => it.Values)
                    .Where(it => it.EnterpriseId == request.EnterpriseId && !it.IsDisabled),
                 it => it.EnterpriseId == request.EnterpriseId && it.Name == request.Name && !it.IsDisabled && it.Id != request.Id,
                 null,
                 entity =>
                 {
                     if (entity.Code != request.Code)
                     {
                         entity.WxmpQrCode = wxmpUtils.GetQrCodeOssUrl(new WxmpGetQrCodeCommand
                         {
                             UserType = EnumUserType.Personal,
                             OssScene = "Wxmp/QrCode/ContractTemplate",
                             OssFileName = $"{entity.Name}.png",
                             Page = "subpackages/mine/mineAgreementSignDetail/mineAgreementSignDetail",
                             CheckPath = false,
                             Scene = $"{entity.Code}",
                         }).Result;
                     }

                     request.Adapt(entity);

                     if (request.Id == null)
                     {
                         entity.Status = EnumContractTemplateStatus.Wait;
                     }
                     else if (entity.Access.HasValue && entity.TemplateId.IsNotNull() && entity.Values.IsNotNull())
                     {
                         entity.Status = EnumContractTemplateStatus.Completed;
                         entity.CompletedTime = DateTime.Now;
                     }
                 },
                 cancellationToken);

            await SyncElectronSignContractTemplate(entity);

            return entity.Id;
        }

        /// <summary>
        /// 合同制版
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<Guid> Handle(SaveContractTemplateValuesCommand request, CancellationToken cancellationToken)
        {
            var logier = JwtUtils.GetCurrentLogier();
            var entity = await request.SaveData<ContractTemplate, SaveContractTemplateValuesCommand>(
                 q => q
                    .Include(it => it.Values)
                    .Where(it => !it.IsDisabled),
                 null,
                 entity =>
                 {
                     request.Adapt(entity);
@@ -69,13 +131,17 @@
                         entity.UpdatedUserId = logier.Id;
                         entity.UpdatedTime = DateTime.Now;
                     }
                     if (entity.Access.HasValue && entity.TemplateId.IsNotNull() && entity.Status == EnumContractTemplateStatus.Wait)
                     if (entity.Access.HasValue && entity.TemplateId.IsNotNull() && request.Values.IsNotNull())
                     {
                         entity.Status = EnumContractTemplateStatus.Completed;
                         entity.CompletedTime = DateTime.Now;
                     }
                 },
                 cancellationToken);

            await SyncElectronSignContractTemplate(entity);

            return entity.Id;
        }

        /// <summary>
@@ -87,14 +153,87 @@
        public async Task<int> Handle(SetIsDisabledContractTemplateCommand request, CancellationToken cancellationToken)
        {
            var logier = JwtUtils.GetCurrentLogier();
            return await request.SetIsDisabled<ContractTemplate>(q =>
            var q = rep.AsQueryable();
            if (logier.Type == EnumUserType.Enterprise)
            {
                if (logier.Type == EnumUserType.Enterprise)
                q = q.Where(it => it.EnterpriseId == logier.EnterpriseId);
            }
            var entities = await q
                .Where(it => request.Ids.Contains(it.Id) && it.IsDisabled != request.IsDisabled)
                .ToListAsync();
            foreach (var entity in entities)
            {
                entity.IsDisabled = request.IsDisabled;
            }
            var ids = entities.DistinctSelect(it => it.ElectronSignContractTemplateId.HasValue, it => it.ElectronSignContractTemplateId!.Value);
            if (ids.IsNotNull())
            {
                var result = await new DeleteContractTemplateInput
                {
                    q = q.Where(it => it.EnterpriseId == logier.EnterpriseId);
                    Ids = ids
                }.SendHttpAsync<DeleteContractTemplateInput, ElectronSignServerResult<object>>(EnumResourceHttpProvider.ElectronSignServerCustomer);
                if (result?.Success != true)
                {
                    throw Oops.Oh(EnumErrorCodeType.s510, result?.Message ?? "删除电子签合同模板异常");
                }
                return q;
            }, cancellationToken);
            }
            return entities.Count;
        }

        /// <summary>
        /// 同步电子签合同模板
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        private async Task SyncElectronSignContractTemplate(ContractTemplate entity)
        {
            if (entity.Status == EnumContractTemplateStatus.Completed)
            {
                var enterprise = await rep.Change<Enterprise>().AsQueryable()
                    .Include(it => it.EnterpriseAuth)
                    .Where(it => it.Id == entity.EnterpriseId)
                    .FirstOrDefaultAsync();
                if (enterprise == null) throw Oops.Oh(EnumErrorCodeType.s404, "企业");
                if (enterprise.EnterpriseAuth == null)
                {
                    enterprise.EnterpriseAuth = new EnterpriseAuth();
                }
                if (enterprise.EnterpriseAuth.ElectronSignEnterpriseId == null)
                {
                    var resultRegOrUpdateUser = await new RegOrUpdateUserInput
                    {
                        OutUserId = enterprise.Id.ToString(),
                        UserType = EnumElectronSignUserType.Personal,
                        EnterpriseName = enterprise.EnterpriseName,
                        SocietyCreditCode = enterprise.SocietyCreditCode,
                        Name = enterprise.EnterpriseAuth?.Name,
                        Identity = enterprise?.EnterpriseAuth?.Identity,
                        Mobile = enterprise?.EnterpriseAuth?.PhoneNumber
                    }.SendHttpAsync<RegOrUpdateUserInput, ElectronSignServerResult<Guid?>>(EnumResourceHttpProvider.ElectronSignServerCustomer);

                    if (resultRegOrUpdateUser?.Success == true)
                    {
                        enterprise!.EnterpriseAuth!.ElectronSignEnterpriseId = resultRegOrUpdateUser.Result;
                    }
                    else
                    {
                        throw Oops.Oh(EnumErrorCodeType.s510, resultRegOrUpdateUser?.Message ?? "注册电子签账号异常");
                    }
                }
                var result = await new CreateOrUpdateContractTemplateInput
                {
                    CustomerId = App.GetConfig<Guid>("ElectronSignServer:AppId"),
                    UserId = enterprise.EnterpriseAuth.ElectronSignEnterpriseId,
                    Supplier = (EnumElectronSignContractSupplier)entity.Access!,
                    Name = entity.Name,
                    TemplateCode = entity.TemplateId,
                    Values = entity.Values.Adapt<List<CreateOrUpdateContractTemplateValueInput>>()
                }.SendHttpAsync<CreateOrUpdateContractTemplateInput, ElectronSignServerResult<Guid>>(EnumResourceHttpProvider.ElectronSignServerCustomer);
                if (result?.Success == true)
                {
                    entity.ElectronSignContractTemplateId = result.Result;
                }
            }
        }
    }
}