feat:开发

sunpengfei

2025-08-28 1d2e9595487a774cd93697630774ff135ca6c11a

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

@@ -1,4 +1,5 @@
using FlexJobApi.Core;
using Azure.Core;
using FlexJobApi.Core;
using Furion;
using Furion.DatabaseAccessor;
using Furion.FriendlyException;
@@ -16,11 +17,17 @@
    /// 电子签回传
    /// </summary>
    public class ElectronSignCallbackCommandHandler(
            IRepository<User> repUser
            IRepository<User> repUser,
            IRepository<EnterpriseEmployeeContract> repEnterpriseEmployeeContract,
            IRepository<EnterpriseEmployee> repEnterpriseEmployee,
            IRepository<TaskInfoUser> repTaskInfoUser
        ) :
        IRequestHandler<ElectronSignCallbackCommand, bool>
    {
        private readonly IRepository<User> repUser = repUser;
        private readonly IRepository<EnterpriseEmployeeContract> repEnterpriseEmployeeContract = repEnterpriseEmployeeContract;
        private readonly IRepository<EnterpriseEmployee> repEnterpriseEmployee = repEnterpriseEmployee;
        private readonly IRepository<TaskInfoUser> repTaskInfoUser = repTaskInfoUser;

        /// <summary>
        /// 电子签回传
@@ -33,7 +40,116 @@
            var appId = App.GetConfig<Guid>("ElectronSignServer:AppId");
            if (appId != request.CustomerId)
                throw Oops.Oh(EnumErrorCodeType.s400, "无效的AppId");
            if (request.Action == "UserSign")
            switch (request.Action)
            {
                case "UserSign":
                    await UserFaceReal(request);
                    break;
                case "ContractSign":
                    await ContractSign(request);
                    break;
                default:
                    break;
            }
            return true;
        }

        private async Task ContractSign(ElectronSignCallbackCommand request)
        {
            if (request.Data is ElectronSignCallbackCommandContractSignModel data)
            {
                var contractId = data.OutContractId.ToGuid("无效的合同Id")!.Value;
                var contract = await repEnterpriseEmployeeContract.AsQueryable()
                    .Where(it => it.Id == contractId)
                    .FirstOrDefaultAsync();
                if (contract == null) throw Oops.Oh(EnumErrorCodeType.s404, "合同");
                var entity = await repEnterpriseEmployee.AsQueryable()
                    .Include(it => it.ContractTemplate)
                    .Where(it => it.Id == contract.EnterpriseEmployeeId)
                    .FirstOrDefaultAsync();
                if (entity == null) throw Oops.Oh(EnumErrorCodeType.s404, "灵工");
                if (entity.ContractTemplateId != contract.ContractTemplateId
                    || entity.UserSignContractStatus != contract.UserSignContractStatus
                    || entity.UserSignContractTime != contract.UserSignContractTime
                    || entity.EnterpriseSignContractStatus != contract.EnterpriseSignContractStatus
                    || entity.EnterpriseSignContractTime != contract.EnterpriseSignContractTime)
                {
                    throw Oops.Oh(EnumErrorCodeType.s510, "合同已失效");
                }
                if (entity.ContractTemplate.Access == EnumElectronSignAccess.BestSign)
                {
                    if (data.UserType == Core.Models.ElectronSignServer.PersonalUserReals.EnumElectronSignUserType.Personal)
                    {
                        if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Signing)
                        {
                            contract.UserSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                            contract.UserSignContractTime = DateTime.Now;
                        }
                        else if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Cancelled)
                        {
                            contract.UserSignContractStatus = EnumTaskUserSignContractStatus.Refuse;
                            contract.UserSignContractErrorMessage = request.Message;
                        }
                    }
                    else
                    {
                        if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Signing)
                        {
                            contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                            contract.EnterpriseSignContractTime = DateTime.Now;
                        }
                        else if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Cancelled)
                        {
                            contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Refuse;
                            contract.EnterpriseSignContractErrorMessage = request.Message;
                        }
                    }
                }
                else if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Cancelled)
                {
                    contract.UserSignContractStatus = EnumTaskUserSignContractStatus.Refuse;
                    contract.UserSignContractErrorMessage = request.Message;
                    contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Refuse;
                    contract.EnterpriseSignContractErrorMessage = request.Message;
                }
                if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Completed)
                {
                    contract.UserSignContractStatus = EnumTaskUserSignContractStatus.Effect;
                    if (contract.UserSignContractTime == null)
                    {
                        contract.UserSignContractTime = DateTime.Now;
                    }
                    contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Effect;
                    if (contract.EnterpriseSignContractTime == null)
                    {
                        contract.EnterpriseSignContractTime = DateTime.Now;
                    }
                    contract.ContractUrl = data.ContactUrl;
                }
                await repEnterpriseEmployeeContract.UpdateAsync(contract);

                entity.UserSignContractStatus = contract.UserSignContractStatus;
                entity.UserSignContractTime = contract.UserSignContractTime;
                entity.EnterpriseSignContractStatus = contract.EnterpriseSignContractStatus;
                entity.EnterpriseSignContractTime = contract.EnterpriseSignContractTime;
                entity.ContractUrl = contract.ContractUrl;
                await repEnterpriseEmployee.UpdateAsync(entity);

                var taskUsers = await repTaskInfoUser.AsQueryable()
                    .Where(it => it.EnterpriseEmployeeId == entity.Id && it.HireStatus == EnumTaskUserHireStatus.Pass && it.ArrangeStatus == null)
                    .ToListAsync();
                if (taskUsers.IsNotNull())
                {
                    foreach (var taskUser in taskUsers)
                    {
                        taskUser.ArrangeStatus = EnumTaskUserArrangeStatus.Wait;
                    }
                    await repTaskInfoUser.UpdateAsync(taskUsers);
                }
            }
        }

        private async Task UserFaceReal(ElectronSignCallbackCommand request)
            {
                var user = await repUser.AsQueryable()
                    .Include(it => it.UserAuth)
@@ -64,8 +180,6 @@
                        faceRealUrl: user.UserAuth.FaceRealUrl);
                    await repUser.UpdateAsync(user);
                }
            }
            return true;
        }
    }
}