feat:开发

sunpengfei

2025-09-02 2dfe3b8df9d01bb810224115522ba90da9b31f21

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

@@ -1,9 +1,11 @@
using FlexJobApi.Core;
using Azure.Core;
using FlexJobApi.Core;
using Furion;
using Furion.DatabaseAccessor;
using Furion.FriendlyException;
using MediatR;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -16,11 +18,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,39 +41,144 @@
            var appId = App.GetConfig<Guid>("ElectronSignServer:AppId");
            if (appId != request.CustomerId)
                throw Oops.Oh(EnumErrorCodeType.s400, "无效的AppId");
            if (request.Action == "UserSign")
            switch (request.Action)
            {
                var user = await repUser.AsQueryable()
                    .Include(it => it.UserAuth)
                    .Where(it => it.UserAuth.ElectronSignUserId == request.RelationId)
                    .FirstOrDefaultAsync();
                if (user == null)
                    throw Oops.Oh(EnumErrorCodeType.s404, "用户");
                if (request.Data is ElectronSignCallbackCommandUserSignModel data)
                {
                    if (user.Id != data.OutUserId)
                        throw Oops.Oh(EnumErrorCodeType.s404, "用户");
                    var enterpriseEmployees = request.Success
                        ? await repUser.Change<EnterpriseEmployee>().AsQueryable()
                            .Where(it => it.UserId == user.Id)
                            .ToListAsync()
                        : new List<EnterpriseEmployee>();
                    PersonalUserRealCommandHandler.PersonalReal(
                        request.Success == true
                        ? EnumPersonalUserRealStatus.Real
                        : EnumPersonalUserRealStatus.Fail,
                        EnumUserRealMethod.Face,
                        user,
                        enterpriseEmployees,
                        user.UserAuth.Name,
                        user.UserAuth.Identity,
                        user.UserAuth.IdentityImg,
                        user.UserAuth.IdentityBackImg,
                        faceRealUrl: user.UserAuth.FaceRealUrl);
                    await repUser.UpdateAsync(user);
                }
                case "UserSign":
                    await UserFaceReal(request);
                    break;
                case "ContractSign":
                    await ContractSign(request);
                    break;
                default:
                    break;
            }
            return true;
        }

        private async Task ContractSign(ElectronSignCallbackCommand request)
        {
            var data = ((JObject)request.Data).ToObject<ElectronSignCallbackCommandContractSignModel>()!;
            var contractId = data.OutContractId.ToGuid("无效的合同Id")!.Value;
            var contract = await repEnterpriseEmployeeContract.AsQueryable()
                .Include(it=>it.ContractTemplate)
                .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;
                        contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Wait;
                    }
                    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.Pass;
                if (contract.UserSignContractTime == null)
                {
                    contract.UserSignContractTime = DateTime.Now;
                }
                contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                if (contract.EnterpriseSignContractTime == null)
                {
                    contract.EnterpriseSignContractTime = DateTime.Now;
                }
                contract.ContractUrl =  AliyunOSSUtils.Upload("Contact", data.ContactUrl, $"{contract.ContractTemplate.Name}.pdf").Url;
            }
            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)
                .Where(it => it.UserAuth.ElectronSignUserId == request.RelationId)
                .FirstOrDefaultAsync();
            if (user == null)
                throw Oops.Oh(EnumErrorCodeType.s404, "用户");
            var data = ((JObject)request.Data).ToObject<ElectronSignCallbackCommandUserSignModel>()!;
            if (user.Id != data.OutUserId)
                throw Oops.Oh(EnumErrorCodeType.s404, "用户");
            var enterpriseEmployees = request.Success
                ? await repUser.Change<EnterpriseEmployee>().AsQueryable()
                    .Where(it => it.UserId == user.Id)
                    .ToListAsync()
                : new List<EnterpriseEmployee>();
            PersonalUserRealCommandHandler.PersonalReal(
                request.Success == true
                ? EnumPersonalUserRealStatus.Real
                : EnumPersonalUserRealStatus.Fail,
                EnumUserRealMethod.Face,
                user,
                enterpriseEmployees,
                user.UserAuth.Name,
                user.UserAuth.Identity,
                user.UserAuth.IdentityImg,
                user.UserAuth.IdentityBackImg,
                faceRealUrl: user.UserAuth.FaceRealUrl);
            await repUser.UpdateAsync(user);
        }
    }
}