OA2023/OASystem/OASystem.Infrastructure/Repositories/PersonnelModule/TaskAllocationRepository.cs

using AutoMapper;
using EnumsNET;
using Microsoft.VisualBasic;
using NPOI.SS.Formula.Functions;
using OASystem.Domain;
using OASystem.Domain.Dtos.PersonnelModule;
using OASystem.Domain.Entities.Groups;
using OASystem.Domain.Entities.PersonnelModule;
using OASystem.Domain.Entities.System;
using OASystem.Domain.ViewModels.PersonnelModule;
using OASystem.Infrastructure.Logging;
using Org.BouncyCastle.Asn1.Tsp;
using Org.BouncyCastle.Ocsp;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Text;
using System.Text.Json.Serialization;
using System.Threading.Tasks;

namespace OASystem.Infrastructure.Repositories.PersonnelModule
{
    /// <summary>
    /// 任务分配
    /// 仓库
    /// </summary>
    public class TaskAllocationRepository : BaseRepository<Pm_TaskAllocation, TaskAllocationView>
    {
        private readonly IMapper _mapper;
        private Result _result;
        private readonly ITaskTextFileLogger _taskTextFileLogger;

        public TaskAllocationRepository(SqlSugarClient sqlSugar, IMapper mapper, ITaskTextFileLogger taskTextFileLogger)
            : base(sqlSugar)
        {
            _mapper = mapper;
            _result = new Result() { Code = -1, Msg = "操作失败!" };
            _taskTextFileLogger = taskTextFileLogger;
        }

        /// <summary>
        /// 任务操作权限(任务创建人才可以进行操作)
        /// </summary>
        /// <param name="taskAllocation"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        public TaskOperationPerm TaskOperationAudit(Pm_TaskAllocation taskAllocation, int userId)
        {
            TaskOperationPerm taskOperationPrem = new TaskOperationPerm();
            if (taskAllocation.CreateUserId == userId)
            {
                taskOperationPrem.IsAddPerm = true;
                taskOperationPrem.IsDelPerm = true;
                taskOperationPrem.IsStopPerm = true;
                taskOperationPrem.IsComfirmPerm = true;
                taskOperationPrem.IsScorePerm = true;
            }

            return taskOperationPrem;
        }

        /// <summary>
        /// 基础数据源
        /// </summary>
        /// <returns></returns>
        public async Task<Result> Init(int portType, int userId)
        {
            if (portType == 1 || portType == 2 || portType == 3)
            {
                if (userId < 1)
                {
                    _result.Msg = string.Format("请传入有效的UserId参数!");
                    return _result;
                }

                //任务类型
                var taskTypeInfos = _sqlSugar.Queryable<Sys_SetData>()
                    .Where(x => x.STid == 127 && x.IsDel == 0)
                    .Select(x => new ValueInfo { Id = x.Id, Name = x.Name })
                    .ToList();

                //任务名称 
                var taskNameInfos = _sqlSugar.Queryable<Pm_TaskAllocation, Pm_TaskRelevanceUser>((ta, taru) => new JoinQueryInfos(JoinType.Left, ta.Id == taru.TAId))
                    .Where((ta, taru) => ta.IsDel == 0 && taru.IsDel == 0)
                    .Where((ta, taru) => ta.CreateUserId == userId || taru.UserId == userId)
                    .OrderByDescending((ta, taru) => ta.CreateTime)
                    .Select((ta, taru) => new
                    {
                        ta.TaskName,
                        ta.CreateTime 
                    })
                    .ToList()
                    .DistinctBy(x => x.TaskName)
                    .Select(x => x.TaskName) 
                    .ToList();

                //团组名称
                var groupNameInfos = _sqlSugar.Queryable<Grp_DelegationInfo>()
                    .Where(it => it.IsDel == 0)
                    .OrderByDescending(it => it.VisitStartDate)
                    .Select(it => new ValueInfo { Id = it.Id, Name = it.TeamName })
                    .ToList();
                groupNameInfos.Insert(0, new ValueInfo() { Id = -1, Name = "未选择" });

                //部门名称
                var departmentNameInfos = _sqlSugar.Queryable<Sys_Users, Sys_Department>((u, d) => new JoinQueryInfos(JoinType.Left, u.DepId == d.Id))
                    .Where((u, d) => u.Id == userId)
                    .Select((u, d) => new ValueInfo() { Id = d.Id, Name = d.DepName })
                    .First();

                //执行任务人员信息 1 公司总经理/副总 可分配 所有人的任务 2 公司 部门经理/主管 可分配 部门下的人员的任务
                var executeTaskUserInfos = new List<ExecuteTaskUserInfo>();
                var taskOpertionAudit = new TaskOperationPerm();

                var taskAudits = _sqlSugar.Queryable<Pm_TaskJobRelevancy>().Where(it => it.IsDel == 0 && it.PrimaryUserId == userId).ToList();
                var taslPerm = taskAudits.Any();
                if (!taskAudits.Any())
                {
                    var taskUserIds = _sqlSugar.Queryable<Pm_TaskJobRelevancy>().Where(it => it.IsDel == 0 && it.SubUserId == userId).Select(x => x.PrimaryUserId).ToList();
                    if (taskUserIds.Any())
                    {
                        taskAudits = _sqlSugar.Queryable<Pm_TaskJobRelevancy>().Where(it => it.IsDel == 0 && taskUserIds.Contains(it.PrimaryUserId)).ToList();
                    }
                }

                if (taskAudits.Any())
                {
                    //任务权限
                    if (taslPerm)
                    {
                        taskOpertionAudit.IsAddPerm = true;
                        taskOpertionAudit.IsDelPerm = true;
                        taskOpertionAudit.IsStopPerm = true;
                    }

                    var userIds = taskAudits.Select(it => it.SubUserId).ToList();
                    string userSql = string.Format(@"Select u.Id,u.CnName As Name,c.CompanyName,
                                                         d.DepName As DepartmentName,jp.JobName
                                                         From Sys_Users u
                                                         Left Join Sys_Company c On u.CompanyId = c.Id
                                                         Left Join Sys_Department d On u.DepId = d.Id
                                                         Left Join Sys_JobPost jp On u.JobPostId = jp.Id
                                                         Where u.IsDel = 0 ");
                    executeTaskUserInfos = _sqlSugar.SqlQueryable<ExecuteTaskUserInfo>(userSql).Where(it => userIds.Contains(it.Id)).ToList();

                }

                var view = new InitView()
                {
                    OperationPerm = taskOpertionAudit,
                    TaskNameInfos = taskNameInfos,
                    ExecuteTaskUserInfos = executeTaskUserInfos,
                    GroupNameInfos = groupNameInfos,
                    DepartmentNameInfo = departmentNameInfos,
                    TaskTypeInfos = taskTypeInfos
                };
                _result.Code = 0;
                _result.Data = view;
            }
            else _result.Msg = string.Format("请传入有效的PortType参数!");

            return _result;
        }

        /// <summary>
        /// 任务发布者验证
        /// </summary>
        /// <returns></returns>
        public async Task<(bool isTaskPublisher, List<int> userIds)> ValidateTaskPublisher(int userId)
        {
            var taskAudits = await _sqlSugar.Queryable<Pm_TaskJobRelevancy>().Where(it => it.IsDel == 0 && it.PrimaryUserId == userId).ToListAsync();
            
            if (taskAudits.Any())
            {
                return (true, taskAudits.Select(x => x.SubUserId).ToList());
            }

            return (false, new List<int>());
        }


        /// <summary>
        /// 任务指派
        /// 详情
        /// </summary>
        /// <param name="portType"></param>
        /// <param name="Id"></param>
        /// <returns></returns>
        public async Task<Result> Details(int portType, int Id)
        {
            if (Id < 1)
            {
                _result.Msg = string.Format("请传入有效的Id参数!");
                return _result;
            }

            if (portType == 1 || portType == 2 || portType == 3)
            {
                //团组名称
                var _groupNameInfos = _sqlSugar.Queryable<Grp_DelegationInfo>().Where(it => it.IsDel == 0)
                    .OrderByDescending(it => it.VisitDate)
                    .Select(it => new ValueInfo { Id = it.Id, Name = it.TeamName })
                    .ToList();
                _groupNameInfos.Insert(0, new ValueInfo() { Id = -1, Name = "未选择" });

                //部门名称
                var _departmentNameInfos = _sqlSugar.Queryable<Sys_Department>()
                    .Select(d => new ValueInfo() { Id = d.Id, Name = d.DepName })
                    .ToList();

                //用户名称
                var _userNameInfos = _sqlSugar.Queryable<Sys_Users>()
                    .Select(d => new ValueInfo() { Id = d.Id, Name = d.CnName })
                    .ToList();

                var _view = _sqlSugar.Queryable<Pm_TaskAllocation>()
                    .Where(it => it.IsDel == 0 && it.Id == Id)
                    .Select(it => new TaskDetailsView
                    {
                        Id = it.Id,
                        DiId = it.DiId,
                        DepId = it.DepId,
                        CreateUserId = it.CreateUserId,
                        CreateTime = it.CreateTime,
                        TaskName = it.TaskName,
                        TaskContent = it.TaskContent,
                        TaskType = it.TaskType,
                        TaskPriority = it.TaskPriority,
                        PredictBeginTime = it.PredictBeginTime,
                        PredictEndTime = it.PredictEndTime,
                        IsIntoPerformance = it.IsIntoPerformance,
                        Remark = it.Remark,
                    })
                    .First();
                if (_view != null)      
                {
                    var taskUserDetailsViews = _sqlSugar.Queryable<Pm_TaskRelevanceUser>()
                        .Where(it => it.IsDel == 0 && it.TAId == _view.Id)
                        .Select(it => new TaskUserDetailsView
                        {
                            Id = it.Id,
                            TAId = it.TAId,
                            UserId = it.UserId,
                            BeginTime = it.BeginTime,
                            OverTime = it.OverTime,
                            TaskStatus = it.TaskStatus,
                            Cause = it.Cause,
                            Remark = it.Remark
                        })
                        .ToList();
                    _view.UserTaskInfos = taskUserDetailsViews;

                    _result.Data = _view;
                    _result.Code = 0;
                    _result.Msg = "查询成功!";
                }
            }
            else
            {
                _result.Msg = string.Format("请传入有效的PortType参数!");
            }
            return _result;
        }

        /// <summary>
        /// 编辑权限验证
        /// </summary>
        public (bool CanEdit, string Message) EditPerm(int taskId, int currentUserId)
        {
            var taskInfo = _sqlSugar.Queryable<Pm_TaskAllocation>().First(x => x.Id == taskId && x.IsDel == 0);

            if (taskInfo == null)
                return (false, "任务不存在!");

            if (taskInfo.CreateUserId != currentUserId)
                return (false, "当前任务仅创建人可编辑!");

            // 定义结束状态集合
            var UneditableStatuses = new List<TaskEnum>
            {
                TaskEnum.UnFinished,
                TaskEnum.Finished,
                TaskEnum.TaskStop
            };

            if (UneditableStatuses.Contains(taskInfo.Status))
                return (false,
                    taskInfo.Status switch
                    {
                        TaskEnum.UnFinished => "当前任务状态为“未完成”结束状态，不可编辑!",
                        TaskEnum.Finished => "当前任务状态为“已完成”结束状态，不可编辑!",
                        TaskEnum.TaskStop => "当前任务状态为“任务终止”结束状态，不可编辑!",
                        _ => "当前任务状态不可编辑!"
                    });

            return (true, string.Empty);
        }

        /// <summary>
        /// 任务终止权限验证
        /// </summary>
        public (bool CanEdit, string Message) TaskStopPerm(int taskId, int currentUserId)
        {
            var taskInfo = _sqlSugar.Queryable<Pm_TaskAllocation>().First(x => x.Id == taskId && x.IsDel == 0);

            if (taskInfo == null)
                return (false, "任务不存在!");

            if (taskInfo.CreateUserId != currentUserId)
                return (false, "只有创建人可以终止任务!");

            // 2. 检查当前状态是否允许终止
            if (taskInfo.Status == TaskEnum.TaskStop)
            {
                return (false, "任务已终止，无需重复操作!");
            }

            // 3. 定义不允许终止的状态
            var cannotStopStatuses = new List<TaskEnum>
            {
                TaskEnum.Finished,
                TaskEnum.UnFinished
            };

            if (cannotStopStatuses.Contains(taskInfo.Status))
            {
                var statusDesc = taskInfo.Status switch
                {
                    TaskEnum.Finished => "已完成",
                    TaskEnum.UnFinished => "未完成",
                    _ => "未知状态"
                };
                return (false, $"任务已{statusDesc}，不能终止!");
            }

            // 安全解析时间
            var predictBeginTime = SafeParse(taskInfo.PredictBeginTime);
            var predictEndTime = SafeParse(taskInfo.PredictEndTime);
            var currTime = DateTime.Now;

            // 时间范围检查
            if (predictBeginTime.HasValue && currTime < predictBeginTime.Value)
                return (false, "任务尚未开始，不能终止!");

            if (predictEndTime.HasValue && currTime > predictEndTime.Value.AddHours(24))
                return (false, "任务已超过预计结束时间24小时，不能终止!");

            // 检查创建时间（防止恶意创建后立即终止）
            if ((currTime - taskInfo.CreateTime).TotalMinutes < 5)
            {
                return (false, "任务创建时间不足5分钟，请先执行一段时间才可执行任务终止!");
            }

            return (true, string.Empty);
        }

        /// <summary>
        /// 任务知晓权限验证
        /// </summary>
        public (bool CanEdit, string Message) TaskHavePerm(int taskId, int currentUserId)
        {
            var taskInfo = _sqlSugar.Queryable<Pm_TaskAllocation>().First(x => x.Id == taskId && x.IsDel == 0);

            if (taskInfo == null)
                return (false, "任务不存在!");

            var taskerInfo = _sqlSugar.Queryable<Pm_TaskRelevanceUser>().First(x => x.TAId == taskId && x.UserId == currentUserId && x.IsDel == 0);
            if (taskerInfo == null)
                return (false, "任务指派单不存在!");

            if (taskerInfo.UserId != currentUserId)
                return (false, "只有任务归属者可设置“已知晓”状态!");

            // 检查当前状态是否设置已知晓
            //if (taskerInfo.TaskStatus == TaskerEnum.HaveKnown)
            //{
            //    return (false, "当前状态已设置，无需重复操作!");
            //}

            //if (taskInfo.Status == TaskEnum.UnFinished)
            //{
            //    return (false, "当前状态 “未完成”，不可设置该状态!");
            //}
            //if (taskInfo.Status == TaskEnum.Finished)
            //{
            //    return (false, "当前状态 “已完成”，不可设置该状态!");
            //}

            return (true, string.Empty);
        }

        /// <summary>
        /// 安全解析字符串为 DateTime?
        /// </summary>
        public static DateTime? SafeParse(string dateTimeString)
        {
            if (string.IsNullOrWhiteSpace(dateTimeString))
                return null;

            if (DateTime.TryParse(dateTimeString, out DateTime result))
                return result;

            return null;
        }

        /// <summary>
        /// Add Or Edit
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<Result> AddOrEdit(TaskAllocationAddOrEditDto dto)
        {
            if (dto.PortType == 1 || dto.PortType == 2 || dto.PortType == 3)
            {
                if (dto.UserIds.Count < 1)
                {
                    _result.Msg = string.Format("指派人员不能为空!");
                    return _result;
                }

                #region 参数处理
                var _TaskAllocation = new Pm_TaskAllocation();
                var _TaskRelevanceUsers = new List<Pm_TaskRelevanceUser>();
                _TaskAllocation = _mapper.Map<Pm_TaskAllocation>(dto);
                _TaskAllocation.CreateUserId = dto.UserId;
                _TaskAllocation.Status = TaskEnum.NotStarted;
                foreach (var item in dto.UserIds)
                {
                    _TaskRelevanceUsers.Add(new Pm_TaskRelevanceUser() {
                        TAId = dto.Id,
                        UserId = item,
                        TaskStatus = TaskEnum.NotStarted,
                        CreateUserId = dto.UserId,
                    });
                }

                #endregion

                var createUserName = _sqlSugar.Queryable<Sys_Users>().Where(x => x.Id == dto.UserId).First()?.CnName ?? "-";

                if (dto.Id == 0) //添加
                {
                    //// 1 按 任务名称 查询重
                    //Pm_TaskAllocation taskAllocation1 = await _sqlSugar.Queryable<Pm_TaskAllocation>().Where(it => it.IsDel == 0 && it.TaskName.Equals(_TaskAllocation.TaskName)).FirstAsync();
                    //if (taskAllocation1 != null)
                    //{
                    //    _result.Msg = string.Format("任务名称重复,请重命名!");
                    //    return _result;
                    //}

                    _sqlSugar.BeginTran();

                    int addId = await _sqlSugar.Insertable<Pm_TaskAllocation>(_TaskAllocation).ExecuteReturnIdentityAsync();
                    if (addId < 1)
                    {
                        _sqlSugar.RollbackTran();
                        _result.Msg = string.Format("任务发布失败!"); 
                        _taskTextFileLogger.LogInformation("任务新增[失败]，任务名称：{TaskName}，创建人：{CreateUserName}", _TaskAllocation.TaskName, createUserName);
                        return _result;
                    }

                    foreach (var item in _TaskRelevanceUsers)
                    {
                        item.TAId = addId;
                    }

                    int addSub = await _sqlSugar.Insertable<Pm_TaskRelevanceUser>(_TaskRelevanceUsers).ExecuteCommandAsync();

                    if (addSub < 1)
                    {
                        _sqlSugar.RollbackTran();
                        _result.Msg = string.Format("任务发布失败!");
                        _taskTextFileLogger.LogInformation("任务新增[失败]，任务名称：{TaskName}，创建人：{CreateUserName}", _TaskAllocation.TaskName, createUserName);
                        return _result;
                    }

                    _result.Code = 0;
                    _result.Msg = "添加成功!";
                    _taskTextFileLogger.LogInformation("任务新增[成功]，任务名称：{TaskName}，创建人：{CreateUserName}", _TaskAllocation.TaskName, createUserName);

                    _sqlSugar.CommitTran();
                }
                else if (dto.Id > 0) //修改
                {
                    _sqlSugar.BeginTran();

                   
                    #region 编辑验证 1. 仅创建者可以修改 

                    var taskInfo = await _sqlSugar
                        .Queryable<Pm_TaskAllocation>()
                        .Where(it => it.Id == dto.Id && it.IsDel == 0)
                        .FirstAsync();
                    if (taskInfo != null)
                    {
                        (bool isEdit, string msg) = EditPerm(dto.Id, dto.UserId);

                        if (!isEdit)
                        {
                            _result.Msg = msg;
                            _taskTextFileLogger.LogInformation("任务编辑[无操作权限]，任务名称：{TaskName}，创建人：{CreateUserName}", _TaskAllocation.TaskName, createUserName);

                            _sqlSugar.RollbackTran();
                            return _result;
                        }
                    }

                    #endregion
                    var mainTaskInfoOld = new Pm_TaskAllocation() {
                        DepId = taskInfo.DepId,
                        DiId = taskInfo.DiId,
                        TaskType = taskInfo.TaskType,
                        TaskPriority = taskInfo.TaskPriority,
                        TaskName = taskInfo.TaskName,
                        TaskContent = taskInfo.TaskContent,
                        PredictBeginTime = taskInfo.PredictBeginTime,
                        PredictEndTime = taskInfo.PredictEndTime,
                        IsIntoPerformance = taskInfo.IsIntoPerformance
                    };

                   int updateStatus1 = await _sqlSugar.Updateable<Pm_TaskAllocation>(_TaskAllocation)
                        .UpdateColumns(it => new
                        {
                            it.DepId,
                            it.DiId,
                            it.TaskType,
                            it.TaskPriority,
                            it.TaskName,
                            it.TaskContent,
                            it.PredictBeginTime,
                            it.PredictEndTime,
                            it.IsIntoPerformance,
                        })
                        .Where(it => it.Id == _TaskAllocation.Id)
                        .ExecuteCommandAsync();
                    if (updateStatus1 < 1)
                    {
                        _sqlSugar.RollbackTran();
                        _result.Msg = string.Format("任务编辑失败!");
                        _taskTextFileLogger.LogInformation("任务编辑[失败]，任务名称：{TaskName}，创建人：{CreateUserName}", _TaskAllocation.TaskName, createUserName);

                        return _result;
                    }

                    List<int> selectUserId = new List<int>();
                    selectUserId = await _sqlSugar.Queryable<Pm_TaskRelevanceUser>()
                    .Where(it => it.IsDel == 0 && it.TAId == _TaskAllocation.Id)
                    .Select(it => it.UserId)
                    .ToListAsync();

                    if (selectUserId.Count < 1)
                    {
                        int addSub1 = await _sqlSugar.Insertable<Pm_TaskRelevanceUser>(_TaskRelevanceUsers).ExecuteCommandAsync();
                        if (addSub1 < 1)
                        {
                            _sqlSugar.RollbackTran();
                            _result.Msg = string.Format("任务编辑失败!");
                            _taskTextFileLogger.LogInformation("任务编辑[失败]，任务名称：{TaskName}，创建人：{CreateUserName}", _TaskAllocation.TaskName, createUserName);

                            return _result;
                        }
                    }
                    else
                    {
                        List<int> SelectUserIdDiff = new List<int>(); //select 差集
                        SelectUserIdDiff = selectUserId.Except(dto.UserIds).ToList();
                        if (SelectUserIdDiff.Count > 0) //删除
                        {
                            List<Pm_TaskRelevanceUser> _TaskRelevanceUsers1 = new List<Pm_TaskRelevanceUser>();

                            _TaskRelevanceUsers1 = await _sqlSugar.Queryable<Pm_TaskRelevanceUser>()
                                .Where(it => it.IsDel == 0 &&
                                            it.TAId == _TaskAllocation.Id &&
                                            SelectUserIdDiff.Contains(it.UserId))
                                .ToListAsync();
                            if (_TaskRelevanceUsers1.Count > 0)
                            {
                                foreach (var item in _TaskRelevanceUsers1)
                                {
                                    item.IsDel = 1;
                                }

                                var updateIsDel = await _sqlSugar.Updateable(_TaskRelevanceUsers1)
                                    .UpdateColumns(it => it.IsDel)
                                    .WhereColumns(it => new { it.Id, it.TAId })
                                    .ExecuteCommandAsync();
                                if (updateIsDel < 1)
                                {
                                    _sqlSugar.RollbackTran();
                                    _result.Msg = string.Format("任务编辑失败!");
                                    return _result;
                                }
                            }
                        }

                        List<int> ParaUserIdDiff = new List<int>(); //para 差集
                        ParaUserIdDiff = dto.UserIds.Except(selectUserId).ToList();

                        if (ParaUserIdDiff.Count > 0)
                        {
                            List<Pm_TaskRelevanceUser> _TaskRelevanceUsers1 = new List<Pm_TaskRelevanceUser>();
                            _TaskRelevanceUsers1 = _TaskRelevanceUsers.Where(it => ParaUserIdDiff.Contains(it.UserId)).ToList();
                            if (_TaskRelevanceUsers1.Count > 0)
                            {
                                int addSub1 = await _sqlSugar.Insertable<Pm_TaskRelevanceUser>(_TaskRelevanceUsers1).ExecuteCommandAsync();
                                if (addSub1 < 1)
                                {
                                    _sqlSugar.RollbackTran();
                                    _result.Msg = string.Format("任务编辑失败!");
                                    _taskTextFileLogger.LogInformation("任务编辑[失败]，任务名称：{TaskName}，创建人：{CreateUserName}", _TaskAllocation.TaskName, createUserName);

                                    return _result;
                                }
                            }
                        }
                    }

                    var mainTaskInfoNew = new Pm_TaskAllocation()
                    {
                        DepId = _TaskAllocation.DepId,
                        DiId = _TaskAllocation.DiId,
                        TaskType = _TaskAllocation.TaskType,
                        TaskPriority = _TaskAllocation.TaskPriority,
                        TaskName = _TaskAllocation.TaskName,
                        TaskContent = _TaskAllocation.TaskContent,
                        PredictBeginTime = _TaskAllocation.PredictBeginTime,
                        PredictEndTime = _TaskAllocation.PredictEndTime,
                        IsIntoPerformance = _TaskAllocation.IsIntoPerformance
                    }; ;

                    /*
                     * 发送消息
                     */
                    _result.Code = 0;
                    _result.Msg = "编辑成功!";
                    var changeMsg = ChangeMsg(mainTaskInfoOld, mainTaskInfoNew);

                    _taskTextFileLogger.LogInformation("任务完成设置[成功]，任务名称：{TaskName}，操作者：{OperatorName}{ChangeMsg}", _TaskAllocation.TaskName, createUserName, changeMsg);

                    _sqlSugar.CommitTran();
                }
                else _result.Msg = string.Format("请传入有效的Id参数!");
            }
            else _result.Msg = string.Format("请传入有效的PortType参数!");

            return _result;
        }

        /// <summary>
        /// 任务归属人状态 Items
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<Result> TaskerDetails(int id)
        {
            if (id < 1)
            {
                _result.Msg = string.Format("请传入有效的Id参数!");
                return _result;
            }

            string sql = string.Format(@"Select tau.Id,u.CnName As UserName,tau.BeginTime,tau.OverTime,tau.TaskStatus,
												 tau.Cause,tau.Score,tau.Remark As ScoreRemark,tau.CreateUserId As TaskCreateUserId
												 From Pm_TaskRelevanceUser tau 
												 Left Join Sys_Users u On tau.UserId = u.Id
												 Where tau.IsDel = 0 And  tau.TAId = {0}", id);

            var data = await _sqlSugar.SqlQueryable<TaskerDetailsView>(sql).ToListAsync();

            _result.Data = data;
            _result.Msg = string.Format("操作成功!");
            _result.Code = 0;

            return _result;
        }

        /// <summary>
        /// 任务归属人状态
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<Result> TaskerStatus(int id)
        {
            if (id < 1)
            {
                _result.Msg = string.Format("请传入有效的Id参数!");
                return _result;
            }

            var data1 = await _sqlSugar.Queryable<Pm_TaskRelevanceUser>().Where(it => it.IsDel == 0 && it.Id == id).FirstAsync();
            if (data1 == null)
            {
                _result.Msg = string.Format("该任务不存在!");
                return _result;
            }
            var data2 = await _sqlSugar.Queryable<Pm_TaskAllocation>().Where(it => it.IsDel == 0 && it.Id == data1.TAId).FirstAsync();

            _sqlSugar.BeginTran();

            var update1 = await _sqlSugar.Updateable<Pm_TaskRelevanceUser>()
                                         .SetColumns(it => it.TaskStatus == TaskEnum.UnderWay)
                                         .ExecuteCommandAsync();
            if (update1 < 1)
            {
                _result.Msg = string.Format("操作失败!");
                return _result;
            }
            _result.Msg = string.Format("操作成功!");
            _result.Code = 0;
            _sqlSugar.CommitTran();


            return _result;
        }

        /// <summary>
        /// 任务归属人设置开始状态
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<Result> TaskerSetStartStatus(int userId, int id)
        {
            if (id < 1)
            {
                _result.Msg = string.Format("请传入有效的Id参数!");
                return _result;
            }
            //状态限制
            var selectData = await _sqlSugar.Queryable<Pm_TaskRelevanceUser>().Where(it => it.IsDel == 0 && it.UserId == userId && it.TAId == id).FirstAsync();
            if (selectData == null)
            {
                _result.Msg = string.Format("该任务不在!");
                return _result;
            }
            if (selectData.TaskStatus >= TaskEnum.UnderWay)
            {
                _result.Msg = string.Format("该任务已知晓，不可重复设置!");
                return _result;
            }

            _sqlSugar.BeginTran();
            var update1 = await _sqlSugar.Updateable<Pm_TaskRelevanceUser>()
                                         .SetColumns(it => it.TaskStatus == TaskEnum.UnderWay)
                                         .SetColumns(it => it.BeginTime == DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"))
                                         .Where(it => it.TAId == id)
                                         .Where(it => it.UserId == userId )
                                         .ExecuteCommandAsync();
            if (update1 < 1)
            {
                _result.Msg = string.Format("操作失败!");
                _sqlSugar.RollbackTran();
                return _result;
            }
            var update2 = await _sqlSugar.Updateable<Pm_TaskAllocation>()
                                        .SetColumns(it => it.Status == TaskEnum.UnderWay)
                                        .Where(it => it.Id == id)
                                        .ExecuteCommandAsync();
            if (update2 < 1)
            {
                _result.Msg = string.Format("操作失败!");
                _sqlSugar.RollbackTran();
                return _result;
            }

            _sqlSugar.CommitTran();
            _result.Msg = string.Format("操作成功!");
            _result.Code = 0;

            return _result;
        }

        /// <summary>
        /// 任务归属人设置完成状态
        /// 1.待审核
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<Result> TaskerSetOverStatus(int userId, int id)
        {
            if (id < 1)
            {
                _result.Msg = string.Format("请传入有效的Id参数!");
                return _result;
            }

            //状态限制
            var selectData = await _sqlSugar.Queryable<Pm_TaskRelevanceUser>().Where(it => it.IsDel == 0 && it.UserId == userId && it.TAId == id).FirstAsync();
            if (selectData == null)
            {
                _result.Msg = string.Format("该任务不在!");
                return _result;
            }
            
            if (selectData.TaskStatus >= TaskEnum.WaitConfirm)
            {
                _result.Msg = string.Format("该任务已提交待审核状态,不可重复提交!");
                return _result;
            }
            _sqlSugar.BeginTran();
            var update1 = await _sqlSugar.Updateable<Pm_TaskRelevanceUser>()
                                         .SetColumns(it => it.TaskStatus == TaskEnum.WaitConfirm)
                                         .SetColumns(it => it.OverTime == DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"))
                                         .Where(it => it.TAId == id)
                                         .Where(it => it.UserId == userId)
                                         .ExecuteCommandAsync();
            if (update1 < 1)
            {
                _result.Msg = string.Format("操作失败!");
                _sqlSugar.RollbackTran();
                return _result;
            }
            var update2 = await _sqlSugar.Updateable<Pm_TaskAllocation>()
                                        .SetColumns(it => it.Status == TaskEnum.UnderWay)
                                        .Where(it => it.Id == id)
                                        .ExecuteCommandAsync();
            if (update2 < 1)
            {
                _result.Msg = string.Format("操作失败!");
                _sqlSugar.RollbackTran();
                return _result;
            }

            _sqlSugar.CommitTran();
            _result.Msg = string.Format("操作成功!");
            _result.Code = 0;

            return _result;
        }

        /// <summary>
        /// 设置任务知晓
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<Result> TaskSetHaveStatus(int id,int userId)
        {
            if (id < 1)
            {
                _result.Msg = string.Format("请传入有效的Id参数!");
                return _result;
            }

            //状态校验
            (bool havePerm, string msg3) = TaskHavePerm(id, userId);
            if (!havePerm)
            {
                _result.Msg = msg3;
                return _result;
            }

            _sqlSugar.BeginTran();
            var taskName = await _sqlSugar.Queryable<Pm_TaskAllocation>().Where(it => it.IsDel == 0 && it.Id == id).Select(it => it.TaskName).FirstAsync();
            var operatorName = await _sqlSugar.Queryable<Sys_Users>().Where(it => it.IsDel == 0 && it.Id == userId).Select(it => it.CnName).FirstAsync();
            var update1 = await _sqlSugar.Updateable<Pm_TaskRelevanceUser>()
                .SetColumns(it => it.TaskStatus == TaskEnum.UnderWay)
                .Where(it => it.TAId == id && it.UserId == userId)
                .ExecuteCommandAsync();
            if (update1 < 1)
            {
                _result.Msg = string.Format("操作失败!");

                _taskTextFileLogger.LogInformation("任务知晓设置[失败]，任务名称：{TaskName}，操作者：{OperatorName}", taskName, operatorName);

                _sqlSugar.RollbackTran();
                return _result;
            }

            var update2 = await _sqlSugar.Updateable<Pm_TaskAllocation>()
                .SetColumns(it => it.Status == TaskEnum.UnderWay)
                .Where(it => it.Id == id)
                .ExecuteCommandAsync();
            if (update2 < 1)
            {
                _result.Msg = string.Format("操作失败!");
                _taskTextFileLogger.LogInformation("任务知晓设置[失败]，任务名称：{TaskName}，操作者：{OperatorName}", taskName, operatorName);
                _sqlSugar.RollbackTran();
                return _result;
            }

            _result.Msg = string.Format("操作成功!");
            _taskTextFileLogger.LogInformation("任务知晓设置[成功]，任务名称：{TaskName}，操作者：{OperatorName}", taskName, operatorName);
            _result.Code = 0;
            _sqlSugar.CommitTran();

            return _result;
        }
        
        /// <summary>
        /// 设置任务审批状态
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public Result TaskSetAuditStatus(int id,int userId,string overTime,string remark)
        {
            if (id < 1)
            {
                _result.Msg = string.Format("请传入有效的任务关联ID!");
                return _result;
            }

            // 实际完成时间验证
            // 验证完成时间格式
            if (!DateTime.TryParse(overTime,out DateTime overDt))
            {
                _result.Msg = string.Format("实际完成时间格式不正确，正确时间格式为: yyyy-MM-dd HH:mm:ss");
                return _result;
            }

            // 验证时间合理性（不能是未来时间）
            if (overDt > DateTime.Now.AddMinutes(5)) // 允许5分钟内的未来时间（考虑时差）
            {
                _result.Msg = string.Format("实际完成时间不能是未来时间!");
                return _result;
            }

            _sqlSugar.BeginTran();

            var taskName =  _sqlSugar.Queryable<Pm_TaskAllocation>().Where(it => it.IsDel == 0 && it.Id == id).Select(it => it.TaskName).First();
            var operatorName =  _sqlSugar.Queryable<Sys_Users>().Where(it => it.IsDel == 0 && it.Id == userId).Select(it => it.CnName).First();

            try
            {
                //状态验证
                var subTaskInfo = _sqlSugar.Queryable<Pm_TaskRelevanceUser>()
                    .Where(it => it.IsDel == 0 && it.TAId == id)
                    .First();
                if (subTaskInfo == null)
                {
                    _result.Msg = string.Format("该任务关联信息不存在!");
                    return _result;
                }
                int mainTaskId = subTaskInfo.TAId;
                int taskerId = subTaskInfo.Id;

                //只有创建人可以审批完成状态
                if (subTaskInfo.CreateUserId != userId)
                {
                    _result.Msg = string.Format("只有任务创建者可审批'已完成'状态!");
                    _taskTextFileLogger.LogInformation("任务完成设置[尝试审批]，任务名称：{TaskName}，操作者：{OperatorName}", taskName, operatorName);
                    return _result;
                }

                //不可重复设置状态
                //if (subTaskInfo.TaskStatus == TaskerEnum.Finished)
                //{
                //    _result.Msg = string.Format("“已完成”状态，已设置不可重复操作!");
                //    return _result;
                //}

                var subTaskUpd = _sqlSugar.Updateable<Pm_TaskRelevanceUser>()
                    .SetColumns(it => it.TaskStatus == TaskEnum.Finished)
                    .SetColumns(it => it.OverTime == overTime)
                    .SetColumns(it => it.Remark == remark)
                    .Where(it => it.Id == taskerId)
                    .ExecuteCommand();
                if (subTaskUpd < 1)
                {
                    _result.Msg = string.Format("操作失败!");
                    _taskTextFileLogger.LogInformation("任务完成设置[失败]，任务名称：{TaskName}，操作者：{OperatorName}", taskName, operatorName);
                    _sqlSugar.RollbackTran();
                    return _result;
                }

                #region 更新主任务状态

                // 查询所有关联任务的状态
                var allRelevanceTasks = _sqlSugar.Queryable<Pm_TaskRelevanceUser>()
                    .Where(x => x.TAId == mainTaskId && x.IsDel == 0)
                    .Select(x => new
                    {
                        x.Id,
                        x.UserId,
                        x.TaskStatus
                    })
                    .ToList();

                var mainTaskInfoOld = _sqlSugar.Queryable<Pm_TaskAllocation>()
                    .Where(x => x.Id == mainTaskId && x.IsDel == 0)
                    .Select(x => new Pm_TaskAllocation
                    {
                        OverTime = x.OverTime,
                        Status = x.Status,
                        Remark = x.Remark
                    })
                    .First();
                var mainTaskInfoNew = new Pm_TaskAllocation();

                // 计算任务状态统计
                int totalCount = allRelevanceTasks.Count;

                // 未开始 数量
                int notStartedCount = allRelevanceTasks.Count(x => x.TaskStatus <= TaskEnum.NotStarted);
                int underWayCount = allRelevanceTasks.Count(x => x.TaskStatus > TaskEnum.NotStarted);

                if (notStartedCount > 0)
                {
                    //其他人未设置已知晓 不可设置 完成状态
                    var userIds = allRelevanceTasks.Where(x => x.TaskStatus < TaskEnum.UnderWay).Select(x => x.UserId).ToList();
                    var names = _sqlSugar.Queryable<Sys_Users>()
                        .Where(x => userIds.Contains(x.Id))
                        .Select(x => x.CnName)
                        .ToList();

                    string userLabel = string.Join("、",names);

                    _result.Msg = string.Format($"{userLabel} 未点击已知晓，不可设置任务完成。");
                    _sqlSugar.RollbackTran();
                    return _result;
                }

                // 判断是否所有子任务均处于结束状态 是 则更新主任务状态
                bool allTasksInEndStatus = totalCount == underWayCount;
                if (allTasksInEndStatus)
                {
                    TaskEnum newMainTaskStatus;

                    if (notStartedCount > 0)
                    {
                        // 存在未完成的子任务
                        newMainTaskStatus = TaskEnum.UnFinished;
                    }
                    else if (underWayCount == totalCount)
                    {
                        // 所有子任务都在进行中
                        newMainTaskStatus = TaskEnum.Finished;
                    }
                    else
                    {
                        // 理论上不会走到这里，但为了安全
                        newMainTaskStatus = TaskEnum.UnFinished;
                    }

                    var rowsAffected = _sqlSugar.Updateable<Pm_TaskAllocation>()
                        .SetColumns(x => new Pm_TaskAllocation
                        {
                            Status = newMainTaskStatus,
                            OverTime = overTime,
                            Remark = remark
                        })
                        .Where(x => x.Id == mainTaskId && x.IsDel == 0)
                        .ExecuteCommand();

                    if (rowsAffected <= 0)
                    {
                        _result.Msg = string.Format("更新主任务状态失败!");
                        _taskTextFileLogger.LogInformation("任务完成设置[失败]，任务名称：{TaskName}，操作者：{OperatorName}", taskName, operatorName);
                        _sqlSugar.RollbackTran();
                        return _result;
                    }
                    mainTaskInfoNew = new Pm_TaskAllocation
                    {
                        OverTime = overTime,
                        Status = newMainTaskStatus,
                        Remark = remark
                    };
                }else

                #endregion

                _result.Msg = string.Format("操作成功!");
                var logMsgChange = new StringBuilder();

                var changeMsg = ChangeMsg(mainTaskInfoOld, mainTaskInfoNew);

                _taskTextFileLogger.LogInformation("任务完成设置[成功]，任务名称：{TaskName}，操作者：{OperatorName}{ChangeMsg}", taskName, operatorName, changeMsg);
                _result.Code = 0;
                _sqlSugar.CommitTran();

                return _result;
            }
            catch (Exception)
            {
                _sqlSugar.RollbackTran();
                _result.Msg = string.Format("操作失败!");
                return _result;
            }
        }

        /// <summary>
        /// 设置任务未完成状态
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<Result> TaskSetUnFinishedStatus(int id, string cause)
        {
            if (id < 1)
            {
                _result.Msg = string.Format("请传入有效的Id参数!");
                return _result;
            }

            var data1 = await _sqlSugar.Queryable<Pm_TaskRelevanceUser>().Where(it => it.IsDel == 0 && it.Id == id).FirstAsync();
            if (data1 == null)
            {
                _result.Msg = string.Format("该任务不存在或者该任务未分配给你!");
                return _result;
            }
            int _taId = data1.TAId;

            _sqlSugar.BeginTran();
            var update1 = await _sqlSugar.Updateable<Pm_TaskRelevanceUser>()
                                         .SetColumns(it => it.TaskStatus == TaskEnum.UnFinished)
                                         .SetColumns(it => it.Cause == cause)
                                         .Where(it => it.Id == id)
                                         .ExecuteCommandAsync();
            if (update1 < 1)
            {
                _result.Msg = string.Format("操作失败!");
                _sqlSugar.RollbackTran();
                return _result;
            }

            //设置任务状态
            var data2 = _sqlSugar.Queryable<Pm_TaskRelevanceUser>().Where(it => it.IsDel == 0 && it.TAId == _taId).ToList();
            var data3 = data2.Where(it => it.TaskStatus == TaskEnum.Finished && it.Id != id).ToList();
            var data4 = data2.Where(it => it.TaskStatus == TaskEnum.UnFinished && it.Id != id).ToList();
           
            if ((data2.Count - 1) == (data3.Count + data4.Count))
            {
                var update2 = _sqlSugar.Updateable<Pm_TaskAllocation>()
                                         .SetColumns(it => it.Status == TaskEnum.UnFinished)
                                         .Where(it => it.Id == _taId)
                                         .ExecuteCommand();
                if (update2 < 1)
                {
                    _result.Msg = string.Format("操作失败!");
                    _sqlSugar.RollbackTran();
                    return _result;
                }
            }

            _result.Msg = string.Format("操作成功!");
            _result.Code = 0;
            _sqlSugar.CommitTran();

            return _result;
        }

        /// <summary>
        /// 任务确认完成
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<Result> TaskConfirmCompletion(int portType,int id)
        {
            if (portType == 1 || portType == 2 || portType == 3)
            {
                if (id < 1)
                {
                    _result.Msg = string.Format("请传入有效的Id参数!");
                    return _result;
                }

                var data = await _sqlSugar.Queryable<Pm_TaskRelevanceUser>()
                                          .Where(it => it.IsDel == 0 && it.Id == id && it.TaskStatus <= TaskEnum.UnFinished)
                                          .ToListAsync();
                if (data.Count > 0)
                {
                    _result.Msg = string.Format("本任务参与人员并未全部完成,不可确认任务完成!");
                    return _result;
                }


                var update = await _sqlSugar.Updateable<Pm_TaskAllocation>()
                                            .SetColumns(it => it.IsComplete == 1)
                                            .SetColumns(it => it.Status == TaskEnum.Finished)
                                            .Where(it => it.Id == id)
                                            .ExecuteCommandAsync();
                if (update > 0)
                {
                    _result.Code = 0;
                    return _result;
                }
                else _result.Msg = "确认完成失败!";


            }
            else
            {
                _result.Msg = string.Format("请传入有效的PortType参数!");
            }
            return _result;
        }

        /// <summary>
        /// 任务评分
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<Result> TaskScore(TaskAllocationScoreDto dto)
        {
            int portType = dto.PortType;
            if (portType == 1 || portType == 2 || portType == 3)
            {
                if (dto.SubId < 1)
                {
                    _result.Msg = string.Format("请传入有效的SubId参数!");
                    return _result;
                }

                //var data = await _sqlSugar.Queryable<Pm_TaskAllocation>()
                //                          .Where(it => it.IsDel == 0 )
                //                          .FirstAsync();
                //if (data == null)
                //{
                //    _result.Msg = string.Format("本任务尚未由发布人确认任务完成,不可评分!");
                //    return _result;
                //}

                var data = _sqlSugar.Queryable<Pm_TaskRelevanceUser>()
                                          .Where(it => it.IsDel == 0 && it.Id == dto.SubId)
                                          .First();
                if (data == null)
                {
                    _result.Msg = string.Format("本任务尚未由发布人确认任务完成,不可评分!");
                    return _result;
                }

                if (data.TaskStatus != TaskEnum.Finished)
                {
                    _result.Msg = string.Format("本任务尚未由发布人确认任务完成,不可评分!");
                    return _result;
                }


                Pm_TaskRelevanceUser _TaskRelevanceUser = new Pm_TaskRelevanceUser() {
                    Id = dto.SubId,
                    Score = dto.Score,
                    Remark = dto.ScoreRemark
                };

                var update = await _sqlSugar.Updateable<Pm_TaskRelevanceUser>(_TaskRelevanceUser)
                                            .UpdateColumns(it => new { it.Score, it.Remark })
                                            .WhereColumns(it => it.Id)
                                            .ExecuteCommandAsync();
                if (update > 0)
                {
                    _result.Code = 0;
                    return _result;
                }
                else _result.Msg = "评分失败!";

            }
            else
            {
                _result.Msg = string.Format("请传入有效的PortType参数!");
            }
            return _result;
        }

        /// <summary>
        /// 任务终止
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<Result> TaskTermination(int taskId,int userId)
        {
            if (taskId < 1)
            {
                _result.Msg = string.Format("请传入有效的taskId参数!");
                return _result;
            }

            //权限验证
            (bool taskStopPerm,string msg) = TaskStopPerm(taskId, userId);
            if (!taskStopPerm)
            {
                _result.Msg = msg;
                return _result;
            }

            _sqlSugar.BeginTran();
            var taskUpdate = _sqlSugar.Updateable<Pm_TaskAllocation>()
                .SetColumns(it => it.Status == TaskEnum.TaskStop)
                .Where(it => it.Id == taskId)
                .ExecuteCommand();
            if (taskUpdate < 1)
            {
                _result.Msg = "任务终止失败!";
                _sqlSugar.RollbackTran();
                return _result;
            }
            var subTaskUpdate = _sqlSugar.Updateable<Pm_TaskRelevanceUser>()
                .SetColumns(it => it.TaskStatus == TaskEnum.TaskStop)
                .Where(it => it.TAId == taskId)
                .ExecuteCommand();

            if (taskUpdate < 1)
            {
                _result.Msg = "任务终止失败!";
                _sqlSugar.RollbackTran();
                return _result;
            }
            _result.Msg = "操作成功!";
            _result.Code = 0;
            _sqlSugar.CommitTran();
            return _result;
        }

        /// <summary>
        /// 任务删除
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<Result> TaskDel(int taskId,int userId)
        {
            if (taskId < 1)
            {
                _result.Msg = string.Format("请传入有效的taskId参数!");
                return _result;
            }
            _sqlSugar.BeginTran();

            var taskName = _sqlSugar.Queryable<Pm_TaskAllocation>().Where(it => it.IsDel == 0 && it.Id == taskId).Select(it => it.TaskName).First();
            var operatorName = _sqlSugar.Queryable<Sys_Users>().Where(it => it.IsDel == 0 && it.Id == userId).Select(it => it.CnName).First();
            var nowStrig = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            var taskUpdate = _sqlSugar.Updateable<Pm_TaskAllocation>()
                .SetColumns(it => it.IsDel == 1)
                .SetColumns(it => it.DeleteUserId == userId)
                .SetColumns(it => it.DeleteTime == nowStrig)
                .Where(it => it.Id == taskId)
                .ExecuteCommand();
            if (taskUpdate < 1)
            {
                _result.Msg = "任务删除失败!";
                _sqlSugar.RollbackTran();
                return _result;
            }
            var subTaskUpdate = _sqlSugar.Updateable<Pm_TaskRelevanceUser>()
                .SetColumns(it => it.IsDel == 1)
                .SetColumns(it => it.DeleteUserId == userId)
                .SetColumns(it => it.DeleteTime == nowStrig)
                .Where(it => it.TAId == taskId)
                .ExecuteCommand();

            if (taskUpdate < 1)
            {
                _result.Msg = "任务删除失败!";
                _taskTextFileLogger.LogInformation("任务删除[失败]，任务名称：{TaskName}，操作者：{OperatorName}", taskName, operatorName);
                _sqlSugar.RollbackTran();
                return _result;
            }
            _result.Msg = "操作成功!";
            _taskTextFileLogger.LogInformation("任务删除[成功]，任务名称：{TaskName}，操作者：{OperatorName}", taskName, operatorName);
            _result.Code = 0;
            _sqlSugar.CommitTran();
            return _result;
        }

        #region 操作日志

        /// <summary>
        /// 记录任务分配步骤值改变
        /// </summary>
        /// <param name="before">操作前的步骤数据实体</param>
        /// <param name="after">操作后的步骤数据实体</param>
        /// <returns>表示同步操作的任务</returns>
        /// <remarks>此方法会自动比较前后数据的差异，生成变更字段列表和操作描述</remarks>
        public string ChangeMsg(Pm_TaskAllocation before, Pm_TaskAllocation after)
        {
            // 合并基础排除字段和额外排除字段
            var allExcludedFields = GetDefaultExcludedFields();
            var changedFields = GetChangeDetails(before, after, allExcludedFields);

            if (!changedFields.Any()) return "\r\n无内容变更\r\n\r\n";

            return "\r\n值改变内容(只记录有变化的信息)：\r\n" + string.Join("\r\n", changedFields.Select(x =>
                $"{x.FieldName} ({x.BeforeValue} -> {x.AfterValue});")) + "\r\n";

        }

        /// <summary>
        /// 获取字段变更详情
        /// </summary>
        /// <param name="before">变更前</param>
        /// <param name="after">变更后</param>
        /// <param name="exclFields">排除字段</param>
        /// <returns>变更详情列表</returns>
        private List<FieldChangeDetail> GetChangeDetails(Pm_TaskAllocation before, Pm_TaskAllocation after, List<string>? exclFields = null)
        {
            var changeDetails = new List<FieldChangeDetail>();
            var defaultExclFields = GetDefaultExcludedFields();

            // 合并排除字段
            var allExclFields = defaultExclFields;
            if (exclFields != null && exclFields.Any())
            {
                allExclFields = defaultExclFields.Union(exclFields).ToList();
            }

            if (before == null || after == null) return changeDetails;

            var properties = typeof(Pm_TaskAllocation).GetProperties(BindingFlags.Public | BindingFlags.Instance);

            foreach (var prop in properties)
            {
                // 跳过排除的字段
                if (allExclFields.Contains(prop.Name))
                {
                    continue;
                }

                var beforeValue = prop.GetValue(before);
                var afterValue = prop.GetValue(after);

                // 处理字符串类型的特殊比较（忽略前后空格）
                if (prop.PropertyType == typeof(string))
                {
                    var beforeString = beforeValue?.ToString()?.Trim();
                    var afterString = afterValue?.ToString()?.Trim();

                    if (beforeString != afterString)
                    {
                        changeDetails.Add(new FieldChangeDetail
                        {
                            FieldName = prop.Name,
                            BeforeValue = FormatValue(beforeString),
                            AfterValue = FormatValue(afterString)
                        });
                    }
                }
                else
                {
                    // 其他类型使用默认比较
                    if (!Equals(beforeValue, afterValue))
                    {
                        changeDetails.Add(new FieldChangeDetail
                        {
                            FieldName = prop.Name,
                            BeforeValue = FormatValue(beforeValue),
                            AfterValue = FormatValue(afterValue)
                        });
                    }
                }
            }

            return changeDetails;
        }

        /// <summary>
        /// 格式化值显示
        /// </summary>
        /// <param name="value">原始值</param>
        /// <returns>格式化后的值</returns>
        private static string FormatValue(object value)
        {
            if (value == null) return "null";

            var strValue = value.ToString();

            // 处理空字符串
            if (string.IsNullOrEmpty(strValue)) return "空";

            // 处理布尔值
            if (value is bool boolValue) return boolValue ? "是" : "否";

            // 处理日期时间
            if (value is DateTime dateTimeValue) return dateTimeValue.ToString("yyyy-MM-dd HH:mm");

            // 处理枚举类型
            if (value is Enum enumBool) return enumBool.GetDescription();

            return strValue;
        }

        /// <summary>
        /// 字段变更详情类
        /// </summary>
        private class FieldChangeDetail
        {
            public string FieldName { get; set; }
            public string BeforeValue { get; set; }
            public string AfterValue { get; set; }
        }

        /// <summary>
        /// 获取默认排除的字段列表（包含系统字段和忽略字段）
        /// </summary>
        /// <returns>默认排除的字段列表</returns>
        private static List<string> GetDefaultExcludedFields()
        {
            var defaultExcludedFields = new List<string>
            {
                nameof(Pm_TaskAllocation.Id),
                nameof(Pm_TaskAllocation.CreateTime),
                nameof(Pm_TaskAllocation.CreateUserId),
                nameof(Pm_TaskAllocation.DeleteTime),
                nameof(Pm_TaskAllocation.DeleteUserId)
            };

            return defaultExcludedFields.Distinct().ToList();
        }

        #endregion
    }
}