4241 lines
188 KiB
C#
4241 lines
188 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using System.Linq;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using Microsoft.AspNetCore.Mvc;
|
||
using Microsoft.Extensions.Logging;
|
||
using ZhonTai.Admin.Services;
|
||
using ZhonTai.DynamicApi;
|
||
using ZhonTai.DynamicApi.Attributes;
|
||
using NPP.SmartSchedue.Api.Contracts.Services.Integration;
|
||
using NPP.SmartSchedue.Api.Contracts.Services.Integration.Input;
|
||
using NPP.SmartSchedue.Api.Contracts.Services.Integration.Output;
|
||
using NPP.SmartSchedue.Api.Contracts.Services.Work;
|
||
using NPP.SmartSchedue.Api.Contracts.Services.Personnel;
|
||
using NPP.SmartSchedue.Api.Contracts.Core.Enums;
|
||
using NPP.SmartSchedue.Api.Contracts.Domain.Work;
|
||
using NPP.SmartSchedue.Api.Contracts.Domain.Personnel;
|
||
using NPP.SmartSchedue.Api.Services.Integration.Models;
|
||
using NPP.SmartSchedue.Api.Contracts.Domain.Time;
|
||
using NPP.SmartSchedue.Api.Repositories.Work;
|
||
using NPP.SmartSchedue.Api.Contracts.Services.Integration.Models;
|
||
using Microsoft.Extensions.Caching.Memory;
|
||
using NPP.SmartSchedue.Api.Contracts.Services.Time;
|
||
using SkiaSharp;
|
||
|
||
namespace NPP.SmartSchedue.Api.Services.Integration
|
||
{
|
||
/// <summary>
|
||
/// 智能人员分配服务
|
||
/// 实现基于五层决策模型的智能分配算法：资格过滤→约束评估→优化决策→结果生成→统一验证
|
||
/// 深度业务思考：支持复杂的多维度约束和智能优化，确保分配结果的合理性和公平性
|
||
/// </summary>
|
||
[DynamicApi(Area = "app")]
|
||
public partial class PersonnelAllocationService : BaseService, IPersonnelAllocationService
|
||
{
|
||
private readonly WorkOrderRepository _workOrderRepository;
|
||
private readonly IPersonService _personService;
|
||
private readonly IPersonnelWorkLimitService _personnelWorkLimitService;
|
||
private readonly IPersonnelQualificationService _personnelQualificationService;
|
||
private readonly IShiftService _shiftService;
|
||
private readonly IEmployeeLeaveService _employeeLeaveService;
|
||
private readonly ILogger<PersonnelAllocationService> _logger;
|
||
private readonly IMemoryCache _memoryCache;
|
||
|
||
// 性能监控
|
||
private readonly ActivitySource _activitySource;
|
||
|
||
// 权重配置（可配置化）
|
||
private readonly OptimizationWeights _defaultWeights = OptimizationWeights.CreateEfficiencyFirstConfiguration();
|
||
|
||
public PersonnelAllocationService(
|
||
WorkOrderRepository workOrderRepository,
|
||
IPersonService personService,
|
||
IPersonnelWorkLimitService personnelWorkLimitService,
|
||
IPersonnelQualificationService personnelQualificationService,
|
||
IShiftService shiftService,
|
||
IEmployeeLeaveService employeeLeaveService,
|
||
ILogger<PersonnelAllocationService> logger,
|
||
IMemoryCache memoryCache)
|
||
{
|
||
_workOrderRepository = workOrderRepository;
|
||
_personService = personService;
|
||
_personnelWorkLimitService = personnelWorkLimitService;
|
||
_personnelQualificationService = personnelQualificationService;
|
||
_shiftService = shiftService;
|
||
_employeeLeaveService = employeeLeaveService;
|
||
_logger = logger;
|
||
_memoryCache = memoryCache;
|
||
|
||
// 初始化性能监控
|
||
_activitySource = new ActivitySource("NPP.SmartSchedule.PersonnelAllocation");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 智能人员分配核心方法
|
||
/// 基于五层决策模型的完整实现：资格过滤→约束评估→优化决策→结果生成→验证
|
||
/// 深度业务思考：考虑所有约束条件，确保分配结果既满足业务规则又实现最优化
|
||
/// </summary>
|
||
[HttpPost]
|
||
public async Task<PersonnelAllocationResult> AllocatePersonnelSmartlyAsync(PersonnelAllocationInput input)
|
||
{
|
||
using var activity = _activitySource?.StartActivity("AllocatePersonnelSmart");
|
||
var stopwatch = Stopwatch.StartNew();
|
||
|
||
try
|
||
{
|
||
_logger.LogInformation("开始智能人员分配，任务数量：{TaskCount}，策略：{Strategy}",
|
||
input.Tasks?.Count ?? input.TaskIds?.Count ?? 0, input.Strategy);
|
||
|
||
// 输入验证和数据准备
|
||
var validationResult = await ValidateAndPrepareInputAsync(input);
|
||
if (!validationResult.IsValid)
|
||
{
|
||
return CreateFailureResult(validationResult.ErrorMessage);
|
||
}
|
||
|
||
// 构建分配上下文
|
||
var context = await BuildAllocationContextAsync(input, validationResult.WorkOrders);
|
||
activity?.SetTag("task.count", context.WorkOrders.Count);
|
||
activity?.SetTag("personnel.pool.size", context.AvailablePersonnel.Count);
|
||
|
||
// 第一层：资格过滤处理
|
||
var qualificationResult = await ExecuteQualificationFilterAsync(context);
|
||
if (!qualificationResult.IsSuccess)
|
||
{
|
||
_logger.LogWarning("资格过滤失败：{Message}", qualificationResult.Message);
|
||
return CreatePartialFailureResult(context, "资格过滤阶段失败");
|
||
}
|
||
|
||
// 第二层：约束评估处理
|
||
var constraintResult = await ExecuteConstraintEvaluationAsync(context);
|
||
if (!constraintResult.IsSuccess)
|
||
{
|
||
_logger.LogWarning("约束评估失败：{Message}", constraintResult.Message);
|
||
return CreatePartialFailureResult(context, "约束评估阶段失败");
|
||
}
|
||
|
||
// 第三层：优化决策处理
|
||
var optimizationResult = await ExecuteOptimizationDecisionAsync(context);
|
||
if (!optimizationResult.IsSuccess)
|
||
{
|
||
_logger.LogWarning("优化决策失败：{Message}", optimizationResult.Message);
|
||
return CreatePartialFailureResult(context, "优化决策阶段失败");
|
||
}
|
||
|
||
// 第四层：结果生成处理
|
||
var generationResult = await ExecuteResultGenerationAsync(context);
|
||
if (!generationResult.IsSuccess)
|
||
{
|
||
_logger.LogError("结果生成失败：{Message}", generationResult.Message);
|
||
return CreateFailureResult("结果生成阶段失败");
|
||
}
|
||
|
||
// 第五层：最终验证和质量评估
|
||
var finalResult = await ExecuteFinalValidationAsync(context,
|
||
generationResult.ResultData as AllocationGenerationResult);
|
||
|
||
stopwatch.Stop();
|
||
activity?.SetTag("execution.time.ms", stopwatch.ElapsedMilliseconds);
|
||
activity?.SetTag("allocation.success", finalResult.IsSuccess);
|
||
|
||
_logger.LogInformation("智能人员分配完成，耗时：{ElapsedMs}ms，成功：{Success}",
|
||
stopwatch.ElapsedMilliseconds, finalResult.IsSuccess);
|
||
|
||
return finalResult;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
stopwatch.Stop();
|
||
if (activity != null)
|
||
{
|
||
activity.SetStatus(System.Diagnostics.ActivityStatusCode.Error, ex.Message);
|
||
}
|
||
|
||
_logger.LogError(ex, "智能人员分配异常，耗时：{ElapsedMs}ms", stopwatch.ElapsedMilliseconds);
|
||
|
||
return CreateFailureResult($"系统异常：{ex.Message}");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取任务的候选人员列表（带评分和推理）
|
||
/// </summary>
|
||
public async Task<List<PersonnelCandidate>> GetCandidatesAsync(long workOrderId)
|
||
{
|
||
try
|
||
{
|
||
var workOrder = await _workOrderRepository.GetAsync(workOrderId);
|
||
if (workOrder == null)
|
||
{
|
||
_logger.LogWarning("工作任务不存在：{WorkOrderId}", workOrderId);
|
||
return new List<PersonnelCandidate>();
|
||
}
|
||
|
||
// 构建单任务分配上下文
|
||
var context = await BuildSingleTaskContextAsync(workOrder);
|
||
|
||
// 执行资格过滤和约束评估
|
||
await ExecuteQualificationFilterAsync(context);
|
||
await ExecuteConstraintEvaluationAsync(context);
|
||
await ExecuteOptimizationDecisionAsync(context);
|
||
|
||
// 返回候选人员列表
|
||
if (context.FilteredCandidates.TryGetValue(workOrderId, out var candidates))
|
||
{
|
||
return candidates.OrderByDescending(c => c.TotalScore).ToList();
|
||
}
|
||
|
||
return new List<PersonnelCandidate>();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "获取候选人员异常，任务ID：{WorkOrderId}", workOrderId);
|
||
return new List<PersonnelCandidate>();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量获取任务的候选人员映射（性能优化）
|
||
/// </summary>
|
||
public async Task<Dictionary<long, List<PersonnelCandidate>>> GetBatchCandidatesAsync(List<long> workOrderIds)
|
||
{
|
||
try
|
||
{
|
||
if (workOrderIds == null || !workOrderIds.Any())
|
||
{
|
||
return new Dictionary<long, List<PersonnelCandidate>>();
|
||
}
|
||
|
||
// 批量获取工作任务
|
||
var workOrders = await _workOrderRepository.Select
|
||
.Where(w => workOrderIds.Contains(w.Id))
|
||
.Include(w => w.ProcessEntity)
|
||
.ToListAsync();
|
||
|
||
if (!workOrders.Any())
|
||
{
|
||
return new Dictionary<long, List<PersonnelCandidate>>();
|
||
}
|
||
|
||
// 构建批量分配上下文
|
||
var input = new PersonnelAllocationInput
|
||
{
|
||
Tasks = workOrders,
|
||
Strategy = PersonnelAllocationStrategy.FairDistribution
|
||
};
|
||
|
||
var context = await BuildAllocationContextAsync(input, workOrders);
|
||
|
||
// 执行前三层处理
|
||
await ExecuteQualificationFilterAsync(context);
|
||
await ExecuteConstraintEvaluationAsync(context);
|
||
await ExecuteOptimizationDecisionAsync(context);
|
||
|
||
// 排序并返回结果
|
||
var result = new Dictionary<long, List<PersonnelCandidate>>();
|
||
foreach (var kvp in context.FilteredCandidates)
|
||
{
|
||
result[kvp.Key] = kvp.Value.OrderByDescending(c => c.TotalScore).ToList();
|
||
}
|
||
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "批量获取候选人员异常，任务数量：{TaskCount}", workOrderIds?.Count ?? 0);
|
||
return new Dictionary<long, List<PersonnelCandidate>>();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证人员分配的可行性
|
||
/// </summary>
|
||
public async Task<PersonnelAllocationValidationResult> ValidateAllocationAsync(
|
||
PersonnelAllocationValidationInput validationInput)
|
||
{
|
||
try
|
||
{
|
||
var result = new PersonnelAllocationValidationResult();
|
||
var violations = new List<ValidationViolation>();
|
||
var warnings = new List<ValidationWarning>();
|
||
|
||
foreach (var assignment in validationInput.Assignments)
|
||
{
|
||
// 验证资质匹配
|
||
var qualificationValid =
|
||
await ValidatePersonnelQualificationAsync(assignment.WorkOrderId, assignment.PersonnelId);
|
||
if (!qualificationValid.IsValid)
|
||
{
|
||
violations.AddRange(qualificationValid.Violations);
|
||
}
|
||
|
||
// 验证时间冲突
|
||
var timeConflictValid = await ValidateTimeConflictAsync(assignment.PersonnelId,
|
||
assignment.AssignmentDate, assignment.ShiftId ?? 0);
|
||
if (!timeConflictValid.IsValid)
|
||
{
|
||
violations.AddRange(timeConflictValid.Violations);
|
||
}
|
||
|
||
// 验证工作限制
|
||
var workLimitValid =
|
||
await ValidateWorkLimitAsync(assignment.PersonnelId, assignment.AssignmentDate);
|
||
if (!workLimitValid.IsValid)
|
||
{
|
||
violations.AddRange(workLimitValid.Violations);
|
||
}
|
||
|
||
// 验证班次规则
|
||
if (validationInput.IncludeConflictDetection)
|
||
{
|
||
var shiftRuleValid = await ValidateShiftRuleAsync(assignment.PersonnelId,
|
||
assignment.AssignmentDate, assignment.ShiftId ?? 0);
|
||
if (!shiftRuleValid.IsValid)
|
||
{
|
||
violations.AddRange(shiftRuleValid.Violations);
|
||
}
|
||
}
|
||
}
|
||
|
||
result.IsValid = !violations.Any(v => v.Severity >= ViolationSeverity.Error);
|
||
result.Violations = violations;
|
||
result.Warnings = warnings;
|
||
result.PassedAssignmentCount = validationInput.Assignments.Count - result.FailedAssignmentCount;
|
||
result.FailedAssignmentCount = violations.Count(v => v.Severity >= ViolationSeverity.Error);
|
||
result.ValidationScore =
|
||
CalculateValidationScore(violations, warnings, validationInput.Assignments.Count);
|
||
result.ValidationReport = GenerateValidationReport(result);
|
||
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "人员分配验证异常");
|
||
return new PersonnelAllocationValidationResult
|
||
{
|
||
IsValid = false,
|
||
ValidationReport = $"验证异常：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取人员工作负载分析
|
||
/// </summary>
|
||
public async Task<List<PersonnelWorkloadAnalysis>> AnalyzePersonnelWorkloadAsync(List<long> personnelIds,
|
||
DateRange dateRange)
|
||
{
|
||
try
|
||
{
|
||
var result = new List<PersonnelWorkloadAnalysis>();
|
||
|
||
foreach (var personnelId in personnelIds)
|
||
{
|
||
// 获取指定时间范围内的任务分配
|
||
var assignments = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId &&
|
||
w.WorkOrderDate >= dateRange.StartDate &&
|
||
w.WorkOrderDate <= dateRange.EndDate)
|
||
.ToListAsync();
|
||
|
||
// 计算工作负载
|
||
var workloadAnalysis = new PersonnelWorkloadAnalysis
|
||
{
|
||
PersonnelId = personnelId,
|
||
AssignedTaskCount = assignments.Count,
|
||
WorkDates = assignments.Select(a => a.WorkOrderDate).Distinct().ToList()
|
||
};
|
||
|
||
// 计算连续工作天数
|
||
workloadAnalysis.ContinuousWorkDays = CalculateContinuousWorkDays(workloadAnalysis.WorkDates);
|
||
|
||
// 估算总工时
|
||
workloadAnalysis.TotalEstimatedHours = assignments.Sum(a => a.EstimatedHours ?? 8.0m);
|
||
|
||
// 计算工作负载百分比（基于标准工时）
|
||
var standardHours = dateRange.Duration.Days * 8.0m; // 假设每天8小时标准工时
|
||
workloadAnalysis.WorkloadPercentage = standardHours > 0
|
||
? (double)(workloadAnalysis.TotalEstimatedHours / standardHours * 100)
|
||
: 0;
|
||
|
||
// 确定工作负载状态
|
||
workloadAnalysis.WorkloadStatus = workloadAnalysis.WorkloadPercentage switch
|
||
{
|
||
< 50 => "轻松",
|
||
< 80 => "适中",
|
||
< 100 => "繁重",
|
||
_ => "超负荷"
|
||
};
|
||
|
||
result.Add(workloadAnalysis);
|
||
}
|
||
|
||
return result.OrderByDescending(w => w.WorkloadPercentage).ToList();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "人员工作负载分析异常");
|
||
return new List<PersonnelWorkloadAnalysis>();
|
||
}
|
||
}
|
||
|
||
#region 核心流程方法实现
|
||
|
||
/// <summary>
|
||
/// 验证和准备输入数据
|
||
/// 深度业务思考：确保输入数据的完整性和有效性，避免后续处理出现异常
|
||
/// </summary>
|
||
private async Task<InputValidationResult> ValidateAndPrepareInputAsync(PersonnelAllocationInput input)
|
||
{
|
||
var result = new InputValidationResult();
|
||
|
||
try
|
||
{
|
||
// 基础验证
|
||
if (input == null)
|
||
{
|
||
result.IsValid = false;
|
||
result.ErrorMessage = "输入参数不能为空";
|
||
return result;
|
||
}
|
||
|
||
// 获取工作任务
|
||
List<WorkOrderEntity> workOrders;
|
||
if (input.Tasks != null && input.Tasks.Any())
|
||
{
|
||
// 优先使用传入的Tasks对象（性能优化）
|
||
workOrders = input.Tasks;
|
||
_logger.LogInformation("使用传入的Tasks对象，任务数量：{TaskCount}", workOrders.Count);
|
||
}
|
||
else if (input.TaskIds != null && input.TaskIds.Any())
|
||
{
|
||
// 从数据库查询Tasks
|
||
workOrders = await _workOrderRepository.Select
|
||
.Where(w => input.TaskIds.Contains(w.Id))
|
||
.Include(w => w.ProcessEntity)
|
||
.ToListAsync();
|
||
|
||
if (!workOrders.Any())
|
||
{
|
||
result.IsValid = false;
|
||
result.ErrorMessage = "指定的工作任务不存在";
|
||
return result;
|
||
}
|
||
|
||
_logger.LogInformation("从数据库查询Tasks，任务数量：{TaskCount}", workOrders.Count);
|
||
}
|
||
else
|
||
{
|
||
result.IsValid = false;
|
||
result.ErrorMessage = "必须提供Tasks或TaskIds";
|
||
return result;
|
||
}
|
||
|
||
// 验证任务状态
|
||
var invalidTasks = workOrders.Where(w => w.Status != (int)WorkOrderStatusEnum.PendingIntegration).ToList();
|
||
if (invalidTasks.Any())
|
||
{
|
||
result.IsValid = false;
|
||
result.ErrorMessage = $"存在非待分配状态的任务：{string.Join(",", invalidTasks.Select(t => t.WorkOrderCode))}";
|
||
return result;
|
||
}
|
||
|
||
// 验证任务是否包含必要信息
|
||
var invalidProcessTasks = workOrders.Where(w => w.ProcessEntity == null).ToList();
|
||
if (invalidProcessTasks.Any())
|
||
{
|
||
_logger.LogWarning("存在工序信息缺失的任务：{TaskCodes}",
|
||
string.Join(",", invalidProcessTasks.Select(t => t.WorkOrderCode)));
|
||
}
|
||
|
||
result.IsValid = true;
|
||
result.WorkOrders = workOrders;
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "验证和准备输入数据异常");
|
||
result.IsValid = false;
|
||
result.ErrorMessage = $"输入验证异常：{ex.Message}";
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 构建分配上下文
|
||
/// 深度架构思考：集中管理分配过程中的所有状态和数据，支持复杂的多任务分配场景
|
||
/// </summary>
|
||
private async Task<AllocationContext> BuildAllocationContextAsync(PersonnelAllocationInput input,
|
||
List<WorkOrderEntity> workOrders)
|
||
{
|
||
try
|
||
{
|
||
var context = new AllocationContext
|
||
{
|
||
ContextId = Guid.NewGuid().ToString(),
|
||
CreatedAt = DateTime.UtcNow,
|
||
WorkOrders = workOrders,
|
||
Strategy = input.Strategy,
|
||
WeightConfiguration = _defaultWeights.ToDictionary()
|
||
};
|
||
|
||
// 获取可用人员池
|
||
context.AvailablePersonnel = await GetAvailablePersonnelPoolAsync();
|
||
|
||
// 过滤排除的人员
|
||
if (input.ExcludedPersonnelIds != null && input.ExcludedPersonnelIds.Any())
|
||
{
|
||
context.AvailablePersonnel = context.AvailablePersonnel
|
||
.Where(p => !input.ExcludedPersonnelIds.Contains(p.Id))
|
||
.ToList();
|
||
}
|
||
|
||
// 记录处理开始
|
||
context.ProcessingLog.Add($"构建分配上下文完成，上下文ID：{context.ContextId}");
|
||
context.ProcessingLog.Add($"任务数：{workOrders.Count}，人员池大小：{context.AvailablePersonnel.Count}");
|
||
context.ProcessingLog.Add($"分配策略：{input.Strategy}，排除人员：{input.ExcludedPersonnelIds?.Count ?? 0}个");
|
||
|
||
// 记录权重配置
|
||
var weightInfo = string.Join("；", context.WeightConfiguration.Select(kv => $"{kv.Key}={kv.Value:P0}"));
|
||
context.ProcessingLog.Add($"权重配置：{weightInfo}");
|
||
|
||
return context;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "构建分配上下文异常");
|
||
throw new InvalidOperationException($"构建分配上下文失败：{ex.Message}", ex);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 构建单任务分配上下文（用于GetCandidatesAsync）
|
||
/// </summary>
|
||
private async Task<AllocationContext> BuildSingleTaskContextAsync(WorkOrderEntity workOrder)
|
||
{
|
||
try
|
||
{
|
||
var context = new AllocationContext
|
||
{
|
||
ContextId = Guid.NewGuid().ToString(),
|
||
CreatedAt = DateTime.UtcNow,
|
||
WorkOrders = new List<WorkOrderEntity> { workOrder },
|
||
Strategy = PersonnelAllocationStrategy.FairDistribution,
|
||
WeightConfiguration = _defaultWeights.ToDictionary()
|
||
};
|
||
|
||
context.AvailablePersonnel = await GetAvailablePersonnelPoolAsync();
|
||
context.ProcessingLog.Add($"构建单任务上下文完成，任务：{workOrder.WorkOrderCode}");
|
||
|
||
return context;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "构建单任务分配上下文异常，任务ID：{WorkOrderId}", workOrder.Id);
|
||
throw;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取完整人员池
|
||
/// 深度架构思考：严格遵循五层决策模型，获取全量人员池，由各决策层负责筛选
|
||
/// 业务逻辑：根据资质表获取所有人员并去重，确保决策模型的完整性和公正性
|
||
/// </summary>
|
||
private async Task<List<PersonnelEntity>> GetAvailablePersonnelPoolAsync()
|
||
{
|
||
try
|
||
{
|
||
// 获取所有人员池（从资质表关联获取并去重）
|
||
// 五层决策模型要求：人员池应该是完整的，筛选工作由各决策层完成
|
||
var personnelPoolOutputs = await _personService.GetAllPersonnelPoolAsync(includeQualifications: false);
|
||
|
||
if (personnelPoolOutputs == null || !personnelPoolOutputs.Any())
|
||
{
|
||
_logger.LogWarning("系统中无任何人员数据");
|
||
return new List<PersonnelEntity>();
|
||
}
|
||
|
||
// 转换为PersonnelEntity格式，只进行最基础的数据完整性过滤
|
||
var personnelEntities = new List<PersonnelEntity>();
|
||
foreach (var output in personnelPoolOutputs)
|
||
{
|
||
if (output != null && output.Id > 0)
|
||
{
|
||
var entity = new PersonnelEntity
|
||
{
|
||
Id = output.Id,
|
||
PersonnelCode = output.PersonnelCode,
|
||
PersonnelName = output.PersonnelName,
|
||
DepartmentId = output.DepartmentId,
|
||
DepartmentName = output.DepartmentName,
|
||
Position = output.Position,
|
||
IsActive = output.IsActive,
|
||
Contact = output.Contact,
|
||
Remarks = output.Remarks,
|
||
CreatedTime = output.CreatedTime,
|
||
ModifiedTime = output.ModifiedTime
|
||
};
|
||
personnelEntities.Add(entity);
|
||
}
|
||
}
|
||
|
||
_logger.LogInformation("获取完整人员池完成，原始数量：{Total}，有效数量：{Valid}",
|
||
personnelPoolOutputs.Count, personnelEntities.Count);
|
||
|
||
_logger.LogDebug("人员池获取策略：从资质表关联获取全量人员并去重，由五层决策模型负责业务筛选");
|
||
|
||
return personnelEntities;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "获取人员池异常，将影响整个分配流程");
|
||
return new List<PersonnelEntity>();
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 五层处理器方法实现
|
||
|
||
/// <summary>
|
||
/// 执行第一层：资格过滤处理
|
||
/// 🎯 架构说明：这是一个可插拔的处理器架构
|
||
/// 📌 设计理念：既要开箱即用（内置实现），又要支持企业定制（外部处理器）
|
||
/// </summary>
|
||
private async Task<ProcessorResult> ExecuteQualificationFilterAsync(AllocationContext context)
|
||
{
|
||
var stopwatch = Stopwatch.StartNew();
|
||
|
||
try
|
||
{
|
||
context.ProcessingLog.Add("开始资格过滤处理");
|
||
|
||
// ⚡ 内置资格过滤实现（默认实现，覆盖99%的业务场景）
|
||
// 📈 技术特点：高性能、业务完整、可靠稳定
|
||
var filteredCandidates = new Dictionary<long, List<PersonnelCandidate>>();
|
||
|
||
var totalProcessed = 0;
|
||
var totalQualified = 0;
|
||
var totalBasicEligible = 0;
|
||
|
||
foreach (var workOrder in context.WorkOrders)
|
||
{
|
||
var candidates = new List<PersonnelCandidate>();
|
||
|
||
// 获取工序资质要求
|
||
var requiredQualifications = GetRequiredQualifications(workOrder);
|
||
|
||
foreach (var personnel in context.AvailablePersonnel)
|
||
{
|
||
totalProcessed++;
|
||
|
||
// 第一层决策：基础条件筛选
|
||
// 1. 检查人员基础状态（在职、可用等）
|
||
var personnelStatusValid = await IsPersonnelBasicallyEligibleAsync(personnel);
|
||
if (!personnelStatusValid.IsEligible)
|
||
{
|
||
// 记录但不计入后续处理
|
||
_logger.LogDebug("人员 {PersonnelName}({PersonnelId}) 未通过基础资格检查：{Reasons}",
|
||
personnel.PersonnelName, personnel.Id,
|
||
string.Join(",", personnelStatusValid.EligibilityReasons));
|
||
continue;
|
||
}
|
||
|
||
totalBasicEligible++;
|
||
|
||
// 2. 检查资质匹配
|
||
var qualificationMatch =
|
||
await CheckQualificationMatchAsync(personnel.Id, requiredQualifications);
|
||
if (qualificationMatch.IsMatched)
|
||
{
|
||
var candidate = new PersonnelCandidate
|
||
{
|
||
PersonnelId = personnel.Id,
|
||
PersonnelName = personnel.PersonnelName,
|
||
QualificationScore = new QualificationScore
|
||
{
|
||
MatchScore = qualificationMatch.MatchScore,
|
||
MatchedQualifications = qualificationMatch.MatchedQualifications,
|
||
MissingQualifications = qualificationMatch.MissingQualifications,
|
||
IsQualificationValid = qualificationMatch.IsValid,
|
||
QualificationDetails = qualificationMatch.Details
|
||
}
|
||
};
|
||
|
||
candidates.Add(candidate);
|
||
totalQualified++;
|
||
}
|
||
}
|
||
|
||
filteredCandidates[workOrder.Id] = candidates;
|
||
context.ProcessingLog.Add($"任务 {workOrder.WorkOrderCode} 资格过滤完成，候选人：{candidates.Count}");
|
||
}
|
||
|
||
context.FilteredCandidates = filteredCandidates;
|
||
stopwatch.Stop();
|
||
|
||
context.ProcessingLog.Add(
|
||
$"资格过滤完成，总处理：{totalProcessed}，基础合格：{totalBasicEligible}，资质匹配：{totalQualified}，耗时：{stopwatch.ElapsedMilliseconds}ms");
|
||
context.ProcessingLog.Add(
|
||
$"五层决策模型-第一层：从完整人员池({context.AvailablePersonnel.Count})中筛选出资质合格候选人({totalQualified})");
|
||
|
||
context.Metrics["QualificationFilter_ExecutionTime"] = stopwatch.ElapsedMilliseconds;
|
||
context.Metrics["QualificationFilter_ProcessedCount"] = totalProcessed;
|
||
context.Metrics["QualificationFilter_BasicEligibleCount"] = totalBasicEligible;
|
||
context.Metrics["QualificationFilter_QualifiedCount"] = totalQualified;
|
||
|
||
return new ProcessorResult
|
||
{
|
||
IsSuccess = true,
|
||
ProcessorName = "QualificationFilter",
|
||
ExecutionTimeMs = stopwatch.ElapsedMilliseconds,
|
||
SuccessCount = totalQualified,
|
||
ProcessedCount = totalProcessed,
|
||
Message = "资格过滤处理成功"
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
stopwatch.Stop();
|
||
_logger.LogError(ex, "资格过滤处理异常");
|
||
context.Errors.Add($"资格过滤异常：{ex.Message}");
|
||
return new ProcessorResult
|
||
{
|
||
IsSuccess = false,
|
||
ProcessorName = "QualificationFilter",
|
||
ExecutionTimeMs = stopwatch.ElapsedMilliseconds,
|
||
Message = $"资格过滤处理失败：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行第二层：约束评估处理
|
||
/// </summary>
|
||
private async Task<ProcessorResult> ExecuteConstraintEvaluationAsync(AllocationContext context)
|
||
{
|
||
var stopwatch = Stopwatch.StartNew();
|
||
|
||
try
|
||
{
|
||
context.ProcessingLog.Add("开始约束评估处理");
|
||
|
||
// ⚡ 内置约束评估实现（默认实现，包含完整的11种班次规则验证）
|
||
var constraintResults = new Dictionary<long, List<ConstraintEvaluationResult>>();
|
||
var totalEvaluated = 0;
|
||
var totalPassed = 0;
|
||
|
||
// 任务循环
|
||
foreach (var kvp in context.FilteredCandidates)
|
||
{
|
||
var workOrderId = kvp.Key;
|
||
var candidates = kvp.Value;
|
||
var workOrder = context.WorkOrders.First(w => w.Id == workOrderId);
|
||
|
||
var evaluationResults = new List<ConstraintEvaluationResult>();
|
||
|
||
// 人员循环
|
||
foreach (var candidate in candidates)
|
||
{
|
||
totalEvaluated++;
|
||
|
||
// 约束检查
|
||
var constraintCheck = await EvaluateCandidateConstraintsAsync(candidate, workOrder);
|
||
|
||
// 更新候选人约束评分
|
||
candidate.ConstraintScore = new ConstraintScore
|
||
{
|
||
ComplianceScore = constraintCheck.ConstraintScore,
|
||
TimeAvailabilityScore = constraintCheck.TimeAvailabilityScore ?? 0,
|
||
WorkLimitComplianceScore = constraintCheck.WorkLimitScore ?? 0,
|
||
ShiftRuleComplianceScore = constraintCheck.ShiftRuleScore ?? 0,
|
||
Violations = constraintCheck.Violations,
|
||
PassedConstraints = constraintCheck.PassedConstraints ?? new List<string>(),
|
||
ConstraintDetails = constraintCheck.EvaluationDetails
|
||
};
|
||
|
||
// 转换为Processors命名空间的类型
|
||
var processorsResult = new ConstraintEvaluationResult
|
||
{
|
||
Candidate = candidate,
|
||
IsValid = constraintCheck.IsValid,
|
||
ConstraintScore = constraintCheck.ConstraintScore,
|
||
Violations = constraintCheck.Violations?.Select(v => new ConstraintViolation
|
||
{
|
||
ViolationType = "General",
|
||
Description = v.Description,
|
||
Severity = ViolationSeverity.Warning
|
||
}).ToList() ?? new List<ConstraintViolation>(),
|
||
PassedConstraints = constraintCheck.PassedConstraints ?? new List<string>(),
|
||
EvaluationDetails = constraintCheck.EvaluationDetails,
|
||
RiskLevel = constraintCheck.ConstraintScore < 60 ? RiskLevel.High :
|
||
constraintCheck.ConstraintScore < 80 ? RiskLevel.Medium : RiskLevel.Low
|
||
};
|
||
|
||
evaluationResults.Add(processorsResult);
|
||
|
||
if (constraintCheck.IsValid)
|
||
{
|
||
totalPassed++;
|
||
}
|
||
}
|
||
|
||
constraintResults[workOrderId] = evaluationResults;
|
||
|
||
// 过滤掉不符合约束的候选人（约束符合度阈值60分）
|
||
context.FilteredCandidates[workOrderId] = candidates
|
||
.Where(c => c.ConstraintScore.ComplianceScore >= 60)
|
||
.ToList();
|
||
|
||
var passedCount = context.FilteredCandidates[workOrderId].Count;
|
||
context.ProcessingLog.Add(
|
||
$"任务 {workOrder.WorkOrderCode} 约束评估完成，通过：{passedCount}/{candidates.Count}");
|
||
}
|
||
|
||
context.ConstraintResults = constraintResults;
|
||
stopwatch.Stop();
|
||
|
||
context.ProcessingLog.Add(
|
||
$"约束评估完成，总评估：{totalEvaluated}，通过：{totalPassed}，耗时：{stopwatch.ElapsedMilliseconds}ms");
|
||
context.Metrics["ConstraintEvaluation_ExecutionTime"] = stopwatch.ElapsedMilliseconds;
|
||
context.Metrics["ConstraintEvaluation_EvaluatedCount"] = totalEvaluated;
|
||
context.Metrics["ConstraintEvaluation_PassedCount"] = totalPassed;
|
||
|
||
return new ProcessorResult
|
||
{
|
||
IsSuccess = true,
|
||
ProcessorName = "ConstraintEvaluation",
|
||
ExecutionTimeMs = stopwatch.ElapsedMilliseconds,
|
||
SuccessCount = totalPassed,
|
||
ProcessedCount = totalEvaluated,
|
||
Message = "约束评估处理成功"
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
stopwatch.Stop();
|
||
_logger.LogError(ex, "约束评估处理异常");
|
||
context.Errors.Add($"约束评估异常：{ex.Message}");
|
||
return new ProcessorResult
|
||
{
|
||
IsSuccess = false,
|
||
ProcessorName = "ConstraintEvaluation",
|
||
ExecutionTimeMs = stopwatch.ElapsedMilliseconds,
|
||
Message = $"约束评估处理失败：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行第三层：优化决策处理
|
||
/// </summary>
|
||
private async Task<ProcessorResult> ExecuteOptimizationDecisionAsync(AllocationContext context)
|
||
{
|
||
var stopwatch = Stopwatch.StartNew();
|
||
|
||
try
|
||
{
|
||
context.ProcessingLog.Add("开始优化决策处理");
|
||
|
||
// 内置优化决策实现
|
||
var optimizationResults = new Dictionary<long, List<OptimizationScoreResult>>();
|
||
var totalOptimized = 0;
|
||
|
||
foreach (var kvp in context.FilteredCandidates)
|
||
{
|
||
var workOrderId = kvp.Key;
|
||
var candidates = kvp.Value;
|
||
var workOrder = context.WorkOrders.First(w => w.Id == workOrderId);
|
||
|
||
var scoreResults = new List<OptimizationScoreResult>();
|
||
|
||
foreach (var candidate in candidates)
|
||
{
|
||
totalOptimized++;
|
||
|
||
// 计算优化评分
|
||
var optimizationScore = await CalculateOptimizationScoreAsync(candidate, workOrder, context);
|
||
|
||
// 更新候选人优化评分
|
||
candidate.OptimizationScore = new OptimizationScore
|
||
{
|
||
AssignedPersonnelScore =
|
||
optimizationScore.DimensionScores.GetValueOrDefault("AssignedPersonnel", 0),
|
||
|
||
ProjectFLScore = optimizationScore.DimensionScores.GetValueOrDefault("ProjectFL", 0),
|
||
|
||
WorkloadBalanceScore =
|
||
optimizationScore.DimensionScores.GetValueOrDefault("WorkloadBalance", 0),
|
||
|
||
ShiftContinuityScore =
|
||
optimizationScore.DimensionScores.GetValueOrDefault("ShiftContinuity", 0),
|
||
SkillMatchScore = optimizationScore.DimensionScores.GetValueOrDefault("SkillMatch", 0),
|
||
EfficiencyScore =
|
||
optimizationScore.DimensionScores.GetValueOrDefault("CollaborationHistory", 0),
|
||
OptimizationDetails = optimizationScore.OptimizationReason
|
||
};
|
||
|
||
candidate.DecisionScore = new DecisionScore
|
||
{
|
||
FinalScore = optimizationScore.OptimizationScore,
|
||
ConfidenceLevel = optimizationScore.Confidence,
|
||
RiskLevel = optimizationScore.RiskAssessment?.OverallRiskLevel ?? RiskLevel.Low,
|
||
DecisionReason = optimizationScore.OptimizationReason
|
||
};
|
||
|
||
// 计算综合总分
|
||
candidate.TotalScore = CalculateTotalScore(candidate, context.WeightConfiguration);
|
||
|
||
// 设置推荐等级和理由
|
||
candidate.RecommendationLevel = DetermineRecommendationLevel(candidate.TotalScore,
|
||
candidate.DecisionScore.ConfidenceLevel);
|
||
|
||
candidate.AllocationReason = GenerateAllocationReason(candidate);
|
||
|
||
scoreResults.Add(optimizationScore);
|
||
}
|
||
|
||
optimizationResults[workOrderId] = scoreResults;
|
||
|
||
// 对候选人按总分排序
|
||
context.FilteredCandidates[workOrderId] = candidates.OrderByDescending(c => c.TotalScore).ToList();
|
||
|
||
var bestScore = candidates.Any() ? candidates.Max(c => c.TotalScore) : 0;
|
||
context.ProcessingLog.Add($"任务 {workOrder.WorkOrderCode} 优化决策完成，最高评分：{bestScore:F1}");
|
||
}
|
||
|
||
context.OptimizationResults = optimizationResults;
|
||
stopwatch.Stop();
|
||
|
||
context.ProcessingLog.Add($"优化决策完成，总处理：{totalOptimized}，耗时：{stopwatch.ElapsedMilliseconds}ms");
|
||
context.Metrics["OptimizationDecision_ExecutionTime"] = stopwatch.ElapsedMilliseconds;
|
||
context.Metrics["OptimizationDecision_OptimizedCount"] = totalOptimized;
|
||
|
||
return new ProcessorResult
|
||
{
|
||
IsSuccess = true,
|
||
ProcessorName = "OptimizationDecision",
|
||
ExecutionTimeMs = stopwatch.ElapsedMilliseconds,
|
||
SuccessCount = totalOptimized,
|
||
ProcessedCount = totalOptimized,
|
||
Message = "优化决策处理成功"
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
stopwatch.Stop();
|
||
_logger.LogError(ex, "优化决策处理异常");
|
||
context.Errors.Add($"优化决策异常：{ex.Message}");
|
||
return new ProcessorResult
|
||
{
|
||
IsSuccess = false,
|
||
ProcessorName = "OptimizationDecision",
|
||
ExecutionTimeMs = stopwatch.ElapsedMilliseconds,
|
||
Message = $"优化决策处理失败：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行第四层：结果生成处理
|
||
/// </summary>
|
||
private async Task<ProcessorResult> ExecuteResultGenerationAsync(AllocationContext context)
|
||
{
|
||
var stopwatch = Stopwatch.StartNew();
|
||
|
||
try
|
||
{
|
||
context.ProcessingLog.Add("开始结果生成处理");
|
||
|
||
// 内置结果生成实现
|
||
var allocationResult = new AllocationGenerationResult
|
||
{
|
||
SuccessfulAllocations = new Dictionary<long, PersonnelCandidate>(),
|
||
FailedAllocations = new List<FailedAllocation>(),
|
||
DetailedReport = new AllocationReport()
|
||
};
|
||
|
||
foreach (var kvp in context.FilteredCandidates)
|
||
{
|
||
var workOrderId = kvp.Key;
|
||
var candidates = kvp.Value.OrderByDescending(c => c.TotalScore).ToList();
|
||
var workOrder = context.WorkOrders.First(w => w.Id == workOrderId);
|
||
|
||
if (candidates.Any())
|
||
{
|
||
// 选择最佳候选人
|
||
var bestCandidate = candidates.First();
|
||
bestCandidate.IsOptimalChoice = true;
|
||
bestCandidate.Rank = 1;
|
||
|
||
// 为其他候选人设置排名
|
||
for (int i = 1; i < candidates.Count; i++)
|
||
{
|
||
candidates[i].Rank = i + 1;
|
||
}
|
||
|
||
allocationResult.SuccessfulAllocations[workOrderId] = bestCandidate;
|
||
context.ProcessingLog.Add(
|
||
$"任务 {workOrder.WorkOrderCode} 分配成功，选择：{bestCandidate.PersonnelName}({bestCandidate.TotalScore:F1}分)");
|
||
}
|
||
else
|
||
{
|
||
// 记录分配失败
|
||
var failedAllocation = new FailedAllocation
|
||
{
|
||
WorkOrderId = workOrderId,
|
||
FailureReason = "无符合条件的候选人员",
|
||
FailureType = AllocationFailureType.NoAvailablePersonnel,
|
||
SuggestedSolutions = GenerateFailureSuggestions(workOrder)
|
||
};
|
||
|
||
allocationResult.FailedAllocations.Add(failedAllocation);
|
||
context.ProcessingLog.Add(
|
||
$"任务 {workOrder.WorkOrderCode} 分配失败：{failedAllocation.FailureReason}");
|
||
}
|
||
}
|
||
|
||
// 计算整体质量评分和生成报告
|
||
allocationResult.OverallQualityScore = CalculateOverallQualityScore(allocationResult);
|
||
allocationResult.AllocationSummary = GenerateAllocationSummary(allocationResult, context);
|
||
allocationResult.DetailedReport = GenerateDetailedReport(allocationResult, context);
|
||
|
||
// 记录性能指标
|
||
allocationResult.PerformanceMetrics = new Dictionary<string, object>(context.Metrics);
|
||
|
||
stopwatch.Stop();
|
||
context.Metrics["ResultGeneration_ExecutionTime"] = stopwatch.ElapsedMilliseconds;
|
||
|
||
var successCount = allocationResult.SuccessfulAllocations.Count;
|
||
var failureCount = allocationResult.FailedAllocations.Count;
|
||
context.ProcessingLog.Add(
|
||
$"结果生成完成，成功：{successCount}，失败：{failureCount}，耗时：{stopwatch.ElapsedMilliseconds}ms");
|
||
|
||
return new ProcessorResult
|
||
{
|
||
IsSuccess = true,
|
||
ProcessorName = "ResultGeneration",
|
||
ExecutionTimeMs = stopwatch.ElapsedMilliseconds,
|
||
SuccessCount = successCount,
|
||
FailureCount = failureCount,
|
||
ProcessedCount = context.WorkOrders.Count,
|
||
Message = "结果生成处理成功",
|
||
ResultData = allocationResult
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
stopwatch.Stop();
|
||
_logger.LogError(ex, "结果生成处理异常");
|
||
context.Errors.Add($"结果生成异常：{ex.Message}");
|
||
return new ProcessorResult
|
||
{
|
||
IsSuccess = false,
|
||
ProcessorName = "ResultGeneration",
|
||
ExecutionTimeMs = stopwatch.ElapsedMilliseconds,
|
||
Message = $"结果生成处理失败：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行第五层：最终验证和质量评估
|
||
/// </summary>
|
||
private async Task<PersonnelAllocationResult> ExecuteFinalValidationAsync(AllocationContext context,
|
||
AllocationGenerationResult generationResult)
|
||
{
|
||
try
|
||
{
|
||
context.ProcessingLog.Add("开始最终验证和质量评估");
|
||
|
||
var finalResult = new PersonnelAllocationResult
|
||
{
|
||
SuccessfulMatches = new List<TaskPersonnelMatch>(),
|
||
FailedAllocations = new List<FailedPersonnelAllocation>(),
|
||
WorkloadAnalysis = new List<PersonnelWorkloadAnalysis>()
|
||
};
|
||
|
||
// 转换成功分配
|
||
foreach (var kvp in generationResult.SuccessfulAllocations)
|
||
{
|
||
var workOrder = context.WorkOrders.First(w => w.Id == kvp.Key);
|
||
var candidate = kvp.Value;
|
||
|
||
finalResult.SuccessfulMatches.Add(new TaskPersonnelMatch
|
||
{
|
||
TaskId = kvp.Key,
|
||
TaskCode = workOrder.WorkOrderCode,
|
||
PersonnelId = candidate.PersonnelId,
|
||
PersonnelName = candidate.PersonnelName,
|
||
MatchScore = (int)Math.Round(candidate.TotalScore),
|
||
MatchReason = candidate.AllocationReason ?? "综合评分最优",
|
||
QualificationMatches = candidate.QualificationScore.MatchedQualifications,
|
||
EstimatedEfficiency = CalculateEstimatedEfficiency(candidate)
|
||
});
|
||
}
|
||
|
||
// 转换失败分配
|
||
foreach (var failedAllocation in generationResult.FailedAllocations)
|
||
{
|
||
var workOrder = context.WorkOrders.First(w => w.Id == failedAllocation.WorkOrderId);
|
||
finalResult.FailedAllocations.Add(new FailedPersonnelAllocation
|
||
{
|
||
TaskId = failedAllocation.WorkOrderId,
|
||
TaskCode = workOrder.WorkOrderCode,
|
||
FailureReason = failedAllocation.FailureReason,
|
||
ConflictDetails = failedAllocation.SuggestedSolutions
|
||
});
|
||
}
|
||
|
||
// 生成工作负载分析
|
||
finalResult.WorkloadAnalysis =
|
||
await GenerateWorkloadAnalysisAsync(generationResult.SuccessfulAllocations);
|
||
|
||
// 计算公平性评分
|
||
finalResult.FairnessScore = CalculateFairnessScore(finalResult.WorkloadAnalysis);
|
||
|
||
// 设置其他属性
|
||
finalResult.AllocationSummary = generationResult.AllocationSummary;
|
||
finalResult.AllocationStrategy = context.Strategy.ToString();
|
||
finalResult.ProcessingDetails = string.Join("; ", context.ProcessingLog);
|
||
|
||
// 兼容性验证结果
|
||
finalResult.ValidationResult = new
|
||
{
|
||
OverallScore = generationResult.OverallQualityScore,
|
||
ProcessingMetrics = context.Metrics,
|
||
ValidationPassed = !context.Errors.Any(),
|
||
ProcessingTime = context.Metrics.GetValueOrDefault("Total_ExecutionTime", 0),
|
||
QualityAssessment = new
|
||
{
|
||
AverageScore = generationResult.SuccessfulAllocations.Any()
|
||
? generationResult.SuccessfulAllocations.Values.Average(c => c.TotalScore)
|
||
: 0,
|
||
SuccessRate = (double)generationResult.SuccessfulAllocations.Count / context.WorkOrders.Count *
|
||
100,
|
||
FairnessScore = finalResult.FairnessScore
|
||
}
|
||
};
|
||
|
||
context.ProcessingLog.Add(
|
||
$"最终验证完成，成功分配：{finalResult.SuccessfulMatches.Count}，失败：{finalResult.FailedAllocations.Count}，公平性评分：{finalResult.FairnessScore}");
|
||
|
||
return finalResult;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "最终验证异常");
|
||
return CreateFailureResult($"最终验证失败：{ex.Message}");
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 执行第一层：资格过滤辅助方法
|
||
|
||
/// <summary>
|
||
/// 获取工序资质要求
|
||
/// </summary>
|
||
private string[] GetRequiredQualifications(WorkOrderEntity workOrder)
|
||
{
|
||
if (workOrder.ProcessEntity?.QualificationRequirements == null)
|
||
return new string[0];
|
||
|
||
return workOrder.ProcessEntity.QualificationRequirements
|
||
.Split(',', StringSplitOptions.RemoveEmptyEntries)
|
||
.Select(q => q.Trim())
|
||
.Where(q => !string.IsNullOrEmpty(q))
|
||
.ToArray();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成分配理由
|
||
/// </summary>
|
||
private string GenerateAllocationReason(PersonnelCandidate candidate)
|
||
{
|
||
var reasons = new List<string>();
|
||
|
||
// 资质匹配
|
||
if (candidate.QualificationScore.MatchScore >= 90)
|
||
reasons.Add("资质完全匹配");
|
||
else if (candidate.QualificationScore.MatchScore >= 70)
|
||
reasons.Add("资质基本符合");
|
||
|
||
// 约束符合
|
||
if (candidate.ConstraintScore.ComplianceScore >= 90)
|
||
reasons.Add("约束条件优秀");
|
||
else if (candidate.ConstraintScore.ComplianceScore >= 70)
|
||
reasons.Add("约束条件良好");
|
||
|
||
// 优化评分
|
||
if (candidate.OptimizationScore != null)
|
||
{
|
||
if (candidate.OptimizationScore.AssignedPersonnelScore > 80)
|
||
reasons.Add("指定人员匹配");
|
||
if (candidate.OptimizationScore.ProjectFLScore > 80)
|
||
reasons.Add("项目FL人员");
|
||
if (candidate.OptimizationScore.WorkloadBalanceScore > 80)
|
||
reasons.Add("负载均衡良好");
|
||
}
|
||
|
||
// 综合评分
|
||
reasons.Add($"综合评分{candidate.TotalScore:F1}分");
|
||
|
||
return string.Join("；", reasons);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成失败建议
|
||
/// </summary>
|
||
private List<string> GenerateFailureSuggestions(WorkOrderEntity workOrder)
|
||
{
|
||
var suggestions = new List<string>();
|
||
|
||
// 基于工序特点给出建议
|
||
if (!string.IsNullOrEmpty(workOrder.ProcessEntity?.QualificationRequirements))
|
||
{
|
||
suggestions.Add("考虑放宽资质要求或安排人员培训");
|
||
}
|
||
|
||
suggestions.Add("调整任务时间安排");
|
||
suggestions.Add("增加临时人员或外包");
|
||
suggestions.Add("与其他项目协调人员调配");
|
||
|
||
return suggestions;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成详细报告
|
||
/// </summary>
|
||
private AllocationReport GenerateDetailedReport(AllocationGenerationResult result, AllocationContext context)
|
||
{
|
||
var report = new AllocationReport
|
||
{
|
||
SuccessfulAllocationCount = result.SuccessfulAllocations.Count,
|
||
FailedAllocationCount = result.FailedAllocations.Count,
|
||
SuccessRate = context.WorkOrders.Count > 0
|
||
? (double)result.SuccessfulAllocations.Count / context.WorkOrders.Count * 100
|
||
: 0
|
||
};
|
||
|
||
if (result.SuccessfulAllocations.Any())
|
||
{
|
||
report.AverageQualityScore = result.SuccessfulAllocations.Values.Average(c => c.TotalScore);
|
||
}
|
||
|
||
// 人员利用率分析
|
||
report.PersonnelUtilizationRate = result.SuccessfulAllocations.Values
|
||
.GroupBy(c => c.PersonnelId)
|
||
.ToDictionary(g => g.Key, g => (double)g.Count());
|
||
|
||
// 风险分析
|
||
report.RiskAnalysis = new RiskAnalysis
|
||
{
|
||
OverallRiskScore = result.SuccessfulAllocations.Values
|
||
.Where(c => c.DecisionScore?.RiskLevel != null)
|
||
.Average(c => (int)c.DecisionScore.RiskLevel) * 25, // 转换为百分比
|
||
|
||
RiskDistribution = result.SuccessfulAllocations.Values
|
||
.Where(c => c.DecisionScore?.RiskLevel != null)
|
||
.GroupBy(c => c.DecisionScore.RiskLevel)
|
||
.ToDictionary(g => g.Key, g => g.Count())
|
||
};
|
||
|
||
return report;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查人员基础资格（第一层决策的基础筛选）
|
||
/// 深度架构思考：在资格过滤层进行人员基础状态检查，符合五层决策模型设计
|
||
/// </summary>
|
||
private async Task<PersonnelEligibilityResult> IsPersonnelBasicallyEligibleAsync(PersonnelEntity personnel)
|
||
{
|
||
try
|
||
{
|
||
var result = new PersonnelEligibilityResult
|
||
{
|
||
PersonnelId = personnel.Id,
|
||
IsEligible = true,
|
||
EligibilityReasons = new List<string>()
|
||
};
|
||
|
||
// 1. 检查人员基础信息完整性
|
||
if (string.IsNullOrEmpty(personnel.PersonnelName))
|
||
{
|
||
result.IsEligible = false;
|
||
result.EligibilityReasons.Add("人员基础信息不完整");
|
||
return result;
|
||
}
|
||
|
||
// 通过基础资格检查
|
||
result.EligibilityReasons.Add("基础资格检查通过");
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "检查人员基础资格异常，人员ID：{PersonnelId}", personnel.Id);
|
||
return new PersonnelEligibilityResult
|
||
{
|
||
PersonnelId = personnel.Id,
|
||
IsEligible = false,
|
||
EligibilityReasons = new List<string> { $"基础资格检查异常：{ex.Message}" }
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查资质匹配
|
||
/// </summary>
|
||
private async Task<QualificationMatchResult> CheckQualificationMatchAsync(long personnelId,
|
||
string[] requiredQualifications)
|
||
{
|
||
try
|
||
{
|
||
if (requiredQualifications == null || !requiredQualifications.Any())
|
||
{
|
||
return new QualificationMatchResult
|
||
{
|
||
IsMatched = true,
|
||
IsValid = true,
|
||
MatchScore = 100,
|
||
MatchedQualifications = new List<string>(),
|
||
MissingQualifications = new List<string>(),
|
||
Details = "无特殊资质要求"
|
||
};
|
||
}
|
||
|
||
// 获取人员资质
|
||
var personnelQualifications = await GetPersonnelQualificationsAsync(personnelId);
|
||
var validQualificationIds = personnelQualifications
|
||
.Where(q => q.ExpiryDate == null || q.ExpiryDate > DateTime.Now)
|
||
.Select(q => q.QualificationId.ToString())
|
||
.ToList();
|
||
|
||
var matchedQualifications = requiredQualifications.Intersect(validQualificationIds).ToList();
|
||
var missingQualifications = requiredQualifications.Except(validQualificationIds).ToList();
|
||
|
||
var matchScore = requiredQualifications.Length > 0
|
||
? (double)matchedQualifications.Count / requiredQualifications.Length * 100
|
||
: 100;
|
||
|
||
return new QualificationMatchResult
|
||
{
|
||
IsMatched = matchedQualifications.Any() || !requiredQualifications.Any(),
|
||
IsValid = !missingQualifications.Any(),
|
||
MatchScore = matchScore,
|
||
MatchedQualifications = matchedQualifications,
|
||
MissingQualifications = missingQualifications,
|
||
Details =
|
||
$"匹配资质：{matchedQualifications.Count}/{requiredQualifications.Length}，匹配度：{matchScore:F1}%"
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "检查资质匹配异常，人员ID：{PersonnelId}", personnelId);
|
||
return new QualificationMatchResult
|
||
{
|
||
IsMatched = false,
|
||
IsValid = false,
|
||
MatchScore = 0,
|
||
MatchedQualifications = new List<string>(),
|
||
MissingQualifications = requiredQualifications?.ToList() ?? new List<string>(),
|
||
Details = $"资质检查异常：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取人员资质列表
|
||
/// </summary>
|
||
private async Task<List<NPP.SmartSchedue.Api.Contracts.Domain.Personnel.PersonnelQualificationEntity>>
|
||
GetPersonnelQualificationsAsync(long personnelId)
|
||
{
|
||
try
|
||
{
|
||
return await _personnelQualificationService.GetPersonnelQualificationsAsync(personnelId);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "获取人员资质异常，人员ID：{PersonnelId}", personnelId);
|
||
return new List<NPP.SmartSchedue.Api.Contracts.Domain.Personnel.PersonnelQualificationEntity>();
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 执行第二层：约束评估处理辅助方法
|
||
|
||
/// <summary>
|
||
/// 评估候选人约束条件
|
||
/// 深度业务思考：全面检查时间可用性、工作限制、班次规则等多维度约束
|
||
/// </summary>
|
||
private async Task<ConstraintEvaluationResult> EvaluateCandidateConstraintsAsync(PersonnelCandidate candidate,
|
||
WorkOrderEntity workOrder)
|
||
{
|
||
var result = new ConstraintEvaluationResult
|
||
{
|
||
Candidate = candidate,
|
||
IsValid = true,
|
||
PassedConstraints = new List<string>(),
|
||
Violations = new List<ConstraintViolation>()
|
||
};
|
||
|
||
try
|
||
{
|
||
var scores = new List<double>();
|
||
|
||
// 1. 时间可用性检查
|
||
var timeAvailability = await CheckTimeAvailabilityAsync(candidate.PersonnelId, workOrder.WorkOrderDate,
|
||
workOrder.ShiftId ?? 0);
|
||
|
||
result.TimeAvailabilityScore = timeAvailability.Score;
|
||
scores.Add(timeAvailability.Score);
|
||
|
||
if (timeAvailability.IsAvailable)
|
||
{
|
||
result.PassedConstraints.Add("时间可用性检查");
|
||
}
|
||
else
|
||
{
|
||
result.Violations.Add(new ConstraintViolation()
|
||
{
|
||
Severity = ViolationSeverity.High,
|
||
IsBlockingIssue = true,
|
||
CanOverrideWithApproval = false,
|
||
Description = $"时间不可用：{timeAvailability.Reason}"
|
||
});
|
||
|
||
if (timeAvailability.Score == 0)
|
||
{
|
||
result.IsValid = false;
|
||
}
|
||
}
|
||
|
||
// 2. 工作限制检查
|
||
var workLimitCheck = await CheckWorkLimitAsync(candidate.PersonnelId, workOrder.WorkOrderDate);
|
||
result.WorkLimitScore = workLimitCheck.Score;
|
||
scores.Add(workLimitCheck.Score);
|
||
|
||
if (workLimitCheck.IsCompliant)
|
||
{
|
||
result.PassedConstraints.Add("工作限制检查");
|
||
}
|
||
else
|
||
{
|
||
result.Violations.Add(new ConstraintViolation()
|
||
{
|
||
Severity = ViolationSeverity.High,
|
||
IsBlockingIssue = true,
|
||
CanOverrideWithApproval = false,
|
||
Description = $"工作限制违规：{workLimitCheck.Reason}"
|
||
});
|
||
|
||
if (timeAvailability.Score == 0)
|
||
{
|
||
result.IsValid = false;
|
||
}
|
||
|
||
if (workLimitCheck.Severity == "Critical")
|
||
{
|
||
result.IsValid = false;
|
||
}
|
||
}
|
||
|
||
// 3. 班次规则检查
|
||
var shiftRuleCheck = await CheckShiftRulesAsync(candidate.PersonnelId, workOrder.WorkOrderDate,
|
||
workOrder.ShiftId ?? 0);
|
||
|
||
result.ShiftRuleScore = shiftRuleCheck.Score;
|
||
scores.Add(shiftRuleCheck.Score);
|
||
|
||
if (shiftRuleCheck.IsCompliant)
|
||
{
|
||
result.PassedConstraints.Add("班次规则检查");
|
||
}
|
||
else
|
||
{
|
||
result.Violations.Add(new ConstraintViolation()
|
||
{
|
||
Severity = ViolationSeverity.Medium,
|
||
IsBlockingIssue = true,
|
||
CanOverrideWithApproval = false,
|
||
Description = $"班次规则违规：{shiftRuleCheck.Reason}"
|
||
});
|
||
|
||
if (shiftRuleCheck.IsCritical)
|
||
{
|
||
result.IsValid = false;
|
||
}
|
||
}
|
||
|
||
// 计算综合约束评分
|
||
result.ConstraintScore = scores.Any() ? scores.Average() : 0;
|
||
|
||
// 生成评估详情
|
||
result.EvaluationDetails = GenerateConstraintEvaluationDetails(result, scores);
|
||
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "约束评估异常，候选人：{PersonnelId}，任务：{WorkOrderId}",
|
||
candidate.PersonnelId, workOrder.Id);
|
||
|
||
result.IsValid = false;
|
||
result.ConstraintScore = 0;
|
||
result.EvaluationDetails = $"约束评估异常：{ex.Message}";
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成约束评估详情
|
||
/// </summary>
|
||
private string GenerateConstraintEvaluationDetails(ConstraintEvaluationResult result, List<double> scores)
|
||
{
|
||
var details = new List<string>
|
||
{
|
||
$"约束评分：{result.ConstraintScore:F1}分",
|
||
$"通过检查：{result.PassedConstraints.Count}项",
|
||
$"违规项目：{result.Violations.Count}项"
|
||
};
|
||
|
||
if (result.TimeAvailabilityScore.HasValue)
|
||
details.Add($"时间可用性：{result.TimeAvailabilityScore.Value:F1}分");
|
||
if (result.WorkLimitScore.HasValue)
|
||
details.Add($"工作限制：{result.WorkLimitScore.Value:F1}分");
|
||
if (result.ShiftRuleScore.HasValue)
|
||
details.Add($"班次规则：{result.ShiftRuleScore.Value:F1}分");
|
||
|
||
// 评估等级
|
||
var evaluationLevel = result.ConstraintScore switch
|
||
{
|
||
>= 90 => "优秀",
|
||
>= 80 => "良好",
|
||
>= 70 => "一般",
|
||
>= 60 => "勉强",
|
||
_ => "不合格"
|
||
};
|
||
|
||
details.Add($"评估等级：{evaluationLevel}");
|
||
|
||
return string.Join("；", details);
|
||
}
|
||
|
||
#region 约束检查方法
|
||
|
||
/// <summary>
|
||
/// 检查时间可用性
|
||
/// </summary>
|
||
private async Task<TimeAvailabilityResult> CheckTimeAvailabilityAsync(long personnelId, DateTime workDate,
|
||
long shiftId)
|
||
{
|
||
try
|
||
{
|
||
// 检查是否在请假期间
|
||
var leaveInfo = await _employeeLeaveService.IsOnLeaveAsync(personnelId, workDate);
|
||
if (leaveInfo.IsOnLeave)
|
||
{
|
||
return new TimeAvailabilityResult
|
||
{
|
||
IsAvailable = false,
|
||
Score = 0,
|
||
Reason = $"人员在请假期间：{leaveInfo.LeaveType}"
|
||
};
|
||
}
|
||
|
||
// 检查是否已有其他任务分配
|
||
var existingTasks = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId &&
|
||
w.WorkOrderDate.Date == workDate.Date &&
|
||
w.ShiftId == shiftId &&
|
||
w.Status > (int)WorkOrderStatusEnum.PendingReview)
|
||
.CountAsync();
|
||
|
||
if (existingTasks > 0)
|
||
{
|
||
return new TimeAvailabilityResult
|
||
{
|
||
IsAvailable = false,
|
||
Score = 0,
|
||
Reason = $"该时间段已有{existingTasks}个任务分配"
|
||
};
|
||
}
|
||
|
||
return new TimeAvailabilityResult
|
||
{
|
||
IsAvailable = true,
|
||
Score = 100,
|
||
Reason = "时间完全可用"
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "检查时间可用性异常，人员ID：{PersonnelId}，日期：{WorkDate}", personnelId, workDate);
|
||
return new TimeAvailabilityResult
|
||
{
|
||
IsAvailable = false,
|
||
Score = 0,
|
||
Reason = $"时间检查异常：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查工作限制
|
||
/// </summary>
|
||
private async Task<WorkLimitResult> CheckWorkLimitAsync(long personnelId, DateTime workDate)
|
||
{
|
||
try
|
||
{
|
||
var workLimits = await _personnelWorkLimitService.GetByPersonnelIdAsync(personnelId);
|
||
if (workLimits == null || !workLimits.Any())
|
||
{
|
||
return new WorkLimitResult
|
||
{
|
||
IsCompliant = true,
|
||
Score = 100,
|
||
Reason = "无工作限制配置",
|
||
Severity = "Info"
|
||
};
|
||
}
|
||
|
||
// 选择第一个工作限制记录
|
||
var workLimit = workLimits.First();
|
||
|
||
var violations = new List<string>();
|
||
var scores = new List<double>();
|
||
|
||
// 检查连续工作天数限制
|
||
var continuousWorkDays = await CalculateContinuousWorkDaysAsync(personnelId, workDate);
|
||
if (workLimit.MaxContinuousWorkDays.HasValue &&
|
||
continuousWorkDays >= workLimit.MaxContinuousWorkDays.Value)
|
||
{
|
||
violations.Add($"连续工作天数({continuousWorkDays}) 超过限制({workLimit.MaxContinuousWorkDays.Value})");
|
||
scores.Add(0);
|
||
}
|
||
else
|
||
{
|
||
var continuousScore = workLimit.MaxContinuousWorkDays.HasValue
|
||
? Math.Max(0, 100 - (continuousWorkDays / (double)workLimit.MaxContinuousWorkDays.Value * 100))
|
||
: 100;
|
||
scores.Add(continuousScore);
|
||
}
|
||
|
||
// 检查周班次数限制
|
||
var weekShiftCount = await CalculateWeekShiftCountAsync(personnelId, workDate);
|
||
if (workLimit.MaxShiftsPerWeek.HasValue && weekShiftCount >= workLimit.MaxShiftsPerWeek.Value)
|
||
{
|
||
violations.Add($"周班次数({weekShiftCount})超过限制({workLimit.MaxShiftsPerWeek.Value})");
|
||
scores.Add(0);
|
||
}
|
||
else
|
||
{
|
||
var weekScore = workLimit.MaxShiftsPerWeek.HasValue
|
||
? Math.Max(0, 100 - (weekShiftCount / (double)workLimit.MaxShiftsPerWeek.Value * 100))
|
||
: 100;
|
||
scores.Add(weekScore);
|
||
}
|
||
|
||
var averageScore = scores.Any() ? scores.Average() : 100;
|
||
var isCompliant = !violations.Any();
|
||
|
||
return new WorkLimitResult
|
||
{
|
||
IsCompliant = isCompliant,
|
||
Score = averageScore,
|
||
Reason = violations.Any() ? string.Join("; ", violations) : "符合所有工作限制",
|
||
Severity = violations.Any() ? "Warning" : "Info"
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "检查工作限制异常，人员ID：{PersonnelId}", personnelId);
|
||
return new WorkLimitResult
|
||
{
|
||
IsCompliant = false,
|
||
Score = 0,
|
||
Reason = $"工作限制检查异常：{ex.Message}",
|
||
Severity = "Error"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查班次规则
|
||
/// </summary>
|
||
private async Task<ShiftRuleResult> CheckShiftRulesAsync(long personnelId, DateTime workDate, long shiftId)
|
||
{
|
||
try
|
||
{
|
||
// 获取班次规则配置
|
||
var shiftRules = await _shiftService.GetShiftRulesAsync(shiftId);
|
||
if (shiftRules == null || !shiftRules.Any())
|
||
{
|
||
return new ShiftRuleResult
|
||
{
|
||
IsCompliant = true,
|
||
Score = 100,
|
||
Reason = "无班次规则配置",
|
||
IsCritical = false
|
||
};
|
||
}
|
||
|
||
var violations = new List<string>();
|
||
var scores = new List<double>();
|
||
var criticalViolations = new List<string>();
|
||
|
||
foreach (var rule in shiftRules.Where(r => r.IsEnabled))
|
||
{
|
||
var ruleResult = await ValidateIndividualShiftRuleAsync(rule, personnelId, workDate, shiftId);
|
||
if (!ruleResult.IsValid)
|
||
{
|
||
violations.Add($"规则{rule.RuleName}：{ruleResult.ViolationMessage}");
|
||
if (ruleResult.IsCritical)
|
||
{
|
||
criticalViolations.Add(ruleResult.ViolationMessage);
|
||
}
|
||
}
|
||
|
||
scores.Add(ruleResult.ComplianceScore);
|
||
}
|
||
|
||
var averageScore = scores.Any() ? scores.Average() : 100;
|
||
var hasCriticalViolation = criticalViolations.Any();
|
||
|
||
return new ShiftRuleResult
|
||
{
|
||
IsCompliant = !violations.Any() || (!hasCriticalViolation && averageScore >= 50),
|
||
Score = averageScore,
|
||
Reason = violations.Any() ? string.Join("; ", violations) : "符合所有班次规则",
|
||
IsCritical = hasCriticalViolation
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "检查班次规则异常，人员ID：{PersonnelId}", personnelId);
|
||
return new ShiftRuleResult
|
||
{
|
||
IsCompliant = false,
|
||
Score = 0,
|
||
Reason = $"班次规则检查异常：{ex.Message}",
|
||
IsCritical = true
|
||
};
|
||
}
|
||
}
|
||
|
||
#region ?????
|
||
|
||
/// <summary>
|
||
/// 验证人员资质
|
||
/// </summary>
|
||
private async Task<NPP.SmartSchedue.Api.Contracts.Services.Integration.Output.ValidationResult> ValidatePersonnelQualificationAsync(long workOrderId, long personnelId)
|
||
{
|
||
try
|
||
{
|
||
var workOrder = await _workOrderRepository.GetAsync(workOrderId);
|
||
if (workOrder?.ProcessEntity?.QualificationRequirements == null)
|
||
{
|
||
return new ValidationResult
|
||
{
|
||
IsValid = true,
|
||
Violations = new List<ValidationViolation>()
|
||
};
|
||
}
|
||
|
||
var requiredQualifications = workOrder.ProcessEntity.QualificationRequirements.Split(',');
|
||
var qualificationMatch = await CheckQualificationMatchAsync(personnelId, requiredQualifications);
|
||
|
||
if (qualificationMatch.IsMatched)
|
||
{
|
||
return new ValidationResult
|
||
{
|
||
IsValid = true,
|
||
Violations = new List<ValidationViolation>()
|
||
};
|
||
}
|
||
|
||
return new ValidationResult
|
||
{
|
||
IsValid = false,
|
||
Violations = new List<ValidationViolation>
|
||
{
|
||
new ValidationViolation
|
||
{
|
||
ViolationType = ViolationType.QualificationMismatch.ToString(),
|
||
Severity = ViolationSeverity.Error,
|
||
Description = $"人员资质不匹配，缺失：{string.Join(",", qualificationMatch.MissingQualifications)}"
|
||
}
|
||
}
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "验证人员资质异常，任务：{WorkOrderId}，人员：{PersonnelId}", workOrderId, personnelId);
|
||
return new ValidationResult
|
||
{
|
||
IsValid = false,
|
||
Violations = new List<ValidationViolation>
|
||
{
|
||
new ValidationViolation
|
||
{
|
||
ViolationType = ViolationType.QualificationMismatch.ToString(),
|
||
Severity = ViolationSeverity.Critical,
|
||
Description = $"资质验证异常：{ex.Message}"
|
||
}
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证时间冲突
|
||
/// </summary>
|
||
private async Task<NPP.SmartSchedue.Api.Contracts.Services.Integration.Output.ValidationResult> ValidateTimeConflictAsync(long personnelId, DateTime assignmentDate,
|
||
long shiftId)
|
||
{
|
||
try
|
||
{
|
||
var timeAvailability = await CheckTimeAvailabilityAsync(personnelId, assignmentDate, shiftId);
|
||
|
||
if (timeAvailability.IsAvailable)
|
||
{
|
||
return new ValidationResult
|
||
{
|
||
IsValid = true,
|
||
Violations = new List<ValidationViolation>()
|
||
};
|
||
}
|
||
|
||
return new ValidationResult
|
||
{
|
||
IsValid = false,
|
||
Violations = new List<ValidationViolation>
|
||
{
|
||
new ValidationViolation
|
||
{
|
||
ViolationType = ViolationType.TimeConflict.ToString(),
|
||
Severity = ViolationSeverity.Error,
|
||
Description = timeAvailability.Reason
|
||
}
|
||
}
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "验证时间冲突异常，人员：{PersonnelId}", personnelId);
|
||
return new ValidationResult
|
||
{
|
||
IsValid = false,
|
||
Violations = new List<ValidationViolation>
|
||
{
|
||
new ValidationViolation
|
||
{
|
||
ViolationType = ViolationType.TimeConflict.ToString(),
|
||
Severity = ViolationSeverity.Critical,
|
||
Description = $"时间冲突验证异常：{ex.Message}"
|
||
}
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证工作限制
|
||
/// </summary>
|
||
private async Task<NPP.SmartSchedue.Api.Contracts.Services.Integration.Output.ValidationResult> ValidateWorkLimitAsync(long personnelId, DateTime assignmentDate)
|
||
{
|
||
try
|
||
{
|
||
var workLimitResult = await CheckWorkLimitAsync(personnelId, assignmentDate);
|
||
|
||
if (workLimitResult.IsCompliant)
|
||
{
|
||
return new ValidationResult
|
||
{
|
||
IsValid = true,
|
||
Violations = new List<ValidationViolation>()
|
||
};
|
||
}
|
||
|
||
var severity = workLimitResult.Severity switch
|
||
{
|
||
"Critical" => ViolationSeverity.Critical,
|
||
"Error" => ViolationSeverity.Error,
|
||
"Warning" => ViolationSeverity.Warning,
|
||
_ => ViolationSeverity.Info
|
||
};
|
||
|
||
return new ValidationResult
|
||
{
|
||
IsValid = severity < ViolationSeverity.Error,
|
||
Violations = new List<ValidationViolation>
|
||
{
|
||
new ValidationViolation
|
||
{
|
||
ViolationType = ViolationType.WorkloadExceeded.ToString(),
|
||
Severity = severity,
|
||
Description = workLimitResult.Reason
|
||
}
|
||
}
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "验证工作限制异常，人员：{PersonnelId}", personnelId);
|
||
return new ValidationResult
|
||
{
|
||
IsValid = false,
|
||
Violations = new List<ValidationViolation>
|
||
{
|
||
new ValidationViolation
|
||
{
|
||
ViolationType = ViolationType.WorkloadExceeded.ToString(),
|
||
Severity = ViolationSeverity.Critical,
|
||
Description = $"工作限制验证异常：{ex.Message}"
|
||
}
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证班次规则
|
||
/// </summary>
|
||
private async Task<NPP.SmartSchedue.Api.Contracts.Services.Integration.Output.ValidationResult> ValidateShiftRuleAsync(long personnelId, DateTime assignmentDate,
|
||
long shiftId)
|
||
{
|
||
try
|
||
{
|
||
var shiftRuleResult = await CheckShiftRulesAsync(personnelId, assignmentDate, shiftId);
|
||
|
||
if (shiftRuleResult.IsCompliant)
|
||
{
|
||
return new ValidationResult
|
||
{
|
||
IsValid = true,
|
||
Violations = new List<ValidationViolation>()
|
||
};
|
||
}
|
||
|
||
var severity = shiftRuleResult.IsCritical ? ViolationSeverity.Critical : ViolationSeverity.Warning;
|
||
|
||
return new ValidationResult
|
||
{
|
||
IsValid = !shiftRuleResult.IsCritical,
|
||
Violations = new List<ValidationViolation>
|
||
{
|
||
new ValidationViolation
|
||
{
|
||
ViolationType = ViolationType.ShiftRuleViolation.ToString(),
|
||
Severity = severity,
|
||
Description = shiftRuleResult.Reason
|
||
}
|
||
}
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "验证班次规则异常，人员：{PersonnelId}", personnelId);
|
||
return new ValidationResult
|
||
{
|
||
IsValid = false,
|
||
Violations = new List<ValidationViolation>
|
||
{
|
||
new ValidationViolation
|
||
{
|
||
ViolationType = ViolationType.ShiftRuleViolation.ToString(),
|
||
Severity = ViolationSeverity.Critical,
|
||
Description = $"班次规则验证异常：{ex.Message}"
|
||
}
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
|
||
#region 检查班次规则实现
|
||
|
||
/// <summary>
|
||
/// 验证个人班次规则
|
||
/// 深度业务思考：基于规则类型、参数和时间有效性进行全面验证
|
||
/// </summary>
|
||
private async Task<RuleValidationResult> ValidateIndividualShiftRuleAsync(ShiftRuleEntity rule,
|
||
long personnelId, DateTime workDate, long shiftId)
|
||
{
|
||
try
|
||
{
|
||
if (!rule.IsEnabled)
|
||
{
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true, // 规则不生效，视为通过
|
||
ComplianceScore = 100.0,
|
||
IsCritical = false,
|
||
ViolationMessage = $"规则'{rule.RuleName}'在此时间段不生效"
|
||
};
|
||
}
|
||
|
||
// 根据规则类型进行详细验证
|
||
var result = rule.RuleType switch
|
||
{
|
||
"1" => await ValidateAssignedPersonnelPriorityRuleAsync(personnelId, workDate), // 指定人员优先
|
||
"2" => await ValidateWeeklyTaskLimitRuleAsync(personnelId, workDate),
|
||
"3" => await ValidateShiftContinuityRuleAsync(personnelId, workDate, shiftId, 3), // 1->2班
|
||
"4" => await ValidateShiftContinuityRuleAsync(personnelId, workDate, shiftId, 4), // 2->3班
|
||
"5" => await ValidateCrossWeekendContinuityRuleAsync(personnelId, workDate, shiftId, 5), // 不能这周日/下周六连
|
||
"6" => await ValidateCrossWeekendContinuityRuleAsync(personnelId, workDate, shiftId, 6), // 不能本周六/本周日连
|
||
"7" => await ValidateContinuousWorkDaysRuleAsync(personnelId, workDate, new Dictionary<string, object>()), // 连续工作天数
|
||
"8" => await ValidateNextDayRestRuleAsync(personnelId, workDate, shiftId, 8), // 三班后一天不排班
|
||
"9" => await ValidateNextDayRestRuleAsync(personnelId, workDate, shiftId, 9), // 二班后一天不排班
|
||
"10" => await ValidateProjectFLPriorityRuleAsync(personnelId, workDate, shiftId, rule), // 优先分配本项目FL
|
||
|
||
_ => await ValidateDefaultRuleAsync(personnelId, workDate, rule, new Dictionary<string, object>()) // 默认规则验证
|
||
};
|
||
|
||
// 记录规则验证详情
|
||
_logger.LogDebug("规则验证完成 - 规则：{RuleName}({RuleType})，人员：{PersonnelId}，结果：{IsValid}，评分：{Score}",
|
||
rule.RuleName, rule.RuleType, personnelId, result.IsValid, result.ComplianceScore);
|
||
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "验证班次规则异常，规则：{RuleName}({RuleType})，人员：{PersonnelId}",
|
||
rule.RuleName, rule.RuleType, personnelId);
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = false,
|
||
ComplianceScore = 0,
|
||
IsCritical = true,
|
||
ViolationMessage = $"规则'{rule.RuleName}'验证异常：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
#region 规则验证方法
|
||
/// <summary>
|
||
/// 验证指定人员优先规则
|
||
/// </summary>
|
||
private async Task<RuleValidationResult> ValidateAssignedPersonnelPriorityRuleAsync(long personnelId,
|
||
DateTime workDate)
|
||
{
|
||
// 检查是否存在指定人员分配
|
||
var hasAssignedTask = await _workOrderRepository.Select
|
||
.AnyAsync(w => w.AssignedPersonnelId == personnelId &&
|
||
w.WorkOrderDate.Date == workDate.Date);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true, // 这个规则通常不会阻断，只是影响评分
|
||
ComplianceScore = hasAssignedTask ? 100.0 : 80.0,
|
||
IsCritical = false,
|
||
ViolationMessage = hasAssignedTask ? "" : "非指定人员，优先级稍低"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证周任务限制规则
|
||
/// </summary>
|
||
private async Task<RuleValidationResult> ValidateWeeklyTaskLimitRuleAsync(long personnelId, DateTime workDate)
|
||
{
|
||
var maxWeeklyShifts = 6;
|
||
var weekShiftCount = await CalculateWeekShiftCountAsync(personnelId, workDate);
|
||
|
||
var isValid = weekShiftCount <= maxWeeklyShifts;
|
||
var complianceScore = isValid ? Math.Max(0, 100 - (weekShiftCount / (double)maxWeeklyShifts * 100)) : 0;
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = isValid,
|
||
ComplianceScore = complianceScore,
|
||
IsCritical = !isValid,
|
||
ViolationMessage = isValid ? "" : $"周班次数({weekShiftCount})超过限制({maxWeeklyShifts})"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证同一天内班次连续性规则
|
||
/// 深度业务思考：检查同一天内是否存在不合理的班次连续安排
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="workDate">当前工作日期</param>
|
||
/// <param name="shiftId">当前班次ID</param>
|
||
/// <param name="ruleType">规则类型（3：同天早中班连续性，4：同天中晚班连续性）</param>
|
||
/// <returns>规则验证结果，包含合规状态、评分和详细说明</returns>
|
||
private async Task<RuleValidationResult> ValidateShiftContinuityRuleAsync(long personnelId, DateTime workDate,
|
||
long shiftId, int ruleType)
|
||
{
|
||
try
|
||
{
|
||
// 第一步：检查当天是否已有相同班次的任务分配（防重复分配）
|
||
var hasDuplicateShift = await CheckDuplicateShiftOnSameDateAsync(personnelId, workDate, shiftId);
|
||
if (hasDuplicateShift)
|
||
{
|
||
_logger.LogWarning("班次重复分配违规 - 人员ID:{PersonnelId}, 日期:{Date}, 班次ID:{ShiftId}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = false,
|
||
ComplianceScore = 0,
|
||
IsCritical = true,
|
||
ViolationMessage = "该人员当天已有相同班次的任务分配，不能重复分配"
|
||
};
|
||
}
|
||
|
||
// 第二步：获取当前要分配班次的编号
|
||
var currentShiftNumber = await GetShiftNumberByIdAsync(shiftId);
|
||
if (!currentShiftNumber.HasValue)
|
||
{
|
||
_logger.LogWarning("无法获取班次编号 - 班次ID:{ShiftId}", shiftId);
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = false,
|
||
ComplianceScore = 0,
|
||
IsCritical = true,
|
||
ViolationMessage = $"无法获取班次ID {shiftId} 对应的班次编号"
|
||
};
|
||
}
|
||
|
||
// 第三步：获取当天已分配的所有班次编号
|
||
var todayShiftNumbers = await GetPersonnelAllShiftNumbersOnDateAsync(personnelId, workDate);
|
||
|
||
// 如果当天无其他班次记录，直接通过验证
|
||
if (todayShiftNumbers == null || !todayShiftNumbers.Any())
|
||
{
|
||
_logger.LogDebug("同天班次连续性验证：当天无其他班次记录，通过验证 - 人员ID:{PersonnelId}, 当前班次编号:{ShiftNumber}",
|
||
personnelId, currentShiftNumber.Value);
|
||
return CreateValidResult("当天无其他班次记录，通过连续性验证", 100);
|
||
}
|
||
|
||
// 第四步：根据规则类型检查同一天内班次连续性违规情况
|
||
bool hasViolation = ruleType switch
|
||
{
|
||
3 => todayShiftNumbers.Contains(1) && currentShiftNumber == 2, // 同一天禁止早班(1)和中班(2)同时存在
|
||
4 => todayShiftNumbers.Contains(2) && currentShiftNumber == 3, // 同一天禁止中班(2)和晚班(3)同时存在
|
||
_ => false // 未定义的规则类型默认不违规
|
||
};
|
||
|
||
// 第五步：生成详细的验证结果
|
||
if (hasViolation)
|
||
{
|
||
var existingShift = todayShiftNumbers.First(s => (ruleType == 3 && s == 1) || (ruleType == 4 && s == 2));
|
||
var violationDetail = GenerateSameDayViolationDetail(ruleType, existingShift, currentShiftNumber.Value);
|
||
_logger.LogWarning("同天班次连续性规则违规 - 人员ID:{PersonnelId}, {ViolationDetail}",
|
||
personnelId, violationDetail);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = false,
|
||
ComplianceScore = 0,
|
||
IsCritical = true, // 同天连续班次违规是关键风险
|
||
ViolationMessage = violationDetail
|
||
};
|
||
}
|
||
else
|
||
{
|
||
var successMessage = GenerateSameDaySuccessMessage(ruleType, currentShiftNumber.Value);
|
||
_logger.LogDebug("同天班次连续性验证通过 - 人员ID:{PersonnelId}, {SuccessMessage}",
|
||
personnelId, successMessage);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true,
|
||
ComplianceScore = 100,
|
||
IsCritical = false,
|
||
ViolationMessage = ""
|
||
};
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 记录异常并返回保守结果
|
||
_logger.LogError(ex,
|
||
"验证班次连续性规则异常 - 人员ID:{PersonnelId}, 工作日期:{WorkDate}, 班次ID:{ShiftId}, 规则类型:{RuleType}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId, ruleType);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true, // 异常情况下采用保守策略，不阻断分配
|
||
ComplianceScore = 60, // 给予中等评分
|
||
IsCritical = false,
|
||
ViolationMessage = $"验证异常，建议人工审核：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证连续工作天数规则
|
||
/// </summary>
|
||
private async Task<RuleValidationResult> ValidateContinuousWorkDaysRuleAsync(long personnelId,
|
||
DateTime workDate, Dictionary<string, object> ruleParams)
|
||
{
|
||
var maxContinuousDays = 7;
|
||
var continuousDays = await CalculateContinuousWorkDaysAsync(personnelId, workDate);
|
||
|
||
var isValid = continuousDays <= maxContinuousDays;
|
||
var complianceScore = isValid ? Math.Max(0, 100 - (continuousDays / (double)maxContinuousDays * 100)) : 0;
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = isValid,
|
||
ComplianceScore = complianceScore,
|
||
IsCritical = !isValid,
|
||
ViolationMessage = isValid ? "" : $"连续工作天数({continuousDays})超过限制({maxContinuousDays})"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证跨周末班次连续性规则
|
||
/// 深度业务思考：检查跨周末时期是否存在违反休息间隔的班次连续安排
|
||
/// 规则5：不能这周日/下周六连续工作
|
||
/// 规则6：不能本周六/本周日连续工作
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="workDate">当前工作日期</param>
|
||
/// <param name="shiftId">当前班次ID</param>
|
||
/// <param name="ruleType">规则类型（5：周日/下周六禁止连续，6：周六/周日禁止连续）</param>
|
||
/// <returns>规则验证结果，包含合规状态、评分和详细说明</returns>
|
||
private async Task<RuleValidationResult> ValidateCrossWeekendContinuityRuleAsync(long personnelId, DateTime workDate,
|
||
long shiftId, int ruleType)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始验证跨周末班次连续性规则 - 人员ID:{PersonnelId}, 工作日期:{WorkDate}, 规则类型:{RuleType}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), ruleType);
|
||
|
||
// 第一步：计算相关的日期
|
||
var (firstDate, secondDate) = CalculateWeekendDates(workDate, ruleType);
|
||
|
||
_logger.LogDebug("跨周末日期计算完成 - 第一日期:{FirstDate}, 第二日期:{SecondDate}",
|
||
firstDate.ToString("yyyy-MM-dd"), secondDate.ToString("yyyy-MM-dd"));
|
||
|
||
// 第二步：检查当前工作日期是否匹配需要验证的日期
|
||
bool isTargetDate = workDate.Date == firstDate.Date || workDate.Date == secondDate.Date;
|
||
if (!isTargetDate)
|
||
{
|
||
// 如果当前日期不是目标验证日期，直接通过验证
|
||
_logger.LogDebug("当前日期不在验证范围内，跳过验证 - 当前日期:{CurrentDate}", workDate.ToString("yyyy-MM-dd"));
|
||
return CreateValidResult("非目标验证日期，通过验证", 100);
|
||
}
|
||
|
||
// 第三步：获取两个日期的班次分配情况
|
||
var firstDateShifts = await GetPersonnelAllShiftNumbersOnDateAsync(personnelId, firstDate);
|
||
var secondDateShifts = await GetPersonnelAllShiftNumbersOnDateAsync(personnelId, secondDate);
|
||
|
||
// 如果当前要分配的是第二个日期，需要将当前班次加入到检查中
|
||
if (workDate.Date == secondDate.Date)
|
||
{
|
||
var currentShiftNumber = await GetShiftNumberByIdAsync(shiftId);
|
||
if (currentShiftNumber.HasValue && !secondDateShifts.Contains(currentShiftNumber.Value))
|
||
{
|
||
secondDateShifts.Add(currentShiftNumber.Value);
|
||
}
|
||
}
|
||
// 如果当前要分配的是第一个日期，需要将当前班次加入到检查中
|
||
else if (workDate.Date == firstDate.Date)
|
||
{
|
||
var currentShiftNumber = await GetShiftNumberByIdAsync(shiftId);
|
||
if (currentShiftNumber.HasValue && !firstDateShifts.Contains(currentShiftNumber.Value))
|
||
{
|
||
firstDateShifts.Add(currentShiftNumber.Value);
|
||
}
|
||
}
|
||
|
||
// 第四步：检查是否存在跨周末连续性违规
|
||
bool hasViolation = firstDateShifts.Any() && secondDateShifts.Any();
|
||
|
||
// 第五步：生成验证结果
|
||
if (hasViolation)
|
||
{
|
||
var violationDetail = GenerateCrossWeekendViolationDetail(ruleType, firstDate, secondDate,
|
||
firstDateShifts, secondDateShifts);
|
||
|
||
_logger.LogWarning("跨周末班次连续性规则违规 - 人员ID:{PersonnelId}, {ViolationDetail}",
|
||
personnelId, violationDetail);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = false,
|
||
ComplianceScore = 0,
|
||
IsCritical = true, // 跨周末连续工作是关键风险
|
||
ViolationMessage = violationDetail
|
||
};
|
||
}
|
||
else
|
||
{
|
||
var successMessage = GenerateCrossWeekendSuccessMessage(ruleType, firstDate, secondDate);
|
||
_logger.LogDebug("跨周末班次连续性验证通过 - 人员ID:{PersonnelId}, {SuccessMessage}",
|
||
personnelId, successMessage);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true,
|
||
ComplianceScore = 100,
|
||
IsCritical = false,
|
||
ViolationMessage = ""
|
||
};
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 记录异常并返回保守结果
|
||
_logger.LogError(ex,
|
||
"验证跨周末班次连续性规则异常 - 人员ID:{PersonnelId}, 工作日期:{WorkDate}, 班次ID:{ShiftId}, 规则类型:{RuleType}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId, ruleType);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true, // 异常情况下采用保守策略，不阻断分配
|
||
ComplianceScore = 60, // 给予中等评分
|
||
IsCritical = false,
|
||
ViolationMessage = $"验证异常，建议人工审核：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证项目FL优先分配规则
|
||
/// 【深度业务思考】：确保项目专业性和工作效率的关键规则
|
||
/// 业务背景：
|
||
/// - FL（Front Line，一线人员）是项目的核心执行者
|
||
/// - 本项目FL具有专业知识和操作经验优势
|
||
/// - 优先分配本项目FL有助于提高工作质量和效率
|
||
/// - 降低项目间人员切换的学习成本和沟通成本
|
||
///
|
||
/// 规则10业务逻辑：
|
||
/// - 检查人员是否为当前工作任务所属项目的FL成员
|
||
/// - 本项目FL获得优先分配机会（高评分）
|
||
/// - 非本项目FL仍可分配但评分较低
|
||
/// - 确保项目专业性与人员灵活调配的平衡
|
||
///
|
||
/// 【边界情况深度分析】：
|
||
/// 1. 跨项目FL：人员同时是多个项目的FL，按关联度评分
|
||
/// 2. 项目FL不足：当本项目FL都不可用时，允许跨项目分配
|
||
/// 3. 新项目场景：项目初期可能还没有指定FL，采用宽松策略
|
||
/// 4. FL资质变更：人员FL资格变更后的历史数据处理
|
||
/// 5. 项目暂停/结束：项目状态变更对FL优先级的影响
|
||
/// 6. 紧急任务：紧急情况下可适当放宽FL限制
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="workDate">工作日期</param>
|
||
/// <param name="shiftId">班次ID</param>
|
||
/// <param name="rule">规则实体（包含规则参数配置）</param>
|
||
/// <returns>规则验证结果，包含优先级评分和详细说明</returns>
|
||
private async Task<RuleValidationResult> ValidateProjectFLPriorityRuleAsync(long personnelId, DateTime workDate,
|
||
long shiftId, ShiftRuleEntity rule)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始验证项目FL优先分配规则 - 人员ID:{PersonnelId}, 工作日期:{WorkDate}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"));
|
||
|
||
// 第一步：获取当前分配上下文中的工作任务信息
|
||
// 【重要说明】：由于此方法是规则验证，我们需要从上下文中获取当前要分配的任务信息
|
||
var currentWorkOrder = await GetCurrentWorkOrderFromContextAsync(personnelId, workDate, shiftId);
|
||
if (currentWorkOrder == null)
|
||
{
|
||
_logger.LogWarning("无法获取当前工作任务上下文 - 人员ID:{PersonnelId}, 日期:{WorkDate}, 班次:{ShiftId}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId);
|
||
return CreateValidResult("无法确定工作任务上下文，采用中性评分", 85);
|
||
}
|
||
|
||
// 第二步：检查人员是否为当前项目的FL成员
|
||
var isProjectFL = await CheckPersonnelIsProjectFLAsync(personnelId, currentWorkOrder.ProjectNumber);
|
||
|
||
// 第三步：查询人员的其他项目FL关联情况（用于综合评分）
|
||
var allProjectFLs = await GetPersonnelAllProjectFLsAsync(personnelId);
|
||
|
||
// 第四步：根据FL关联情况进行综合评分
|
||
var scoringResult = CalculateProjectFLPriorityScore(personnelId, currentWorkOrder.ProjectNumber,
|
||
isProjectFL, allProjectFLs, rule);
|
||
|
||
// 第五步：生成详细的验证结果
|
||
var resultMessage = GenerateProjectFLValidationMessage(personnelId, currentWorkOrder.ProjectNumber,
|
||
isProjectFL, scoringResult.Score, scoringResult.Reason);
|
||
|
||
_logger.LogDebug("项目FL优先规则验证完成 - 人员ID:{PersonnelId}, 项目:{ProjectNumber}, " +
|
||
"是否本项目FL:{IsProjectFL}, 评分:{Score}",
|
||
personnelId, currentWorkOrder.ProjectNumber, isProjectFL, scoringResult.Score);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true, // 此规则主要影响优先级，不阻断分配
|
||
ComplianceScore = scoringResult.Score,
|
||
IsCritical = false,
|
||
ViolationMessage = resultMessage
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 【异常处理策略】：记录详细异常信息并返回保守结果
|
||
_logger.LogError(ex,
|
||
"验证项目FL优先规则异常 - 人员ID:{PersonnelId}, 工作日期:{WorkDate}, 班次ID:{ShiftId}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId);
|
||
|
||
// 【保守策略】：异常情况下给予中等评分，不阻断分配流程
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true,
|
||
ComplianceScore = 80, // 给予中等偏上评分
|
||
IsCritical = false,
|
||
ViolationMessage = $"项目FL优先规则验证异常，建议人工审核：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 默认规则验证
|
||
/// </summary>
|
||
private async Task<RuleValidationResult> ValidateDefaultRuleAsync(long personnelId, DateTime workDate,
|
||
ShiftRuleEntity rule, Dictionary<string, object> ruleParams)
|
||
{
|
||
// 对于未识别的规则类型，进行基础验证
|
||
_logger.LogWarning("未识别的规则类型：{RuleType}，规则名称：{RuleName}", rule.RuleType, rule.RuleName);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true,
|
||
ComplianceScore = 90, // 给予较高分，但不是满分
|
||
IsCritical = false,
|
||
ViolationMessage = $"未识别的规则类型({rule.RuleType})，采用默认验证"
|
||
};
|
||
}
|
||
|
||
#region 十一种规则辅助方法
|
||
|
||
/// <summary>
|
||
/// 检查指定人员在同一天是否已有相同班次的任务分配
|
||
/// 业务逻辑：防止同一人员在同一天被分配多个相同班次的任务
|
||
/// 深度思考：考虑任务状态、班次类型、数据一致性等因素
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="workDate">工作日期</param>
|
||
/// <param name="shiftId">班次ID</param>
|
||
/// <returns>true表示存在重复班次分配，false表示无重复</returns>
|
||
private async Task<bool> CheckDuplicateShiftOnSameDateAsync(long personnelId, DateTime workDate, long shiftId)
|
||
{
|
||
try
|
||
{
|
||
// 查询该人员在指定日期是否已有相同班次的任务分配
|
||
// 只考虑非取消和非拒绝状态的任务
|
||
var existingAssignment = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId &&
|
||
w.WorkOrderDate.Date == workDate.Date &&
|
||
w.ShiftId == shiftId &&
|
||
w.Status > (int)WorkOrderStatusEnum.PendingReview)
|
||
.FirstAsync();
|
||
|
||
var hasDuplicate = existingAssignment != null;
|
||
|
||
if (hasDuplicate)
|
||
{
|
||
_logger.LogWarning("发现重复班次分配 - 人员ID:{PersonnelId}, 日期:{Date}, 班次ID:{ShiftId}, 已存在任务ID:{ExistingTaskId}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId, existingAssignment.Id);
|
||
}
|
||
else
|
||
{
|
||
_logger.LogDebug("无重复班次分配 - 人员ID:{PersonnelId}, 日期:{Date}, 班次ID:{ShiftId}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId);
|
||
}
|
||
|
||
return hasDuplicate;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "检查重复班次分配异常 - 人员ID:{PersonnelId}, 日期:{Date}, 班次ID:{ShiftId}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId);
|
||
// 异常情况下采用保守策略，假设无重复
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 线程安全的班次编号缓存锁 - 与GlobalPersonnelAllocationService共享
|
||
/// 【并发安全】：防止多个服务同时访问ShiftService导致DbContext冲突
|
||
/// </summary>
|
||
private static readonly SemaphoreSlim _shiftCacheLock = new SemaphoreSlim(1, 1);
|
||
|
||
/// <summary>
|
||
/// 班次编号缓存 - 与GlobalPersonnelAllocationService共享缓存
|
||
/// 【性能+安全】：跨服务共享班次缓存，避免重复查询和并发冲突
|
||
/// </summary>
|
||
private static readonly Dictionary<long, int?> _shiftNumberCache = new Dictionary<long, int?>();
|
||
|
||
/// <summary>
|
||
/// 根据班次ID获取班次编号 - 线程安全版本
|
||
/// 业务逻辑：将班次ID转换为班次编号，用于班次连续性规则计算
|
||
/// 【关键修复】：使用SemaphoreSlim确保线程安全，避免FreeSql DbContext并发冲突
|
||
/// 深度思考：处理班次不存在、数据异常、并发访问等所有边界情况
|
||
/// </summary>
|
||
/// <param name="shiftId">班次ID</param>
|
||
/// <returns>班次编号（1,2,3等），null表示班次不存在或异常</returns>
|
||
private async Task<int?> GetShiftNumberByIdAsync(long shiftId)
|
||
{
|
||
// 【性能优化】：首先检查缓存，避免不必要的锁等待
|
||
if (_shiftNumberCache.TryGetValue(shiftId, out var cachedNumber))
|
||
{
|
||
_logger.LogTrace("【班次缓存命中】班次ID:{ShiftId} -> 班次编号:{ShiftNumber}", shiftId, cachedNumber);
|
||
return cachedNumber;
|
||
}
|
||
|
||
// 【并发安全】：使用信号量确保同一时间只有一个线程访问数据库
|
||
await _shiftCacheLock.WaitAsync();
|
||
try
|
||
{
|
||
// 【二次检查】：在获取锁后再次检查缓存，可能其他线程已经加载
|
||
if (_shiftNumberCache.TryGetValue(shiftId, out var doubleCheckedNumber))
|
||
{
|
||
_logger.LogTrace("【班次缓存二次命中】班次ID:{ShiftId} -> 班次编号:{ShiftNumber}", shiftId, doubleCheckedNumber);
|
||
return doubleCheckedNumber;
|
||
}
|
||
|
||
// 【数据库查询】：在锁保护下进行数据库访问
|
||
_logger.LogDebug("【线程安全班次查询】开始查询班次ID:{ShiftId}的编号信息", shiftId);
|
||
var shift = await _shiftService.GetAsync(shiftId);
|
||
|
||
int? shiftNumber = null;
|
||
if (shift != null)
|
||
{
|
||
shiftNumber = shift.ShiftNumber;
|
||
_logger.LogDebug("获取班次编号成功 - 班次ID:{ShiftId}, 班次编号:{ShiftNumber}",
|
||
shiftId, shift.ShiftNumber);
|
||
}
|
||
else
|
||
{
|
||
_logger.LogWarning("班次不存在 - 班次ID:{ShiftId}", shiftId);
|
||
}
|
||
|
||
// 【缓存更新】：将结果存入缓存供后续使用（包括null值）
|
||
_shiftNumberCache[shiftId] = shiftNumber;
|
||
|
||
return shiftNumber;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "【并发安全修复】获取班次编号异常 - 班次ID:{ShiftId}，使用线程安全机制重试", shiftId);
|
||
|
||
// 【错误恢复】：异常情况下缓存null值，避免重复失败查询
|
||
_shiftNumberCache[shiftId] = null;
|
||
return null;
|
||
}
|
||
finally
|
||
{
|
||
// 【资源释放】：确保信号量被正确释放
|
||
_shiftCacheLock.Release();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取人员在指定日期的所有班次编号
|
||
/// 业务逻辑：查询人员在特定日期的所有已分配班次编号，用于班次冲突检查
|
||
/// 深度思考：处理多班次分配、任务状态过滤、数据完整性等复杂场景
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="date">查询日期</param>
|
||
/// <returns>班次编号列表，空列表表示该日期无班次分配</returns>
|
||
private async Task<List<int>> GetPersonnelAllShiftNumbersOnDateAsync(long personnelId, DateTime date)
|
||
{
|
||
try
|
||
{
|
||
// 查询该人员在指定日期的所有工作任务及其班次信息
|
||
var workOrdersWithShifts = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId &&
|
||
w.WorkOrderDate.Date == date.Date &&
|
||
w.Status > (int)WorkOrderStatusEnum.PendingReview)
|
||
.Include(w => w.ShiftEntity) // 包含班次实体
|
||
.ToListAsync();
|
||
|
||
// 提取班次编号并去重
|
||
var shiftNumbers = workOrdersWithShifts
|
||
.Where(w => w.ShiftEntity != null)
|
||
.Select(w => w.ShiftEntity.ShiftNumber)
|
||
.Distinct()
|
||
.ToList();
|
||
|
||
_logger.LogDebug("获取人员当日班次编号成功 - 人员ID:{PersonnelId}, 日期:{Date}, 班次编号:{ShiftNumbers}",
|
||
personnelId, date.ToString("yyyy-MM-dd"), string.Join(",", shiftNumbers));
|
||
|
||
return shiftNumbers;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "获取人员当日班次编号异常 - 人员ID:{PersonnelId}, 日期:{Date}",
|
||
personnelId, date.ToString("yyyy-MM-dd"));
|
||
// 异常情况下返回空列表，避免阻断验证流程
|
||
return new List<int>();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建验证通过结果的辅助方法
|
||
/// </summary>
|
||
private RuleValidationResult CreateValidResult(string reason, double score = 100)
|
||
{
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true,
|
||
ComplianceScore = score,
|
||
IsCritical = false,
|
||
ViolationMessage = ""
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成同天班次违规详细信息
|
||
/// 业务逻辑：为同天班次连续性违规生成详细的错误说明
|
||
/// </summary>
|
||
/// <param name="ruleType">规则类型</param>
|
||
/// <param name="existingShift">已存在的班次编号</param>
|
||
/// <param name="currentShift">当前要分配的班次编号</param>
|
||
/// <returns>详细的违规说明</returns>
|
||
private string GenerateSameDayViolationDetail(int ruleType, int existingShift, int currentShift)
|
||
{
|
||
return ruleType switch
|
||
{
|
||
3 => $"同天早中班连续性违规：违反早中班同天禁止规则",
|
||
4 => $"同天中夜班连续性违规：违反中夜班同天禁止规则",
|
||
_ => $"同天班次连续性违规：规则类型{ruleType}，已有班次{existingShift}与当前班次{currentShift}冲突"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成同天班次验证成功信息
|
||
/// 业务逻辑：为同天班次连续性验证通过生成详细的成功说明
|
||
/// </summary>
|
||
/// <param name="ruleType">规则类型</param>
|
||
/// <param name="currentShift">当前班次编号</param>
|
||
/// <returns>成功验证的详细说明</returns>
|
||
private string GenerateSameDaySuccessMessage(int ruleType, int currentShift)
|
||
{
|
||
return ruleType switch
|
||
{
|
||
3 => $"同天早中班连续性验证通过：符合早中班同天禁止规则",
|
||
4 => $"同天中夜班连续性验证通过：符合中夜班同天禁止规则",
|
||
_ => $"同天班次连续性验证通过：规则类型{ruleType}，班次{currentShift}符合要求"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算跨周末规则验证的相关日期
|
||
/// 业务逻辑：根据规则类型和当前工作日期，计算需要检查的两个关键日期
|
||
/// 深度思考：考虑周历边界、时区、月份跨越等复杂场景
|
||
/// </summary>
|
||
/// <param name="workDate">当前工作日期</param>
|
||
/// <param name="ruleType">规则类型（5：周日/下周六，6：周六/周日）</param>
|
||
/// <returns>需要检查的两个日期（第一日期，第二日期）</returns>
|
||
private (DateTime firstDate, DateTime secondDate) CalculateWeekendDates(DateTime workDate, int ruleType)
|
||
{
|
||
try
|
||
{
|
||
var currentDate = workDate.Date;
|
||
|
||
if (ruleType == 5) // 不能这周日/下周六连续
|
||
{
|
||
// 计算当前日期所在周的周日（本周日）
|
||
var daysFromSunday = (int)currentDate.DayOfWeek; // Sunday = 0, Monday = 1, ..., Saturday = 6
|
||
var thisWeekSunday = currentDate.AddDays(-daysFromSunday);
|
||
|
||
// 计算下周六（下一周的周六）
|
||
var nextWeekSaturday = thisWeekSunday.AddDays(13); // 下周六 = 本周日 + 13天
|
||
|
||
_logger.LogDebug("规则5日期计算 - 本周日:{ThisSunday}, 下周六:{NextSaturday}",
|
||
thisWeekSunday.ToString("yyyy-MM-dd"), nextWeekSaturday.ToString("yyyy-MM-dd"));
|
||
|
||
return (thisWeekSunday, nextWeekSaturday);
|
||
}
|
||
else if (ruleType == 6) // 不能本周六/本周日连续
|
||
{
|
||
// 计算当前日期所在周的周六和周日
|
||
var daysFromSunday = (int)currentDate.DayOfWeek;
|
||
var thisWeekSunday = currentDate.AddDays(-daysFromSunday);
|
||
var thisWeekSaturday = thisWeekSunday.AddDays(-1); // 本周六 = 本周日 - 1天
|
||
|
||
_logger.LogDebug("规则6日期计算 - 本周六:{ThisSaturday}, 本周日:{ThisSunday}",
|
||
thisWeekSaturday.ToString("yyyy-MM-dd"), thisWeekSunday.ToString("yyyy-MM-dd"));
|
||
|
||
return (thisWeekSaturday, thisWeekSunday);
|
||
}
|
||
else
|
||
{
|
||
_logger.LogWarning("未支持的跨周末规则类型：{RuleType}", ruleType);
|
||
return (currentDate, currentDate); // 返回相同日期，这样不会产生违规
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算跨周末日期异常 - 工作日期:{WorkDate}, 规则类型:{RuleType}",
|
||
workDate.ToString("yyyy-MM-dd"), ruleType);
|
||
return (workDate, workDate); // 异常情况返回相同日期
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成跨周末班次违规详细信息
|
||
/// 业务逻辑：为跨周末班次连续性违规生成详细的错误说明
|
||
/// </summary>
|
||
/// <param name="ruleType">规则类型</param>
|
||
/// <param name="firstDate">第一个日期</param>
|
||
/// <param name="secondDate">第二个日期</param>
|
||
/// <param name="firstDateShifts">第一个日期的班次编号列表</param>
|
||
/// <param name="secondDateShifts">第二个日期的班次编号列表</param>
|
||
/// <returns>详细的违规说明</returns>
|
||
private string GenerateCrossWeekendViolationDetail(int ruleType, DateTime firstDate, DateTime secondDate,
|
||
List<int> firstDateShifts, List<int> secondDateShifts)
|
||
{
|
||
var firstDateName = GetDateDisplayName(firstDate, ruleType, true);
|
||
var secondDateName = GetDateDisplayName(secondDate, ruleType, false);
|
||
|
||
var firstShiftsStr = string.Join(",", firstDateShifts);
|
||
var secondShiftsStr = string.Join(",", secondDateShifts);
|
||
|
||
return ruleType switch
|
||
{
|
||
5 => $"跨周末连续性违规：违反周日/下周六禁止连续工作规则，{firstDateName}有班次{firstShiftsStr}，{secondDateName}有班次{secondShiftsStr}",
|
||
6 => $"周末连续性违规：违反周六/周日禁止连续工作规则，{firstDateName}有班次{firstShiftsStr}，{secondDateName}有班次{secondShiftsStr}",
|
||
_ => $"跨周末班次连续性违规：规则类型{ruleType}，{firstDateName}({firstDate:yyyy-MM-dd})和{secondDateName}({secondDate:yyyy-MM-dd})存在班次冲突"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成跨周末班次验证成功信息
|
||
/// 业务逻辑：为跨周末班次连续性验证通过生成详细的成功说明
|
||
/// </summary>
|
||
/// <param name="ruleType">规则类型</param>
|
||
/// <param name="firstDate">第一个日期</param>
|
||
/// <param name="secondDate">第二个日期</param>
|
||
/// <returns>成功验证的详细说明</returns>
|
||
private string GenerateCrossWeekendSuccessMessage(int ruleType, DateTime firstDate, DateTime secondDate)
|
||
{
|
||
var firstDateName = GetDateDisplayName(firstDate, ruleType, true);
|
||
var secondDateName = GetDateDisplayName(secondDate, ruleType, false);
|
||
|
||
return ruleType switch
|
||
{
|
||
5 => $"跨周末连续性验证通过：符合周日/下周六禁止连续工作规则",
|
||
6 => $"周末连续性验证通过：符合周六/周日禁止连续工作规则",
|
||
_ => $"跨周末班次连续性验证通过：规则类型{ruleType}，{firstDateName}和{secondDateName}符合要求"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证次日休息规则
|
||
/// 【深度业务思考】：该规则确保员工在高强度班次(二班/三班)工作后获得充分的休息时间
|
||
/// 业务背景：
|
||
/// - 二班(中班)通常是下午14:00-22:00，工作强度较大
|
||
/// - 三班(夜班)通常是晚上22:00-次日6:00，对身体负担最重
|
||
/// - 劳动保护要求：夜班工作后必须有24小时的休息时间
|
||
/// - 生产效率考虑：疲劳工作会导致操作失误和安全隐患
|
||
///
|
||
/// 规则8：三班后一天不排班 - 检查前一天是否有三班(班次编号3)，如有则当天不能排班
|
||
/// 规则9：二班后一天不排班 - 检查前一天是否有二班(班次编号2)，如有则当天不能排班
|
||
///
|
||
/// 【边界情况深度分析】：
|
||
/// 1. 跨周末场景：周六三班→周日必须休息
|
||
/// 2. 跨月场景：月末最后一天三班→次月第一天必须休息
|
||
/// 3. 节假日场景：节假日前的二班/三班→节假日当天必须休息
|
||
/// 4. 紧急任务场景：即使有紧急任务，也不能违反休息规则
|
||
/// 5. 多班次冲突：前一天有多个班次时，只要包含目标班次就触发规则
|
||
/// 6. 任务状态过滤：只考虑已确认和执行中的任务，草稿状态不算
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="workDate">当前工作日期（即将分配班次的日期）</param>
|
||
/// <param name="shiftId">当前班次ID（即将分配的班次）</param>
|
||
/// <param name="ruleType">规则类型（8：三班后次日休息，9：二班后次日休息）</param>
|
||
/// <returns>规则验证结果，包含合规状态、评分和详细说明</returns>
|
||
private async Task<RuleValidationResult> ValidateNextDayRestRuleAsync(long personnelId, DateTime workDate,
|
||
long shiftId, int ruleType)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始验证次日休息规则 - 人员ID:{PersonnelId}, 工作日期:{WorkDate}, 规则类型:{RuleType}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), ruleType);
|
||
|
||
// 第一步：确定需要检查的特定班次编号
|
||
// 【业务逻辑】：根据规则类型确定需要检查的前置班次
|
||
int targetShiftNumber = ruleType switch
|
||
{
|
||
8 => 3, // 规则8：检查前一天是否有三班(夜班)
|
||
9 => 2, // 规则9：检查前一天是否有二班(中班)
|
||
_ => 0 // 未知规则类型，返回0表示无效
|
||
};
|
||
|
||
if (targetShiftNumber == 0)
|
||
{
|
||
_logger.LogWarning("未支持的次日休息规则类型：{RuleType}，跳过验证", ruleType);
|
||
return CreateValidResult("未支持的规则类型，跳过验证", 90);
|
||
}
|
||
|
||
// 第二步：计算前一天日期并进行边界检查
|
||
var previousDate = workDate.AddDays(-1);
|
||
|
||
// 【边界情况处理】：检查日期跨度的合理性
|
||
var daysDifference = (workDate.Date - previousDate.Date).TotalDays;
|
||
if (Math.Abs(daysDifference - 1) > 0.01) // 允许微小的浮点误差
|
||
{
|
||
_logger.LogWarning("日期计算异常 - 工作日期:{WorkDate}, 前一天:{PreviousDate}, 天数差:{Days}",
|
||
workDate.ToString("yyyy-MM-dd"), previousDate.ToString("yyyy-MM-dd"), daysDifference);
|
||
return CreateValidResult("日期计算异常，建议人工审核", 70);
|
||
}
|
||
|
||
_logger.LogDebug("次日休息规则验证 - 检查前一天:{PreviousDate}是否有{TargetShift}班",
|
||
previousDate.ToString("yyyy-MM-dd"), GetShiftDisplayName(targetShiftNumber));
|
||
|
||
// 第三步：获取前一天的所有班次编号（包含状态过滤）
|
||
// 【业务逻辑】：只检查已确认的工作任务，避免草稿状态的干扰
|
||
var previousDayShifts = await GetPersonnelAllShiftNumbersOnDateAsync(personnelId, previousDate);
|
||
|
||
// 【数据完整性检查】：验证查询结果的有效性
|
||
if (previousDayShifts == null)
|
||
{
|
||
_logger.LogWarning("获取前一天班次信息失败 - 人员ID:{PersonnelId}, 日期:{PreviousDate}",
|
||
personnelId, previousDate.ToString("yyyy-MM-dd"));
|
||
return CreateValidResult("数据查询异常，建议人工审核", 70);
|
||
}
|
||
|
||
// 第四步：检查前一天是否有目标班次
|
||
bool hadTargetShiftPreviousDay = previousDayShifts.Contains(targetShiftNumber);
|
||
|
||
// 【详细日志记录】：记录查询到的班次信息，便于调试
|
||
_logger.LogDebug("前一天班次查询结果 - 人员ID:{PersonnelId}, 日期:{PreviousDate}, " +
|
||
"所有班次:{AllShifts}, 目标班次:{TargetShift}, 是否存在目标班次:{HasTarget}",
|
||
personnelId, previousDate.ToString("yyyy-MM-dd"),
|
||
string.Join(",", previousDayShifts), targetShiftNumber, hadTargetShiftPreviousDay);
|
||
|
||
if (!hadTargetShiftPreviousDay)
|
||
{
|
||
// 【正常场景】：前一天没有目标班次，规则不适用，验证通过
|
||
var successMessage = GenerateNextDayRestSuccessMessage(ruleType, previousDate, targetShiftNumber, false);
|
||
_logger.LogDebug("次日休息规则验证通过 - 人员ID:{PersonnelId}, {SuccessMessage}",
|
||
personnelId, successMessage);
|
||
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true,
|
||
ComplianceScore = 100,
|
||
IsCritical = false,
|
||
ViolationMessage = ""
|
||
};
|
||
}
|
||
|
||
// 第五步：【关键业务逻辑】前一天有目标班次，检查当天是否安排了班次（违规检查）
|
||
// 【重要说明】：当前方法是在分配前进行验证，如果执行到这里说明：
|
||
// 1. 前一天确实有目标班次（二班或三班）
|
||
// 2. 当天正在尝试分配新的班次
|
||
// 3. 这违反了"次日必须休息"的规则
|
||
|
||
// 【获取当前即将分配的班次信息】：用于生成更详细的违规说明
|
||
var currentShiftNumber = await GetShiftNumberByIdAsync(shiftId);
|
||
var currentShiftName = currentShiftNumber.HasValue ?
|
||
GetShiftDisplayName(currentShiftNumber.Value) : "未知班次";
|
||
|
||
var violationDetail = GenerateNextDayRestViolationDetail(ruleType, previousDate, workDate,
|
||
targetShiftNumber, previousDayShifts, currentShiftName);
|
||
|
||
_logger.LogWarning("次日休息规则违规 - 人员ID:{PersonnelId}, {ViolationDetail}",
|
||
personnelId, violationDetail);
|
||
|
||
// 【关键决策】：这是强制性的安全规则，必须严格执行
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = false,
|
||
ComplianceScore = 0,
|
||
IsCritical = true, // 违反休息规则是关键风险，涉及员工健康和生产安全
|
||
ViolationMessage = violationDetail
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 【异常处理策略】：记录详细异常信息并返回保守结果
|
||
_logger.LogError(ex,
|
||
"验证次日休息规则异常 - 人员ID:{PersonnelId}, 工作日期:{WorkDate}, 班次ID:{ShiftId}, 规则类型:{RuleType}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId, ruleType);
|
||
|
||
// 【保守策略说明】：在系统异常情况下，倾向于不阻断业务流程，但要求人工审核
|
||
// 这样既避免了系统故障导致的业务停滞，又保证了潜在违规得到人工关注
|
||
return new RuleValidationResult
|
||
{
|
||
IsValid = true, // 异常情况下采用保守策略，不阻断分配
|
||
ComplianceScore = 60, // 给予中等评分，表示存在不确定性
|
||
IsCritical = false, // 标记为非关键，但需要人工审核
|
||
ViolationMessage = $"系统验证异常，强烈建议人工审核此次班次分配的合规性：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成次日休息规则违规详细信息
|
||
/// 【业务逻辑深度思考】：生成详细的违规说明，帮助管理人员理解违规原因和影响
|
||
/// 错误信息设计原则：
|
||
/// 1. 明确指出违规的具体规则
|
||
/// 2. 详细说明前一天的班次情况
|
||
/// 3. 明确当前试图分配的班次信息
|
||
/// 4. 提供易于理解的业务背景说明
|
||
/// </summary>
|
||
/// <param name="ruleType">规则类型（8：三班后休息，9：二班后休息）</param>
|
||
/// <param name="previousDate">前一天日期</param>
|
||
/// <param name="currentDate">当前日期（即将分配班次的日期）</param>
|
||
/// <param name="targetShiftNumber">触发规则的班次编号（2或3）</param>
|
||
/// <param name="previousDayShifts">前一天的所有班次编号列表</param>
|
||
/// <param name="currentShiftName">当前试图分配的班次名称</param>
|
||
/// <returns>详细的违规说明，包含业务上下文和建议</returns>
|
||
private string GenerateNextDayRestViolationDetail(int ruleType, DateTime previousDate, DateTime currentDate,
|
||
int targetShiftNumber, List<int> previousDayShifts, string currentShiftName = "未知班次")
|
||
{
|
||
var targetShiftDisplayName = GetShiftDisplayName(targetShiftNumber);
|
||
var previousShiftsStr = string.Join(",", previousDayShifts);
|
||
var dayOfWeekPrevious = previousDate.ToString("dddd", new System.Globalization.CultureInfo("zh-CN"));
|
||
var dayOfWeekCurrent = currentDate.ToString("dddd", new System.Globalization.CultureInfo("zh-CN"));
|
||
|
||
// 【生成详细的违规说明】：包含时间、班次、规则背景等完整信息
|
||
return ruleType switch
|
||
{
|
||
8 => $"【三班后次日强制休息违规】" + Environment.NewLine +
|
||
$"违规详情：" + Environment.NewLine +
|
||
$"• 前一天：{previousDate:yyyy-MM-dd}({dayOfWeekPrevious}) 已安排{targetShiftDisplayName}(班次编号{targetShiftNumber})" + Environment.NewLine +
|
||
$"• 前一天所有班次：{previousShiftsStr}" + Environment.NewLine +
|
||
$"• 当前日期：{currentDate:yyyy-MM-dd}({dayOfWeekCurrent}) 试图分配{currentShiftName}" + Environment.NewLine +
|
||
$"• 违规原因：夜班工作强度大，员工需要24小时恢复时间" + Environment.NewLine +
|
||
$"• 建议方案：将该班次分配给其他人员，或调整至{currentDate.AddDays(1):yyyy-MM-dd}后",
|
||
|
||
9 => $"【二班后次日强制休息违规】" + Environment.NewLine +
|
||
$"违规详情：" + Environment.NewLine +
|
||
$"• 前一天：{previousDate:yyyy-MM-dd}({dayOfWeekPrevious}) 已安排{targetShiftDisplayName}(班次编号{targetShiftNumber})" + Environment.NewLine +
|
||
$"• 前一天所有班次：{previousShiftsStr}" + Environment.NewLine +
|
||
$"• 当前日期：{currentDate:yyyy-MM-dd}({dayOfWeekCurrent}) 试图分配{currentShiftName}" + Environment.NewLine +
|
||
$"• 违规原因：中班工作时间长，员工需要充分休息时间" + Environment.NewLine +
|
||
$"• 建议方案：将该班次分配给其他人员，或调整至{currentDate.AddDays(1):yyyy-MM-dd}后",
|
||
|
||
_ => $"【次日休息规则违规】规则类型{ruleType}" + Environment.NewLine +
|
||
$"前一天({previousDate:yyyy-MM-dd})有{targetShiftDisplayName}(班次{previousShiftsStr})，" +
|
||
$"当天({currentDate:yyyy-MM-dd})试图分配{currentShiftName}，违反休息规则"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成次日休息规则验证成功信息
|
||
/// 【业务逻辑思考】：为次日休息规则验证通过生成详细的成功说明
|
||
/// 成功信息的价值：
|
||
/// 1. 确认规则检查已正确执行
|
||
/// 2. 记录验证的具体条件和结果
|
||
/// 3. 为系统审计提供完整的决策轨迹
|
||
/// </summary>
|
||
/// <param name="ruleType">规则类型（8：三班后休息，9：二班后休息）</param>
|
||
/// <param name="previousDate">前一天日期</param>
|
||
/// <param name="targetShiftNumber">目标班次编号（2或3）</param>
|
||
/// <param name="hadTargetShift">前一天是否有目标班次（当前总是false，为扩展保留）</param>
|
||
/// <returns>成功验证的详细说明，包含验证条件和结论</returns>
|
||
private string GenerateNextDayRestSuccessMessage(int ruleType, DateTime previousDate, int targetShiftNumber, bool hadTargetShift)
|
||
{
|
||
var shiftDisplayName = GetShiftDisplayName(targetShiftNumber);
|
||
var dayOfWeek = previousDate.ToString("dddd", new System.Globalization.CultureInfo("zh-CN"));
|
||
|
||
// 【生成详细的成功验证信息】：清楚说明验证通过的原因
|
||
return ruleType switch
|
||
{
|
||
8 => $"三班后次日休息规则验证通过：前一天{previousDate:yyyy-MM-dd}({dayOfWeek})无{shiftDisplayName}安排，" +
|
||
$"员工无需强制休息，可正常分配班次。验证条件：检查前日是否有夜班(编号3)作业",
|
||
|
||
9 => $"二班后次日休息规则验证通过：前一天{previousDate:yyyy-MM-dd}({dayOfWeek})无{shiftDisplayName}安排，" +
|
||
$"员工无需强制休息，可正常分配班次。验证条件：检查前日是否有中班(编号2)作业",
|
||
|
||
_ => $"次日休息规则验证通过：规则类型{ruleType}，前一天{previousDate:yyyy-MM-dd}({dayOfWeek})无{shiftDisplayName}，符合规则要求"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取班次显示名称
|
||
/// 业务逻辑：将班次编号转换为易读的显示名称
|
||
/// </summary>
|
||
/// <param name="shiftNumber">班次编号</param>
|
||
/// <returns>班次显示名称</returns>
|
||
private string GetShiftDisplayName(int shiftNumber)
|
||
{
|
||
return shiftNumber switch
|
||
{
|
||
1 => "早班",
|
||
2 => "中班",
|
||
3 => "晚班",
|
||
_ => $"{shiftNumber}班"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取日期的显示名称
|
||
/// 业务逻辑：根据规则类型和日期位置生成易读的日期描述
|
||
/// </summary>
|
||
/// <param name="date">日期</param>
|
||
/// <param name="ruleType">规则类型</param>
|
||
/// <param name="isFirst">是否为第一个日期</param>
|
||
/// <returns>日期显示名称</returns>
|
||
private string GetDateDisplayName(DateTime date, int ruleType, bool isFirst)
|
||
{
|
||
return ruleType switch
|
||
{
|
||
5 => isFirst ? "本周日" : "下周六",
|
||
6 => isFirst ? "本周六" : "本周日",
|
||
_ => $"{(isFirst ? "第一日期" : "第二日期")}({date:yyyy-MM-dd})"
|
||
};
|
||
}
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
|
||
#region 执行第三层：优化决策处理
|
||
|
||
/// <summary>
|
||
/// 计算优化评分
|
||
/// </summary>
|
||
private async Task<OptimizationScoreResult> CalculateOptimizationScoreAsync(PersonnelCandidate candidate,
|
||
WorkOrderEntity workOrder, AllocationContext context)
|
||
{
|
||
try
|
||
{
|
||
var result = new OptimizationScoreResult
|
||
{
|
||
Candidate = candidate,
|
||
DimensionScores = new Dictionary<string, double>(),
|
||
RiskAssessment = new RiskAssessment()
|
||
};
|
||
|
||
// 指定人员优先评分
|
||
var assignedScore =
|
||
workOrder.AssignedPersonnelId.HasValue &&
|
||
workOrder.AssignedPersonnelId.Value == candidate.PersonnelId
|
||
? 100.0
|
||
: 0.0;
|
||
|
||
result.DimensionScores["AssignedPersonnel"] = assignedScore;
|
||
|
||
// 项目FL人员优先评分
|
||
var projectFLScore = await CalculateProjectFLScoreAsync(candidate.PersonnelId, workOrder.ProjectNumber);
|
||
result.DimensionScores["ProjectFL"] = projectFLScore;
|
||
|
||
// 负载均衡评分
|
||
var workloadScore = await CalculateWorkloadBalanceScoreAsync(candidate.PersonnelId);
|
||
result.DimensionScores["WorkloadBalance"] = workloadScore;
|
||
|
||
// 班次连续性评分
|
||
var continuityScore = await CalculateShiftContinuityScoreAsync(candidate.PersonnelId, workOrder);
|
||
result.DimensionScores["ShiftContinuity"] = continuityScore;
|
||
|
||
// 技能匹配评分
|
||
var skillScore = candidate.QualificationScore.MatchScore;
|
||
result.DimensionScores["SkillMatch"] = skillScore;
|
||
|
||
// 协作历史评分
|
||
var collaborationScore =
|
||
await CalculateCollaborationScoreAsync(candidate.PersonnelId, workOrder.ProjectNumber);
|
||
result.DimensionScores["CollaborationHistory"] = collaborationScore;
|
||
|
||
// 计算加权总分
|
||
var weightedScore = 0.0;
|
||
foreach (var kvp in result.DimensionScores)
|
||
{
|
||
var weight = context.WeightConfiguration.GetValueOrDefault(kvp.Key, 0.0);
|
||
weightedScore += kvp.Value * weight;
|
||
}
|
||
|
||
result.OptimizationScore = Math.Min(100, weightedScore);
|
||
result.Confidence =
|
||
CalculateConfidence(result.DimensionScores, candidate.ConstraintScore.ComplianceScore);
|
||
result.RecommendationLevel = DetermineRecommendationLevel(result.OptimizationScore, result.Confidence);
|
||
result.OptimizationReason =
|
||
GenerateOptimizationReason(result.DimensionScores, context.WeightConfiguration);
|
||
|
||
// 风险评估
|
||
result.RiskAssessment = await CalculateRiskAssessmentAsync(candidate, workOrder, result);
|
||
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算优化评分异常，候选人：{PersonnelId}", candidate.PersonnelId);
|
||
return new OptimizationScoreResult
|
||
{
|
||
Candidate = candidate,
|
||
OptimizationScore = 0,
|
||
Confidence = 0,
|
||
RecommendationLevel = RecommendationLevel.NotFeasible,
|
||
OptimizationReason = $"评分计算异常：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算项目FL评分
|
||
/// </summary>
|
||
private async Task<double> CalculateProjectFLScoreAsync(long personnelId, string projectNumber)
|
||
{
|
||
try
|
||
{
|
||
// 查询该人员是否为项目内FL人员
|
||
var isProjectFL = await _workOrderRepository.Select
|
||
.AnyAsync(w => w.ProjectNumber == projectNumber &&
|
||
w.WorkOrderFLPersonnels.Any(fp => fp.FLPersonnelId == personnelId));
|
||
|
||
return isProjectFL ? 100.0 : 0.0;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算项目FL评分异常，人员ID：{PersonnelId}，项目：{ProjectNumber}", personnelId, projectNumber);
|
||
return 0.0;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算工作负载均衡评分
|
||
/// </summary>
|
||
private async Task<double> CalculateWorkloadBalanceScoreAsync(long personnelId)
|
||
{
|
||
try
|
||
{
|
||
var dateRange = new DateRange
|
||
{
|
||
StartDate = DateTime.Today,
|
||
EndDate = DateTime.Today.AddDays(30)
|
||
};
|
||
|
||
var workloadAnalysis = await AnalyzePersonnelWorkloadAsync(new List<long> { personnelId }, dateRange);
|
||
var personalWorkload = workloadAnalysis.FirstOrDefault();
|
||
|
||
if (personalWorkload == null)
|
||
{
|
||
return 100.0; // 无工作负载，最高分
|
||
}
|
||
|
||
// 基于工作负载百分比计算平衡评分（负载越低，评分越高）
|
||
return personalWorkload.WorkloadPercentage switch
|
||
{
|
||
< 30 => 100.0,
|
||
< 50 => 90.0,
|
||
< 70 => 80.0,
|
||
< 90 => 60.0,
|
||
< 100 => 40.0,
|
||
_ => 20.0
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算工作负载均衡评分异常，人员ID：{PersonnelId}", personnelId);
|
||
return 50.0; // 异常时返回中等评分
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算班次连续性评分
|
||
/// </summary>
|
||
private async Task<double> CalculateShiftContinuityScoreAsync(long personnelId, WorkOrderEntity workOrder)
|
||
{
|
||
try
|
||
{
|
||
// 获取前一天的班次
|
||
var previousDay = workOrder.WorkOrderDate.AddDays(-1);
|
||
var previousShift = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId && w.WorkOrderDate.Date == previousDay.Date)
|
||
.FirstAsync();
|
||
|
||
if (previousShift == null)
|
||
{
|
||
return 80.0; // 无前一天班次，给予较高分
|
||
}
|
||
|
||
// 获取后一天的班次
|
||
var nextDay = workOrder.WorkOrderDate.AddDays(1);
|
||
var nextShift = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId && w.WorkOrderDate.Date == nextDay.Date)
|
||
.FirstAsync();
|
||
|
||
// 评估班次连续性（相同班次的连续性更好）
|
||
var continuityScore = 60.0; // 基础分
|
||
|
||
if (previousShift?.ShiftId == workOrder.ShiftId)
|
||
{
|
||
continuityScore += 20.0;
|
||
}
|
||
|
||
if (nextShift?.ShiftId == workOrder.ShiftId)
|
||
{
|
||
continuityScore += 20.0;
|
||
}
|
||
|
||
return Math.Min(100.0, continuityScore);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算班次连续性评分异常，人员ID：{PersonnelId}", personnelId);
|
||
return 60.0; // 异常时返回中等评分
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算协作历史评分
|
||
/// </summary>
|
||
private async Task<double> CalculateCollaborationScoreAsync(long personnelId, string projectNumber)
|
||
{
|
||
try
|
||
{
|
||
// 查询历史协作次数
|
||
var collaborationCount = await _workOrderRepository.Select
|
||
.Where(w => w.ProjectNumber == projectNumber &&
|
||
w.AssignedPersonnelId == personnelId &&
|
||
w.Status == (int)WorkOrderStatusEnum.Completed)
|
||
.CountAsync();
|
||
|
||
// 基于协作次数计算评分
|
||
return collaborationCount switch
|
||
{
|
||
0 => 50.0, // 无历史协作
|
||
1 => 60.0, // 少量协作
|
||
<= 3 => 75.0, // 适度协作
|
||
<= 5 => 85.0, // 良好协作
|
||
_ => 95.0 // 丰富协作经验
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算协作历史评分异常，人员ID：{PersonnelId}，项目：{ProjectNumber}", personnelId, projectNumber);
|
||
return 50.0;
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 计算和统计方法
|
||
|
||
/// <summary>
|
||
/// 计算综合总分
|
||
/// </summary>
|
||
private double CalculateTotalScore(PersonnelCandidate candidate, Dictionary<string, double> weights)
|
||
{
|
||
var scores = new Dictionary<string, double>
|
||
{
|
||
["Qualification"] = candidate.QualificationScore.MatchScore,
|
||
["Constraint"] = candidate.ConstraintScore.ComplianceScore,
|
||
["Optimization"] = candidate.OptimizationScore?.TotalOptimizationScore ?? 0
|
||
};
|
||
|
||
var weightedSum = 0.0;
|
||
var totalWeight = 0.0;
|
||
|
||
// 资格和约束是必须项，权重固定
|
||
weightedSum += scores["Qualification"] * 0.3; // 资格权重30%
|
||
weightedSum += scores["Constraint"] * 0.4; // 约束权重40%
|
||
weightedSum += scores["Optimization"] * 0.3; // 优化权重30%
|
||
|
||
return Math.Min(100, weightedSum);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算连续工作天数
|
||
/// </summary>
|
||
private int CalculateContinuousWorkDays(List<DateTime> workDates)
|
||
{
|
||
if (workDates == null || !workDates.Any())
|
||
return 0;
|
||
|
||
var sortedDates = workDates.OrderBy(d => d.Date).ToList();
|
||
var maxContinuous = 1;
|
||
var currentContinuous = 1;
|
||
|
||
for (int i = 1; i < sortedDates.Count; i++)
|
||
{
|
||
if ((sortedDates[i].Date - sortedDates[i - 1].Date).Days == 1)
|
||
{
|
||
currentContinuous++;
|
||
maxContinuous = Math.Max(maxContinuous, currentContinuous);
|
||
}
|
||
else
|
||
{
|
||
currentContinuous = 1;
|
||
}
|
||
}
|
||
|
||
return maxContinuous;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 异步计算连续工作天数
|
||
/// </summary>
|
||
private async Task<int> CalculateContinuousWorkDaysAsync(long personnelId, DateTime targetDate)
|
||
{
|
||
try
|
||
{
|
||
// 获取目标日期前后两周的工作安排
|
||
var startDate = targetDate.AddDays(-14);
|
||
var endDate = targetDate.AddDays(14);
|
||
|
||
var workDates = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId &&
|
||
w.WorkOrderDate >= startDate &&
|
||
w.WorkOrderDate <= endDate &&
|
||
w.Status > (int)WorkOrderStatusEnum.PendingReview)
|
||
.ToListAsync(w => w.WorkOrderDate);
|
||
|
||
// 包含目标日期
|
||
workDates.Add(targetDate);
|
||
|
||
return CalculateContinuousWorkDays(workDates);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算连续工作天数异常，人员ID：{PersonnelId}", personnelId);
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算周班次数
|
||
/// </summary>
|
||
private async Task<int> CalculateWeekShiftCountAsync(long personnelId, DateTime targetDate)
|
||
{
|
||
try
|
||
{
|
||
// 获取目标日期所在周的开始和结束时间
|
||
var weekStart = targetDate.AddDays(-(int)targetDate.DayOfWeek);
|
||
var weekEnd = weekStart.AddDays(6);
|
||
|
||
var shiftCount = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId &&
|
||
w.WorkOrderDate >= weekStart &&
|
||
w.WorkOrderDate <= weekEnd &&
|
||
w.Status > (int)WorkOrderStatusEnum.PendingReview)
|
||
.CountAsync();
|
||
|
||
return (int)shiftCount + 1; // 包含目标日期
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算周班次数异常，人员ID：{PersonnelId}", personnelId);
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算月工作小时数
|
||
/// </summary>
|
||
private async Task<decimal> CalculateMonthlyWorkHoursAsync(long personnelId, DateTime targetDate)
|
||
{
|
||
try
|
||
{
|
||
var monthStart = new DateTime(targetDate.Year, targetDate.Month, 1);
|
||
var monthEnd = monthStart.AddMonths(1).AddDays(-1);
|
||
|
||
var totalHours = await _workOrderRepository.Select
|
||
.Where(w => w.AssignedPersonnelId == personnelId &&
|
||
w.WorkOrderDate >= monthStart &&
|
||
w.WorkOrderDate <= monthEnd &&
|
||
w.Status > (int)WorkOrderStatusEnum.Assigned)
|
||
.SumAsync(w => w.EstimatedHours ?? 8.0m);
|
||
|
||
return totalHours + 8.0m; // 包含目标日期的估算工时
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算月工作小时数异常，人员ID：{PersonnelId}", personnelId);
|
||
return 8.0m;
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 辅助计算方法
|
||
|
||
/// <summary>
|
||
/// 计算置信度
|
||
/// </summary>
|
||
private double CalculateConfidence(Dictionary<string, double> dimensionScores, double constraintScore)
|
||
{
|
||
var scores = dimensionScores.Values.ToList();
|
||
scores.Add(constraintScore);
|
||
|
||
if (!scores.Any()) return 0;
|
||
|
||
var average = scores.Average();
|
||
var variance = scores.Sum(s => Math.Pow(s - average, 2)) / scores.Count;
|
||
var standardDeviation = Math.Sqrt(variance);
|
||
|
||
// 置信度与平均分正相关，与标准差负相关
|
||
var confidence = average * (1 - standardDeviation / 100);
|
||
return Math.Max(0, Math.Min(100, confidence));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 确定推荐等级
|
||
/// </summary>
|
||
private RecommendationLevel DetermineRecommendationLevel(double optimizationScore, double confidence)
|
||
{
|
||
var combinedScore = (optimizationScore + confidence) / 2;
|
||
|
||
return combinedScore switch
|
||
{
|
||
>= 90 => RecommendationLevel.HighlyRecommended,
|
||
>= 75 => RecommendationLevel.Recommended,
|
||
>= 60 => RecommendationLevel.Acceptable,
|
||
>= 40 => RecommendationLevel.NotRecommended,
|
||
_ => RecommendationLevel.NotFeasible
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成优化理由
|
||
/// </summary>
|
||
private string GenerateOptimizationReason(Dictionary<string, double> dimensionScores,
|
||
Dictionary<string, double> weights)
|
||
{
|
||
var reasons = new List<string>();
|
||
|
||
foreach (var kvp in dimensionScores.OrderByDescending(x => x.Value * weights.GetValueOrDefault(x.Key, 0)))
|
||
{
|
||
var weight = weights.GetValueOrDefault(kvp.Key, 0);
|
||
var weightedScore = kvp.Value * weight;
|
||
|
||
if (weightedScore > 50) // 只显示较好的评分
|
||
{
|
||
var dimensionName = kvp.Key switch
|
||
{
|
||
"AssignedPersonnel" => "指定人员匹配",
|
||
"ProjectFL" => "项目FL人员",
|
||
"WorkloadBalance" => "负载均衡",
|
||
"ShiftContinuity" => "班次连续性",
|
||
"SkillMatch" => "技能匹配",
|
||
"CollaborationHistory" => "协作历史",
|
||
_ => kvp.Key
|
||
};
|
||
|
||
reasons.Add($"{dimensionName}({kvp.Value:F1}分，权重{weight:P0})");
|
||
}
|
||
}
|
||
|
||
return reasons.Any() ? $"优势：{string.Join("；", reasons)}" : "综合评分一般";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算风险评估
|
||
/// </summary>
|
||
private async Task<RiskAssessment> CalculateRiskAssessmentAsync(PersonnelCandidate candidate,
|
||
WorkOrderEntity workOrder, OptimizationScoreResult scoreResult)
|
||
{
|
||
var riskAssessment = new RiskAssessment
|
||
{
|
||
RiskFactors = new List<RiskFactor>()
|
||
};
|
||
|
||
try
|
||
{
|
||
// 约束风险
|
||
if (candidate.ConstraintScore.ComplianceScore < 80)
|
||
{
|
||
riskAssessment.RiskFactors.Add(new RiskFactor
|
||
{
|
||
RiskType = "约束合规风险",
|
||
Description = $"约束符合度较低({candidate.ConstraintScore.ComplianceScore:F1}分)",
|
||
Level = candidate.ConstraintScore.ComplianceScore < 60 ? RiskLevel.High : RiskLevel.Medium,
|
||
Probability = 100 - candidate.ConstraintScore.ComplianceScore,
|
||
Impact = 70
|
||
});
|
||
}
|
||
|
||
// 资质风险
|
||
if (candidate.QualificationScore.MatchScore < 90)
|
||
{
|
||
riskAssessment.RiskFactors.Add(new NPP.SmartSchedue.Api.Contracts.Services.Integration.Models.RiskFactor
|
||
{
|
||
RiskType = "资质匹配风险",
|
||
Description = $"资质匹配度不完全({candidate.QualificationScore.MatchScore:F1}分)",
|
||
Level = candidate.QualificationScore.MatchScore < 60 ? RiskLevel.High : RiskLevel.Medium,
|
||
Probability = 100 - candidate.QualificationScore.MatchScore,
|
||
Impact = 60
|
||
});
|
||
}
|
||
|
||
// 工作负载风险
|
||
var workloadScore = scoreResult.DimensionScores.GetValueOrDefault("WorkloadBalance", 100);
|
||
if (workloadScore < 50)
|
||
{
|
||
riskAssessment.RiskFactors.Add(new NPP.SmartSchedue.Api.Contracts.Services.Integration.Models.RiskFactor
|
||
{
|
||
RiskType = "工作负载风险",
|
||
Description = "人员工作负载较重，可能影响工作质量",
|
||
Level = workloadScore < 30 ? RiskLevel.High : RiskLevel.Medium,
|
||
Probability = 100 - workloadScore,
|
||
Impact = 50
|
||
});
|
||
}
|
||
|
||
// 计算总体风险
|
||
if (riskAssessment.RiskFactors.Any())
|
||
{
|
||
var avgProbability = riskAssessment.RiskFactors.Average(rf => rf.Probability);
|
||
var avgImpact = riskAssessment.RiskFactors.Average(rf => rf.Impact);
|
||
riskAssessment.RiskScore = (avgProbability + avgImpact) / 2;
|
||
|
||
riskAssessment.OverallRiskLevel = riskAssessment.RiskScore switch
|
||
{
|
||
< 30 => RiskLevel.Low,
|
||
< 60 => RiskLevel.Medium,
|
||
< 80 => RiskLevel.High,
|
||
_ => RiskLevel.Critical
|
||
};
|
||
}
|
||
else
|
||
{
|
||
riskAssessment.OverallRiskLevel = RiskLevel.Low;
|
||
riskAssessment.RiskScore = 10;
|
||
}
|
||
|
||
riskAssessment.RiskDescription = GenerateRiskDescription(riskAssessment);
|
||
riskAssessment.MitigationSuggestions = GenerateMitigationSuggestions(riskAssessment.RiskFactors);
|
||
|
||
return riskAssessment;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算风险评估异常，候选人：{PersonnelId}", candidate.PersonnelId);
|
||
return new RiskAssessment
|
||
{
|
||
OverallRiskLevel = RiskLevel.Medium,
|
||
RiskScore = 50,
|
||
RiskDescription = $"风险评估异常：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成风险描述
|
||
/// </summary>
|
||
private string GenerateRiskDescription(RiskAssessment riskAssessment)
|
||
{
|
||
if (!riskAssessment.RiskFactors.Any())
|
||
{
|
||
return "风险较低，可以安全执行";
|
||
}
|
||
|
||
var highRiskFactors = riskAssessment.RiskFactors.Where(rf => rf.Level >= RiskLevel.High).ToList();
|
||
if (highRiskFactors.Any())
|
||
{
|
||
return
|
||
$"存在{highRiskFactors.Count}个高风险因子，需要特别关注：{string.Join("；", highRiskFactors.Select(rf => rf.RiskType))}";
|
||
}
|
||
|
||
return $"存在{riskAssessment.RiskFactors.Count}个中低风险因子，建议采取预防措施";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成缓解建议
|
||
/// </summary>
|
||
private List<string> GenerateMitigationSuggestions(List<RiskFactor> riskFactors)
|
||
{
|
||
var suggestions = new List<string>();
|
||
|
||
foreach (var riskFactor in riskFactors)
|
||
{
|
||
var suggestion = riskFactor.RiskType switch
|
||
{
|
||
"约束合规风险" => "建议调整任务时间或寻找替代人员",
|
||
"资质匹配风险" => "建议提供必要的培训或技术支持",
|
||
"工作负载风险" => "建议减少该人员的其他任务或增加协助人员",
|
||
_ => "建议进一步评估和监控"
|
||
};
|
||
|
||
suggestions.Add(suggestion);
|
||
}
|
||
|
||
return suggestions.Distinct().ToList();
|
||
}
|
||
|
||
#endregion
|
||
|
||
|
||
#region 结果计算和生成方法
|
||
|
||
/// <summary>
|
||
/// 计算验证评分
|
||
/// </summary>
|
||
private double CalculateValidationScore(List<ValidationViolation> violations,
|
||
List<NPP.SmartSchedue.Api.Contracts.Services.Integration.Models.ValidationWarning> warnings,
|
||
int totalAssignments)
|
||
{
|
||
if (totalAssignments == 0) return 100;
|
||
|
||
var criticalCount = violations.Count(v => v.Severity == ViolationSeverity.Critical);
|
||
var errorCount = violations.Count(v => v.Severity == ViolationSeverity.Error);
|
||
var warningCount = violations.Count(v => v.Severity == ViolationSeverity.Warning) + warnings.Count;
|
||
|
||
// 计算扣分
|
||
var deductions = criticalCount * 30 + errorCount * 20 + warningCount * 5;
|
||
var baseScore = Math.Max(0, 100 - (deductions / (double)totalAssignments));
|
||
|
||
return Math.Round(baseScore, 1);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成验证报告
|
||
/// </summary>
|
||
private string GenerateValidationReport(PersonnelAllocationValidationResult result)
|
||
{
|
||
var report =
|
||
$"验证完成：{result.PassedAssignmentCount}个通过，{result.FailedAssignmentCount}个失败，评分：{result.ValidationScore}";
|
||
|
||
if (result.Violations.Any())
|
||
{
|
||
var groupedViolations = result.Violations.GroupBy(v => v.Severity);
|
||
var violationSummary = string.Join("；", groupedViolations.Select(g => $"{g.Key}级别{g.Count()}个"));
|
||
report += $"；违规分布：{violationSummary}";
|
||
}
|
||
|
||
return report;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据策略排序候选人员
|
||
/// </summary>
|
||
private List<PersonnelCandidate> SortCandidatesByStrategy(List<PersonnelCandidate> candidates,
|
||
PersonnelAllocationStrategy strategy)
|
||
{
|
||
return strategy switch
|
||
{
|
||
_ => candidates.OrderByDescending(c => c.TotalScore).ToList()
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算推荐置信度
|
||
/// </summary>
|
||
private double CalculateRecommendationConfidence(IEnumerable<PersonnelCandidate> optimalAssignments)
|
||
{
|
||
var candidates = optimalAssignments.ToList();
|
||
if (!candidates.Any()) return 0;
|
||
|
||
var averageScore = candidates.Average(c => c.TotalScore);
|
||
var minScore = candidates.Min(c => c.TotalScore);
|
||
|
||
// 置信度基于平均分和最低分
|
||
var confidence = (averageScore + minScore) / 2;
|
||
return Math.Round(confidence, 1);
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
|
||
#region 其他辅助方法
|
||
|
||
|
||
/// <summary>
|
||
/// 创建失败结果
|
||
/// </summary>
|
||
private PersonnelAllocationResult CreateFailureResult(string errorMessage)
|
||
{
|
||
return new PersonnelAllocationResult
|
||
{
|
||
SuccessfulMatches = new List<TaskPersonnelMatch>(),
|
||
FailedAllocations = new List<FailedPersonnelAllocation>(),
|
||
WorkloadAnalysis = new List<PersonnelWorkloadAnalysis>(),
|
||
FairnessScore = 0,
|
||
AllocationSummary = $"分配失败：{errorMessage}",
|
||
ProcessingDetails = errorMessage,
|
||
AllocationStrategy = "Failed",
|
||
ValidationResult = new
|
||
{
|
||
OverallScore = 0,
|
||
ProcessingMetrics = new Dictionary<string, object>(),
|
||
ValidationPassed = false,
|
||
ErrorMessage = errorMessage
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建部分失败结果
|
||
/// </summary>
|
||
private PersonnelAllocationResult CreatePartialFailureResult(AllocationContext context, string errorMessage)
|
||
{
|
||
var result = new PersonnelAllocationResult
|
||
{
|
||
SuccessfulMatches = new List<TaskPersonnelMatch>(),
|
||
FailedAllocations = new List<FailedPersonnelAllocation>(),
|
||
WorkloadAnalysis = new List<PersonnelWorkloadAnalysis>(),
|
||
FairnessScore = 0,
|
||
AllocationSummary = $"部分失败：{errorMessage}",
|
||
ProcessingDetails = errorMessage,
|
||
AllocationStrategy = context.Strategy.ToString(),
|
||
ValidationResult = new
|
||
{
|
||
OverallScore = 0,
|
||
ProcessingMetrics = context.Metrics,
|
||
ValidationPassed = false,
|
||
ErrorMessage = errorMessage
|
||
}
|
||
};
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建空结果
|
||
/// </summary>
|
||
private PersonnelAllocationResult CreateEmptyResult()
|
||
{
|
||
return new PersonnelAllocationResult
|
||
{
|
||
SuccessfulMatches = new List<TaskPersonnelMatch>(),
|
||
FailedAllocations = new List<FailedPersonnelAllocation>(),
|
||
WorkloadAnalysis = new List<PersonnelWorkloadAnalysis>(),
|
||
FairnessScore = 100, // 没有分配时公平性为满分
|
||
AllocationSummary = "无任务需要分配",
|
||
ProcessingDetails = "输入的任务列表为空",
|
||
AllocationStrategy = "Empty",
|
||
ValidationResult = new
|
||
{
|
||
OverallScore = 100,
|
||
ProcessingMetrics = new Dictionary<string, object>(),
|
||
ValidationPassed = true,
|
||
ErrorMessage = ""
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算整体质量评分
|
||
/// </summary>
|
||
private double CalculateOverallQualityScore(AllocationGenerationResult result)
|
||
{
|
||
if (!result.SuccessfulAllocations.Any()) return 0;
|
||
|
||
var averageScore = result.SuccessfulAllocations.Values.Average(c => c.TotalScore);
|
||
var successRate = (double)result.SuccessfulAllocations.Count /
|
||
(result.SuccessfulAllocations.Count + result.FailedAllocations.Count) * 100;
|
||
|
||
return Math.Round((averageScore + successRate) / 2, 1);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成分配摘要
|
||
/// </summary>
|
||
private string GenerateAllocationSummary(AllocationGenerationResult result, AllocationContext context)
|
||
{
|
||
var totalTasks = context.WorkOrders.Count;
|
||
var successCount = result.SuccessfulAllocations.Count;
|
||
var failureCount = result.FailedAllocations.Count;
|
||
|
||
return $"分配完成：{totalTasks}个任务，成功{successCount}个，失败{failureCount}个，质量评分{result.OverallQualityScore:F1}";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成工作负载分析
|
||
/// </summary>
|
||
private async Task<List<PersonnelWorkloadAnalysis>> GenerateWorkloadAnalysisAsync(
|
||
Dictionary<long, PersonnelCandidate> successfulAllocations)
|
||
{
|
||
var workloadAnalysis = new List<PersonnelWorkloadAnalysis>();
|
||
var personnelGroups = successfulAllocations.Values.GroupBy(c => c.PersonnelId);
|
||
|
||
foreach (var group in personnelGroups)
|
||
{
|
||
var personnel = group.First();
|
||
workloadAnalysis.Add(new PersonnelWorkloadAnalysis
|
||
{
|
||
PersonnelId = personnel.PersonnelId,
|
||
PersonnelName = personnel.PersonnelName,
|
||
AssignedTaskCount = group.Count(),
|
||
WorkloadPercentage = Math.Min(100, group.Count() * 25), // 假设每个任务25%工作负载
|
||
WorkloadStatus = group.Count() switch
|
||
{
|
||
1 => "轻松",
|
||
2 => "适中",
|
||
3 => "繁重",
|
||
_ => "超负荷"
|
||
}
|
||
});
|
||
}
|
||
|
||
return workloadAnalysis.OrderByDescending(w => w.WorkloadPercentage).ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算公平性评分
|
||
/// </summary>
|
||
private int CalculateFairnessScore(List<PersonnelWorkloadAnalysis> workloadAnalysis)
|
||
{
|
||
if (!workloadAnalysis.Any()) return 100;
|
||
|
||
var workloads = workloadAnalysis.Select(w => w.WorkloadPercentage).ToList();
|
||
var average = workloads.Average();
|
||
var variance = workloads.Sum(w => Math.Pow(w - average, 2)) / workloads.Count;
|
||
var standardDeviation = Math.Sqrt(variance);
|
||
|
||
// 公平性评分：标准差越小，公平性越高
|
||
var fairnessScore = Math.Max(0, 100 - standardDeviation);
|
||
return (int)Math.Round(fairnessScore);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 计算预估效率
|
||
/// </summary>
|
||
private decimal CalculateEstimatedEfficiency(PersonnelCandidate candidate)
|
||
{
|
||
// 基于各项评分计算预估效率
|
||
var qualificationFactor = candidate.QualificationScore.MatchScore / 100;
|
||
var constraintFactor = candidate.ConstraintScore.ComplianceScore / 100;
|
||
var optimizationFactor = candidate.OptimizationScore?.TotalOptimizationScore / 100 ?? 0.8;
|
||
|
||
var efficiency = (qualificationFactor + constraintFactor + optimizationFactor) / 3;
|
||
return Math.Round((decimal)efficiency, 2);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 辅助数据结构
|
||
|
||
/// <summary>
|
||
/// 人员状态检查结果
|
||
/// </summary>
|
||
private class PersonnelStatusCheck
|
||
{
|
||
public bool IsActive { get; set; }
|
||
public string Reason { get; set; }
|
||
public string StatusCode { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 项目授权检查结果
|
||
/// </summary>
|
||
private class ProjectAuthorizationCheck
|
||
{
|
||
public bool IsAuthorized { get; set; }
|
||
public double AuthorizationScore { get; set; }
|
||
public string Reason { get; set; }
|
||
public string AuthorizationLevel { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设备可用性检查结果
|
||
/// </summary>
|
||
private class EquipmentAvailabilityCheck
|
||
{
|
||
public bool IsAvailable { get; set; }
|
||
public double AvailabilityScore { get; set; }
|
||
public string Reason { get; set; }
|
||
public int ConflictCount { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 地理位置约束检查结果
|
||
/// </summary>
|
||
private class LocationConstraintCheck
|
||
{
|
||
public bool IsAccessible { get; set; }
|
||
public double AccessibilityScore { get; set; }
|
||
public string Reason { get; set; }
|
||
public TimeSpan EstimatedTravelTime { get; set; }
|
||
public decimal TravelCost { get; set; }
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 规则验证结果
|
||
/// </summary>
|
||
private class RuleValidationResult
|
||
{
|
||
public bool IsValid { get; set; }
|
||
public double ComplianceScore { get; set; }
|
||
public bool IsCritical { get; set; }
|
||
public string ViolationMessage { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 时间可用性结果
|
||
/// </summary>
|
||
private class TimeAvailabilityResult
|
||
{
|
||
public bool IsAvailable { get; set; }
|
||
public double Score { get; set; }
|
||
public string Reason { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 工作限制结果
|
||
/// </summary>
|
||
private class WorkLimitResult
|
||
{
|
||
public bool IsCompliant { get; set; }
|
||
public double Score { get; set; }
|
||
public string Reason { get; set; }
|
||
public string Severity { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 班次规则结果
|
||
/// </summary>
|
||
private class ShiftRuleResult
|
||
{
|
||
public bool IsCompliant { get; set; }
|
||
public double Score { get; set; }
|
||
public string Reason { get; set; }
|
||
public bool IsCritical { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 班次时间冲突结果
|
||
/// </summary>
|
||
private class ShiftTimeConflictResult
|
||
{
|
||
public bool HasConflict { get; set; }
|
||
public string ConflictDescription { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 资质匹配结果
|
||
/// </summary>
|
||
private class QualificationMatchResult
|
||
{
|
||
public bool IsMatched { get; set; }
|
||
public bool IsValid { get; set; }
|
||
public double MatchScore { get; set; }
|
||
public List<string> MatchedQualifications { get; set; } = new();
|
||
public List<string> MissingQualifications { get; set; } = new();
|
||
public string Details { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 输入验证结果
|
||
/// </summary>
|
||
private class InputValidationResult
|
||
{
|
||
public bool IsValid { get; set; }
|
||
public string ErrorMessage { get; set; }
|
||
public List<WorkOrderEntity> WorkOrders { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 人员基础资格检查结果
|
||
/// </summary>
|
||
private class PersonnelEligibilityResult
|
||
{
|
||
public long PersonnelId { get; set; }
|
||
public bool IsEligible { get; set; }
|
||
public List<string> EligibilityReasons { get; set; } = new();
|
||
}
|
||
|
||
#region 规则10：项目FL优先分配相关辅助方法
|
||
|
||
/// <summary>
|
||
/// 从当前分配上下文中获取工作任务信息
|
||
/// 【业务逻辑】：在规则验证过程中获取当前正在分配的工作任务
|
||
/// 深度思考：考虑多种获取任务信息的方式，确保数据准确性
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="workDate">工作日期</param>
|
||
/// <param name="shiftId">班次ID</param>
|
||
/// <returns>当前工作任务实体，如果获取失败返回null</returns>
|
||
private async Task<WorkOrderEntity> GetCurrentWorkOrderFromContextAsync(long personnelId, DateTime workDate, long shiftId)
|
||
{
|
||
try
|
||
{
|
||
// 方法一：从当前分配上下文获取（如果有的话）
|
||
// 这里需要根据实际的分配上下文实现
|
||
|
||
// 方法二：查询最近创建的、尚未分配FL的工作任务
|
||
var recentWorkOrders = await _workOrderRepository.Select
|
||
.Where(w => w.WorkOrderDate.Date == workDate.Date &&
|
||
w.ShiftId == shiftId &&
|
||
w.Status == (int)WorkOrderStatusEnum.PendingAssignment)
|
||
.OrderByDescending(w => w.CreatedTime)
|
||
.Take(10)
|
||
.ToListAsync();
|
||
|
||
if (recentWorkOrders.Any())
|
||
{
|
||
// 优先返回项目号相关的任务（如果人员已有项目关联）
|
||
var personnelProjects = await GetPersonnelAllProjectFLsAsync(personnelId);
|
||
if (personnelProjects.Any())
|
||
{
|
||
var matchedOrder = recentWorkOrders.FirstOrDefault(w =>
|
||
personnelProjects.Any(p => p.ProjectNumber == w.ProjectNumber));
|
||
if (matchedOrder != null)
|
||
{
|
||
return matchedOrder;
|
||
}
|
||
}
|
||
|
||
// 否则返回第一个符合条件的任务
|
||
return recentWorkOrders.First();
|
||
}
|
||
|
||
// 方法三：如果没有待分配的任务，查找相似的已分配任务作为参考
|
||
var similarWorkOrders = await _workOrderRepository.Select
|
||
.Where(w => w.WorkOrderDate.Date == workDate.Date && w.ShiftId == shiftId)
|
||
.OrderByDescending(w => w.CreatedTime)
|
||
.Take(1)
|
||
.ToListAsync();
|
||
|
||
return similarWorkOrders.FirstOrDefault();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "获取当前工作任务上下文异常 - 人员ID:{PersonnelId}, 日期:{WorkDate}, 班次:{ShiftId}",
|
||
personnelId, workDate.ToString("yyyy-MM-dd"), shiftId);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查人员是否为指定项目的FL成员
|
||
/// 【业务逻辑】：查询WorkOrderFLPersonnelEntity表，确定人员与项目的FL关联关系
|
||
/// 深度思考：考虑FL资格的时效性、状态有效性等因素
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="projectNumber">项目号</param>
|
||
/// <returns>true表示是该项目的FL，false表示不是</returns>
|
||
private async Task<bool> CheckPersonnelIsProjectFLAsync(long personnelId, string projectNumber)
|
||
{
|
||
try
|
||
{
|
||
// 查询该人员在指定项目中的FL记录
|
||
var flRecords = await _workOrderRepository.Orm.Select<WorkOrderFLPersonnelEntity>()
|
||
.From<WorkOrderEntity>()
|
||
.Where((flp, wo) => flp.FLPersonnelId == personnelId &&
|
||
wo.ProjectNumber == projectNumber &&
|
||
flp.WorkOrderId == wo.Id)
|
||
.ToListAsync();
|
||
|
||
bool isProjectFL = flRecords.Any();
|
||
|
||
_logger.LogDebug("检查人员项目FL关联 - 人员ID:{PersonnelId}, 项目:{ProjectNumber}, 是否FL:{IsFL}, FL记录数:{Count}",
|
||
personnelId, projectNumber, isProjectFL, flRecords.Count);
|
||
|
||
return isProjectFL;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "检查人员项目FL关联异常 - 人员ID:{PersonnelId}, 项目:{ProjectNumber}",
|
||
personnelId, projectNumber);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取人员所有项目FL关联情况
|
||
/// 【业务逻辑】：查询人员参与的所有项目FL记录，用于综合评分
|
||
/// 深度思考：考虑项目活跃度、历史记录权重等因素
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <returns>人员所有项目FL关联列表</returns>
|
||
private async Task<List<ProjectFLInfo>> GetPersonnelAllProjectFLsAsync(long personnelId)
|
||
{
|
||
try
|
||
{
|
||
// 查询该人员的所有项目FL记录，并统计每个项目的任务数量
|
||
var projectFLRecords = await _workOrderRepository.Orm.Select<WorkOrderFLPersonnelEntity>()
|
||
.From<WorkOrderEntity>()
|
||
.Where((flp, wo) => flp.FLPersonnelId == personnelId && flp.WorkOrderId == wo.Id)
|
||
.ToListAsync((flp, wo) => new { flp.FLPersonnelId, wo.ProjectNumber, wo.CreatedTime });
|
||
|
||
var projectFLStats = projectFLRecords
|
||
.GroupBy(x => x.ProjectNumber)
|
||
.Select(g => new ProjectFLInfo
|
||
{
|
||
ProjectNumber = g.Key,
|
||
TaskCount = g.Count(),
|
||
LatestAssignmentDate = g.Max(x => x.CreatedTime) ?? DateTime.MinValue
|
||
})
|
||
.ToList();
|
||
|
||
_logger.LogDebug("获取人员所有项目FL关联 - 人员ID:{PersonnelId}, 项目数:{ProjectCount}",
|
||
personnelId, projectFLStats.Count);
|
||
|
||
return projectFLStats;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "获取人员所有项目FL关联异常 - 人员ID:{PersonnelId}", personnelId);
|
||
return new List<ProjectFLInfo>();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算项目FL优先级评分
|
||
/// 【业务逻辑】：基于FL关联情况进行多维度评分
|
||
/// 评分策略：
|
||
/// - 本项目FL：100分（最高优先级）
|
||
/// - 有其他项目FL经验：85分（有经验，但需要适应）
|
||
/// - 无FL经验：70分（可以培养，但优先级较低）
|
||
/// - 多项目FL：95分（经验丰富，适应性强）
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="currentProjectNumber">当前项目号</param>
|
||
/// <param name="isProjectFL">是否为当前项目FL</param>
|
||
/// <param name="allProjectFLs">所有项目FL关联情况</param>
|
||
/// <param name="rule">规则实体（可能包含评分权重配置）</param>
|
||
/// <returns>评分结果，包含分数和详细原因</returns>
|
||
private ProjectFLScoringResult CalculateProjectFLPriorityScore(long personnelId, string currentProjectNumber,
|
||
bool isProjectFL, List<ProjectFLInfo> allProjectFLs, ShiftRuleEntity rule)
|
||
{
|
||
try
|
||
{
|
||
// 基础评分逻辑
|
||
if (isProjectFL)
|
||
{
|
||
// 本项目FL获得最高优先级
|
||
return new ProjectFLScoringResult
|
||
{
|
||
Score = 100,
|
||
Reason = $"本项目FL成员，具有专业经验和项目知识，优先分配"
|
||
};
|
||
}
|
||
|
||
// 非本项目FL的评分策略
|
||
if (allProjectFLs.Any())
|
||
{
|
||
// 有其他项目FL经验
|
||
int projectCount = allProjectFLs.Count;
|
||
DateTime latestAssignment = allProjectFLs.Max(p => p.LatestAssignmentDate);
|
||
int daysSinceLastAssignment = (DateTime.Now - latestAssignment).Days;
|
||
|
||
double score = 85; // 基础分
|
||
|
||
// 多项目经验加分
|
||
if (projectCount >= 3)
|
||
{
|
||
score += 10; // 多项目经验丰富
|
||
}
|
||
else if (projectCount == 2)
|
||
{
|
||
score += 5; // 有跨项目经验
|
||
}
|
||
|
||
// 最近活跃度调整
|
||
if (daysSinceLastAssignment <= 30)
|
||
{
|
||
score += 5; // 最近活跃
|
||
}
|
||
else if (daysSinceLastAssignment > 180)
|
||
{
|
||
score -= 10; // 长期未参与FL工作
|
||
}
|
||
|
||
// 确保评分在合理范围内
|
||
score = Math.Min(95, Math.Max(70, score));
|
||
|
||
return new ProjectFLScoringResult
|
||
{
|
||
Score = score,
|
||
Reason = $"有{projectCount}个项目FL经验，最近参与时间：{latestAssignment:yyyy-MM-dd}，具有一定项目经验"
|
||
};
|
||
}
|
||
else
|
||
{
|
||
// 无FL经验，但仍可培养
|
||
return new ProjectFLScoringResult
|
||
{
|
||
Score = 70,
|
||
Reason = "暂无项目FL经验，可作为培养对象适当分配"
|
||
};
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "计算项目FL优先级评分异常 - 人员ID:{PersonnelId}, 项目:{ProjectNumber}",
|
||
personnelId, currentProjectNumber);
|
||
return new ProjectFLScoringResult
|
||
{
|
||
Score = 75,
|
||
Reason = $"评分计算异常，采用默认中等评分：{ex.Message}"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成项目FL验证信息
|
||
/// 【业务逻辑】：生成详细的验证结果说明，帮助理解分配决策
|
||
/// </summary>
|
||
/// <param name="personnelId">人员ID</param>
|
||
/// <param name="projectNumber">项目号</param>
|
||
/// <param name="isProjectFL">是否为项目FL</param>
|
||
/// <param name="score">评分</param>
|
||
/// <param name="reason">评分原因</param>
|
||
/// <returns>详细的验证信息</returns>
|
||
private string GenerateProjectFLValidationMessage(long personnelId, string projectNumber,
|
||
bool isProjectFL, double score, string reason)
|
||
{
|
||
string priorityLevel = score switch
|
||
{
|
||
>= 95 => "最高优先级",
|
||
>= 85 => "高优先级",
|
||
>= 75 => "中等优先级",
|
||
_ => "低优先级"
|
||
};
|
||
|
||
return $"【项目FL优先分配验证】" + Environment.NewLine +
|
||
$"• 人员ID：{personnelId}" + Environment.NewLine +
|
||
$"• 目标项目：{projectNumber}" + Environment.NewLine +
|
||
$"• 是否本项目FL：{(isProjectFL ? "是" : "否")}" + Environment.NewLine +
|
||
$"• 优先级评分：{score:F1}分（{priorityLevel}）" + Environment.NewLine +
|
||
$"• 评分依据：{reason}" + Environment.NewLine +
|
||
$"• 分配建议：{GetAllocationRecommendation(score, isProjectFL)}";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取分配建议
|
||
/// 【业务逻辑】：基于评分提供分配建议
|
||
/// </summary>
|
||
private string GetAllocationRecommendation(double score, bool isProjectFL)
|
||
{
|
||
if (isProjectFL)
|
||
{
|
||
return "强烈推荐分配，本项目FL具有最佳匹配度";
|
||
}
|
||
else if (score >= 85)
|
||
{
|
||
return "推荐分配，有相关项目经验，适应性较强";
|
||
}
|
||
else if (score >= 75)
|
||
{
|
||
return "可以分配，需要适当培训和指导";
|
||
}
|
||
else
|
||
{
|
||
return "谨慎分配，建议优先考虑其他候选人";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 项目FL信息
|
||
/// </summary>
|
||
private class ProjectFLInfo
|
||
{
|
||
public string ProjectNumber { get; set; }
|
||
public int TaskCount { get; set; }
|
||
public DateTime LatestAssignmentDate { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 项目FL评分结果
|
||
/// </summary>
|
||
private class ProjectFLScoringResult
|
||
{
|
||
public double Score { get; set; }
|
||
public string Reason { get; set; }
|
||
}
|
||
|
||
#endregion
|
||
|
||
#endregion
|
||
}
|
||
} |