1097 lines
50 KiB
C#
1097 lines
50 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using System.Linq;
|
||
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.Core.Enums;
|
||
using NPP.SmartSchedue.Api.Contracts.Domain.Work;
|
||
using NPP.SmartSchedue.Api.Repositories.Work;
|
||
|
||
namespace NPP.SmartSchedue.Api.Services.Integration
|
||
{
|
||
/// <summary>
|
||
/// 智能调度编排服务
|
||
/// 职责：协调各个专业服务，实现智能任务整合的核心流程编排
|
||
/// 架构思考：采用编排器模式，专注于流程控制而非具体业务逻辑实现
|
||
/// </summary>
|
||
[DynamicApi(Area = "app")]
|
||
public class SmartScheduleOrchestratorService : BaseService, ISmartScheduleOrchestratorService, IDynamicApi
|
||
{
|
||
private readonly WorkOrderRepository _workOrderRepository;
|
||
private readonly IGlobalPersonnelAllocationService _globalPersonnelAllocationService;
|
||
private readonly IEquipmentAllocationService _equipmentAllocationService;
|
||
private readonly IIntegrationRecordService _integrationRecordService;
|
||
private readonly ITaskValidationService _taskValidationService;
|
||
private readonly ILogger<SmartScheduleOrchestratorService> _logger;
|
||
|
||
public SmartScheduleOrchestratorService(
|
||
WorkOrderRepository workOrderRepository,
|
||
IGlobalPersonnelAllocationService globalPersonnelAllocationService,
|
||
IEquipmentAllocationService equipmentAllocationService,
|
||
IIntegrationRecordService integrationRecordService,
|
||
ITaskValidationService taskValidationService,
|
||
ILogger<SmartScheduleOrchestratorService> logger)
|
||
{
|
||
_workOrderRepository = workOrderRepository;
|
||
_globalPersonnelAllocationService = globalPersonnelAllocationService;
|
||
_equipmentAllocationService = equipmentAllocationService;
|
||
_integrationRecordService = integrationRecordService;
|
||
_taskValidationService = taskValidationService;
|
||
_logger = logger;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行智能任务整合主流程
|
||
/// 深度业务思考：编排器负责协调各服务，确保流程的一致性和完整性
|
||
/// 架构优化：增加分组处理、降级策略和智能重试机制
|
||
/// </summary>
|
||
[HttpPost]
|
||
public async Task<SmartIntegrationResult> ExecuteSmartIntegrationAsync(SmartIntegrationInput input)
|
||
{
|
||
var stopwatch = Stopwatch.StartNew();
|
||
var batchCode = GenerateIntegrationBatchCode();
|
||
|
||
_logger.LogInformation("==================== 开始执行智能任务整合主流程 ====================");
|
||
_logger.LogInformation("🎯 整合批次号: {BatchCode}", batchCode);
|
||
_logger.LogInformation("📊 整合策略: 人员={PersonnelStrategy}, 设备={EquipmentStrategy}, 强制班次规则={EnforceShiftRules}",
|
||
input.Strategy?.PersonnelStrategy, input.Strategy?.EquipmentStrategy, input.Strategy?.EnforceShiftRules);
|
||
_logger.LogInformation("👤 操作员: {OperatorName} (ID: {OperatorUserId})", input.OperatorName, input.OperatorUserId);
|
||
|
||
var result = new SmartIntegrationResult
|
||
{
|
||
IntegrationBatchCode = batchCode,
|
||
CompletionTime = DateTime.Now
|
||
};
|
||
|
||
try
|
||
{
|
||
// 0. 获取待整合的任务列表
|
||
_logger.LogInformation("🔍 步骤0: 开始获取待整合的任务列表...");
|
||
var taskStopwatch = Stopwatch.StartNew();
|
||
var tasksToIntegrate = await GetTasksForIntegrationAsync(input);
|
||
taskStopwatch.Stop();
|
||
_logger.LogInformation("✅ 步骤0完成: 获取到 {TaskCount} 个待整合任务，耗时 {ElapsedMs}ms",
|
||
tasksToIntegrate.Count, taskStopwatch.ElapsedMilliseconds);
|
||
|
||
if (!tasksToIntegrate.Any())
|
||
{
|
||
_logger.LogWarning("⚠️ 未找到需要整合的任务，流程结束");
|
||
result.IsSuccess = false;
|
||
result.IntegrationDetails = "未找到需要整合的任务";
|
||
return result;
|
||
}
|
||
|
||
// 打印任务详细信息和日期分析
|
||
_logger.LogInformation("📋 待整合任务详情:");
|
||
var tasksByDate = GroupTasksByDate(tasksToIntegrate);
|
||
foreach (var task in tasksToIntegrate)
|
||
{
|
||
var hasPreAssigned = task.AssignedPersonnelId.HasValue && task.AssignedPersonnelId.Value > 0;
|
||
_logger.LogInformation(" 任务ID: {TaskId}, 编码: {TaskCode}, 状态: {Status}, 日期: {WorkDate}, 预分配: {PreAssigned}",
|
||
task.Id, task.WorkOrderCode, task.Status, task.WorkOrderDate.ToString("yyyy-MM-dd"),
|
||
hasPreAssigned ? $"人员{task.AssignedPersonnelId}" : "无");
|
||
}
|
||
|
||
_logger.LogInformation("📅 任务日期分组: {DateGroups} 个日期组，跨度 {DateSpan} 天",
|
||
tasksByDate.Count,
|
||
tasksByDate.Keys.Any() ? (tasksByDate.Keys.Max() - tasksByDate.Keys.Min()).Days + 1 : 0);
|
||
|
||
// 1. 任务需求汇总与验证
|
||
_logger.LogInformation("🔍 步骤1: 开始任务需求汇总与验证...");
|
||
var validationStopwatch = Stopwatch.StartNew();
|
||
|
||
_logger.LogInformation(" 1.1 分析任务需求...");
|
||
await _taskValidationService.AnalyzeTaskRequirementsAsync(tasksToIntegrate);
|
||
|
||
_logger.LogInformation(" 1.2 验证任务数据完整性...");
|
||
await _taskValidationService.ValidateTaskDataIntegrityAsync(tasksToIntegrate);
|
||
|
||
_logger.LogInformation(" 1.3 加载任务详细信息...");
|
||
await _taskValidationService.LoadTaskDetailedInfoAsync(tasksToIntegrate);
|
||
|
||
validationStopwatch.Stop();
|
||
_logger.LogInformation("✅ 步骤1完成: 任务验证完成，耗时 {ElapsedMs}ms", validationStopwatch.ElapsedMilliseconds);
|
||
|
||
// 2. 执行智能人员分配 - 分时段处理优化
|
||
_logger.LogInformation("🔍 步骤2: 开始执行智能人员分配...");
|
||
var personnelStopwatch = Stopwatch.StartNew();
|
||
|
||
// 检查是否需要分时段处理
|
||
bool useTimeSegmentedAllocation = tasksByDate.Count > 1 && !input.Strategy.EnforceShiftRules;
|
||
|
||
if (useTimeSegmentedAllocation)
|
||
{
|
||
_logger.LogInformation(" 2.1 采用分时段人员分配策略处理 {DateCount} 个日期组", tasksByDate.Count);
|
||
result.PersonnelAllocation = await ExecuteTimeSegmentedPersonnelAllocationAsync(
|
||
tasksByDate, input.Strategy, input.OperatorUserId, input.OperatorName);
|
||
}
|
||
else
|
||
{
|
||
_logger.LogInformation(" 2.1 采用统一人员分配策略: {Strategy}, 强制班次规则: {EnforceShiftRules}",
|
||
input.Strategy.PersonnelStrategy, input.Strategy.EnforceShiftRules);
|
||
|
||
var globalAllocationInput = new GlobalAllocationInput
|
||
{
|
||
Tasks = tasksToIntegrate,
|
||
ExcludedPersonnelIds = new List<long>()
|
||
};
|
||
|
||
var globalResult = await _globalPersonnelAllocationService.AllocatePersonnelGloballyAsync(globalAllocationInput);
|
||
result.PersonnelAllocation = ConvertToPersonnelAllocationResult(globalResult);
|
||
}
|
||
|
||
personnelStopwatch.Stop();
|
||
_logger.LogInformation("✅ 步骤2完成: 人员分配完成，成功 {SuccessCount} 个，失败 {FailedCount} 个，耗时 {ElapsedMs}ms",
|
||
result.PersonnelAllocation?.SuccessfulMatches?.Count ?? 0,
|
||
result.PersonnelAllocation?.FailedTasks?.Count ?? 0,
|
||
personnelStopwatch.ElapsedMilliseconds);
|
||
|
||
// 2.2 智能重试机制：如果失败任务过多，尝试降级策略
|
||
if (result.PersonnelAllocation?.FailedTasks?.Count > 0)
|
||
{
|
||
var failedCount = result.PersonnelAllocation.FailedTasks.Count;
|
||
var totalCount = tasksToIntegrate.Count;
|
||
var failureRate = (double)failedCount / totalCount;
|
||
|
||
if (failureRate > 0.3) // 失败率超过30%时启动降级重试
|
||
{
|
||
_logger.LogWarning("⚠️ 人员分配失败率 {FailureRate:P1}，启动降级重试策略...", failureRate);
|
||
await ExecuteFallbackPersonnelAllocationAsync(result, tasksToIntegrate, input.Strategy);
|
||
}
|
||
}
|
||
|
||
// 3. 执行智能设备分配
|
||
_logger.LogInformation("🔍 步骤3: 开始执行智能设备分配...");
|
||
var equipmentStopwatch = Stopwatch.StartNew();
|
||
|
||
// 深度架构优化：直接传入Tasks对象，避免重复数据库查询
|
||
var equipmentAllocationInput = new EquipmentAllocationInput
|
||
{
|
||
Tasks = tasksToIntegrate, // 性能优化：直接使用已加载的task对象
|
||
TaskIds = tasksToIntegrate.Select(t => t.Id).ToList(), // 保持兼容性
|
||
Strategy = input.Strategy.EquipmentStrategy,
|
||
TargetUtilization = input.Strategy.TargetEquipmentUtilization,
|
||
ExcludedEquipmentIds = new List<long>(),
|
||
PreferredEquipmentIds = new List<long>()
|
||
};
|
||
|
||
_logger.LogInformation(" 3.1 设备分配策略: {Strategy}, 目标利用率: {TargetUtilization}%",
|
||
input.Strategy.EquipmentStrategy, input.Strategy.TargetEquipmentUtilization);
|
||
|
||
result.EquipmentAllocation =
|
||
await _equipmentAllocationService.AllocateEquipmentSmartlyAsync(equipmentAllocationInput);
|
||
|
||
equipmentStopwatch.Stop();
|
||
_logger.LogInformation("✅ 步骤3完成: 设备分配完成，成功 {SuccessCount} 个，失败 {FailedCount} 个，耗时 {ElapsedMs}ms",
|
||
result.EquipmentAllocation?.SuccessfulMatches?.Count ?? 0,
|
||
result.EquipmentAllocation?.FailedAllocations.Count ?? 0,
|
||
equipmentStopwatch.ElapsedMilliseconds);
|
||
|
||
// 4. 更新任务状态
|
||
await UpdateTaskStatusAsync(tasksToIntegrate, result);
|
||
|
||
// 5. 生成整合记录
|
||
var integrationRecordInput = new IntegrationRecordInput
|
||
{
|
||
TaskIds = tasksToIntegrate.Select(t => t.Id).ToList(),
|
||
PersonnelAllocation = result.PersonnelAllocation,
|
||
EquipmentAllocation = result.EquipmentAllocation,
|
||
Strategy = input.Strategy,
|
||
OperatorUserId = input.OperatorUserId,
|
||
OperatorName = input.OperatorName,
|
||
Remarks = input.Remarks
|
||
};
|
||
var integrationRecord =
|
||
await _integrationRecordService.GenerateIntegrationRecordAsync(integrationRecordInput);
|
||
result.IntegrationRecordId = integrationRecord.Id;
|
||
result.IntegrationBatchCode = integrationRecord.IntegrationBatchCode;
|
||
|
||
// 6. 最终结果汇总统计
|
||
GenerateFinalResultsSummary(result, tasksToIntegrate);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "💥 智能整合过程中发生严重异常: {ExceptionMessage}", ex.Message);
|
||
|
||
result.IsSuccess = false;
|
||
result.IntegrationDetails = $"智能整合过程中发生异常: {ex.Message}";
|
||
|
||
// 详细的异常分析日志
|
||
_logger.LogError("🔍 异常详细信息:");
|
||
_logger.LogError(" 异常类型: {ExceptionType}", ex.GetType().Name);
|
||
_logger.LogError(" 异常消息: {ExceptionMessage}", ex.Message);
|
||
_logger.LogError(" 堆栈跟踪: {StackTrace}", ex.StackTrace);
|
||
|
||
if (ex.InnerException != null)
|
||
{
|
||
_logger.LogError(" 内部异常: {InnerExceptionType} - {InnerExceptionMessage}",
|
||
ex.InnerException.GetType().Name, ex.InnerException.Message);
|
||
}
|
||
|
||
result.FailedTasks.Add(new FailedTaskInfo
|
||
{
|
||
TaskId = 0,
|
||
TaskCode = "系统错误",
|
||
FailureReason = $"系统异常: {ex.Message}",
|
||
FailureType = FailureType.SystemError,
|
||
ConflictDetails = new List<string>
|
||
{
|
||
$"异常类型: {ex.GetType().Name}",
|
||
$"发生时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}",
|
||
$"整合批次: {batchCode}"
|
||
}
|
||
});
|
||
}
|
||
|
||
stopwatch.Stop();
|
||
result.ElapsedMilliseconds = stopwatch.ElapsedMilliseconds;
|
||
|
||
return result;
|
||
}
|
||
|
||
#region 私有辅助方法
|
||
|
||
/// <summary>
|
||
/// 获取待整合的任务列表
|
||
/// </summary>
|
||
private async Task<List<WorkOrderEntity>> GetTasksForIntegrationAsync(SmartIntegrationInput input)
|
||
{
|
||
var query = _workOrderRepository.Select
|
||
.Where(w => w.Status == (int)WorkOrderStatusEnum.PendingIntegration)
|
||
.Include(w => w.ProcessEntity)
|
||
.IncludeMany(w => w.WorkOrderFLPersonnels);
|
||
|
||
if (input.SelectedTaskIds?.Any() == true)
|
||
{
|
||
query = query.Where(t => input.SelectedTaskIds.Contains(t.Id));
|
||
}
|
||
|
||
if (input.SelectedProjectNumbers?.Any() == true)
|
||
{
|
||
query = query.Where(t => input.SelectedProjectNumbers.Contains(t.ProjectNumber));
|
||
}
|
||
|
||
var allTasks = await query.ToListAsync();
|
||
var tasks = allTasks
|
||
.OrderBy(w => w.Priority)
|
||
.ThenBy(w => w.UrgencyLevel)
|
||
.ThenBy(w => w.ComplexityLevel)
|
||
.ThenBy(w => w.PlannedStartTime)
|
||
.ToList();
|
||
|
||
// 项目分组优化
|
||
return tasks
|
||
.GroupBy(t => t.ProjectNumber)
|
||
.OrderBy(g => g.Min(t => t.Priority))
|
||
.SelectMany(g => g.OrderBy(t => t.PlannedStartTime))
|
||
.ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新任务状态
|
||
/// </summary>
|
||
private async Task UpdateTaskStatusAsync(List<WorkOrderEntity> tasks, SmartIntegrationResult result)
|
||
{
|
||
var successfulTaskIds = result.PersonnelAllocation.SuccessfulMatches.Select(m => m.TaskId).ToHashSet();
|
||
|
||
foreach (var task in tasks.Where(t => successfulTaskIds.Contains(t.Id)))
|
||
{
|
||
task.Status = (int)WorkOrderStatusEnum.Assigned;
|
||
task.AssignedTime = DateTime.Now;
|
||
task.LastModifiedTime = DateTime.Now;
|
||
|
||
var personnelMatch = result.PersonnelAllocation.SuccessfulMatches
|
||
.FirstOrDefault(m => m.TaskId == task.Id);
|
||
var equipmentMatch = result.EquipmentAllocation.SuccessfulMatches
|
||
.FirstOrDefault(m => m.TaskId == task.Id);
|
||
|
||
var allocationNotes = new List<string>();
|
||
|
||
if (personnelMatch != null)
|
||
{
|
||
task.AssignedPersonnelId = personnelMatch.PersonnelId;
|
||
task.AssignedPersonnelName = personnelMatch.PersonnelName;
|
||
allocationNotes.Add($"分配人员: {personnelMatch.PersonnelName ?? "未知"} (评分: {personnelMatch.MatchScore:F1})");
|
||
}
|
||
|
||
if (equipmentMatch != null)
|
||
{
|
||
task.AssignedEquipmentId = equipmentMatch.EquipmentId;
|
||
task.AssignedEquipmentName = equipmentMatch.EquipmentName;
|
||
allocationNotes.Add($"分配设备: {equipmentMatch.EquipmentCode ?? equipmentMatch.EquipmentId.ToString()}");
|
||
}
|
||
|
||
allocationNotes.Add($"智能分配完成时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
|
||
task.Remarks = string.Join("; ", allocationNotes);
|
||
}
|
||
|
||
// 处理失败的任务
|
||
var failedTasks = tasks.Where(t => !successfulTaskIds.Contains(t.Id)).ToList();
|
||
foreach (var failedTask in failedTasks)
|
||
{
|
||
failedTask.Status = (int)WorkOrderStatusEnum.PendingIntegration;
|
||
failedTask.Remarks = $"分配失败，等待重新分配 - {DateTime.Now:yyyy-MM-dd HH:mm}";
|
||
}
|
||
|
||
if (tasks.Any())
|
||
{
|
||
await _workOrderRepository.UpdateAsync(tasks);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 最终结果汇总统计
|
||
/// 优化：提供更详细的分析报告和改进建议
|
||
/// </summary>
|
||
private void GenerateFinalResultsSummary(SmartIntegrationResult result, List<WorkOrderEntity> tasksToIntegrate)
|
||
{
|
||
var successCount = result.PersonnelAllocation?.SuccessfulMatches?.Count ?? 0;
|
||
var totalTasks = tasksToIntegrate.Count;
|
||
|
||
result.SuccessfulTaskCount = successCount;
|
||
result.OverallSuccessRate = totalTasks > 0 ? (double)successCount / totalTasks : 0;
|
||
result.FailedTasks = CollectFailedTasksComprehensive(result);
|
||
|
||
var fairnessScore = result.PersonnelAllocation?.FairnessScore ?? 0;
|
||
var equipmentUtilizationRate = result.EquipmentAllocation?.OverallUtilizationRate ?? 0;
|
||
var equipmentSuccessCount = result.EquipmentAllocation?.SuccessfulMatches?.Count ?? 0;
|
||
|
||
// 生成详细的统计报告
|
||
_logger.LogInformation("📊 === 智能整合最终统计报告 ===");
|
||
_logger.LogInformation("🎯 总体成功率: {SuccessRate:P1} ({SuccessCount}/{TotalCount})",
|
||
result.OverallSuccessRate, successCount, totalTasks);
|
||
_logger.LogInformation("👥 人员分配: 成功 {PersonnelSuccess} 个，公平性评分 {FairnessScore:F1}",
|
||
successCount, fairnessScore);
|
||
_logger.LogInformation("🔧 设备分配: 成功 {EquipmentSuccess} 个，利用率 {UtilizationRate:F1}%",
|
||
equipmentSuccessCount, equipmentUtilizationRate);
|
||
_logger.LogInformation("⏱️ 总耗时: {ElapsedTime}ms", result.ElapsedMilliseconds);
|
||
|
||
// 按失败原因分类统计
|
||
if (result.FailedTasks?.Any() == true)
|
||
{
|
||
var failureStats = result.FailedTasks
|
||
.GroupBy(f => f.FailureType)
|
||
.Select(g => new { Type = g.Key, Count = g.Count() })
|
||
.OrderByDescending(x => x.Count);
|
||
|
||
_logger.LogWarning("⚠️ 失败任务分析:");
|
||
foreach (var stat in failureStats)
|
||
{
|
||
_logger.LogWarning(" {FailureType}: {Count} 个任务", stat.Type, stat.Count);
|
||
}
|
||
}
|
||
|
||
// 生成改进建议
|
||
var suggestions = GenerateImprovementSuggestions(result, tasksToIntegrate);
|
||
if (suggestions.Any())
|
||
{
|
||
_logger.LogInformation("💡 改进建议:");
|
||
foreach (var suggestion in suggestions)
|
||
{
|
||
_logger.LogInformation(" • {Suggestion}", suggestion);
|
||
}
|
||
}
|
||
|
||
result.IntegrationDetails = $"智能整合完成。" +
|
||
$"成功分配 {result.SuccessfulTaskCount} 个任务，" +
|
||
$"失败 {result.FailedTasks.Count} 个任务。" +
|
||
$"人员分配公平性评分: {fairnessScore:F1}，" +
|
||
$"设备利用率: {equipmentUtilizationRate:F1}%。" +
|
||
$"执行耗时: {result.ElapsedMilliseconds}ms。";
|
||
|
||
result.IsSuccess = result.SuccessfulTaskCount > 0;
|
||
result.CompletionTime = DateTime.Now;
|
||
|
||
if (string.IsNullOrEmpty(result.IntegrationBatchCode))
|
||
{
|
||
result.IntegrationBatchCode = GenerateIntegrationBatchCode();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成改进建议
|
||
/// </summary>
|
||
private List<string> GenerateImprovementSuggestions(SmartIntegrationResult result, List<WorkOrderEntity> tasksToIntegrate)
|
||
{
|
||
var suggestions = new List<string>();
|
||
|
||
if (result.OverallSuccessRate < 0.7)
|
||
{
|
||
suggestions.Add("成功率偏低，建议增加人员池或调整任务优先级");
|
||
}
|
||
|
||
if (result.FailedTasks?.Any(f => f.FailureType == FailureType.PersonnelAllocationFailed) == true)
|
||
{
|
||
suggestions.Add("存在人员不可用问题，建议优化人员排班计划");
|
||
}
|
||
|
||
if (result.PersonnelAllocation?.FairnessScore < 70)
|
||
{
|
||
suggestions.Add("人员分配公平性有待提升，建议调整分配策略");
|
||
}
|
||
|
||
var dateSpan = tasksToIntegrate.Any() ?
|
||
(tasksToIntegrate.Max(t => t.WorkOrderDate) - tasksToIntegrate.Min(t => t.WorkOrderDate)).Days : 0;
|
||
if (dateSpan > 7)
|
||
{
|
||
suggestions.Add("任务时间跨度较大，建议采用分时段处理策略");
|
||
}
|
||
|
||
return suggestions;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 收集失败任务信息
|
||
/// </summary>
|
||
private List<FailedTaskInfo> CollectFailedTasksComprehensive(SmartIntegrationResult result)
|
||
{
|
||
var failedTasks = new List<FailedTaskInfo>();
|
||
|
||
if (result.PersonnelAllocation?.FailedTasks != null)
|
||
{
|
||
failedTasks.AddRange(result.PersonnelAllocation.FailedTasks);
|
||
}
|
||
|
||
if (result.EquipmentAllocation?.FailedAllocations != null)
|
||
{
|
||
failedTasks.AddRange(result.EquipmentAllocation.FailedAllocations.Select(f => new FailedTaskInfo
|
||
{
|
||
TaskId = f.TaskId,
|
||
TaskCode = f.TaskCode,
|
||
FailureReason = f.FailureReason,
|
||
FailureType = FailureType.EquipmentUnavailable,
|
||
ConflictDetails = f.ConflictDetails ?? new List<string>()
|
||
}));
|
||
}
|
||
|
||
return failedTasks.GroupBy(f => f.TaskId).Select(g => g.First()).ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成整合批次编码
|
||
/// 格式：INT + yyyyMMddHHmmss + XXX，总长度23字符，符合数据库30字符限制
|
||
/// 业务思考：优化编码长度，保持唯一性的同时确保数据库兼容性
|
||
/// </summary>
|
||
private string GenerateIntegrationBatchCode()
|
||
{
|
||
return $"INT{DateTime.Now:yyyyMMddHHmmss}{new Random().Next(100, 999)}";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 按日期分组任务
|
||
/// 架构设计：将任务按工作日期分组，确保不同日期的任务可以分配给同一人员
|
||
/// 深度业务思考：这种分组方式解决了原算法中时间维度处理粗糙的问题
|
||
/// </summary>
|
||
private Dictionary<DateTime, List<WorkOrderEntity>> GroupTasksByDate(List<WorkOrderEntity> tasks)
|
||
{
|
||
return tasks
|
||
.Where(t => t.WorkOrderDate != default(DateTime))
|
||
.GroupBy(t => t.WorkOrderDate.Date)
|
||
.ToDictionary(g => g.Key, g => g.OrderBy(t => t.PlannedStartTime).ToList());
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行分时段人员分配
|
||
/// 核心算法优化：分别处理每个日期的任务，避免跨日期的时间冲突误判
|
||
/// 预分配优化：确保已指定人员的任务也进行最优性检测
|
||
/// 约束分离：独立处理时间约束与匹配算法
|
||
/// </summary>
|
||
private async Task<PersonnelAllocationResult> ExecuteTimeSegmentedPersonnelAllocationAsync(
|
||
Dictionary<DateTime, List<WorkOrderEntity>> taskGroups,
|
||
IntegrationStrategy strategy,
|
||
long operatorUserId,
|
||
string operatorName)
|
||
{
|
||
var allSuccessfulMatches = new List<TaskPersonnelMatch>();
|
||
var allFailedTasks = new List<FailedTaskInfo>();
|
||
var totalFairnessScore = 0.0;
|
||
var processedDates = 0;
|
||
|
||
foreach (var dateGroup in taskGroups.OrderBy(g => g.Key))
|
||
{
|
||
var date = dateGroup.Key;
|
||
var dailyTasks = dateGroup.Value;
|
||
|
||
_logger.LogInformation("🗓️ 处理 {Date} 的 {TaskCount} 个任务",
|
||
date.ToString("yyyy-MM-dd"), dailyTasks.Count);
|
||
|
||
// 为当日任务执行人员分配
|
||
var dailyGlobalInput = new GlobalAllocationInput
|
||
{
|
||
Tasks = dailyTasks,
|
||
ExcludedPersonnelIds = new List<long>()
|
||
};
|
||
|
||
// 执行当日分配，采用增强的预分配约束处理
|
||
var dailyGlobalResult = await _globalPersonnelAllocationService.AllocatePersonnelGloballyAsync(dailyGlobalInput);
|
||
var dailyResult = ConvertToPersonnelAllocationResult(dailyGlobalResult);
|
||
|
||
if (dailyResult?.SuccessfulMatches != null)
|
||
{
|
||
allSuccessfulMatches.AddRange(dailyResult.SuccessfulMatches);
|
||
_logger.LogInformation(" ✅ {Date} 分配成功 {SuccessCount} 个任务",
|
||
date.ToString("MM-dd"), dailyResult.SuccessfulMatches.Count);
|
||
}
|
||
|
||
if (dailyResult?.FailedTasks != null)
|
||
{
|
||
allFailedTasks.AddRange(dailyResult.FailedTasks);
|
||
if (dailyResult.FailedTasks.Any())
|
||
{
|
||
_logger.LogWarning(" ⚠️ {Date} 分配失败 {FailedCount} 个任务",
|
||
date.ToString("MM-dd"), dailyResult.FailedTasks.Count);
|
||
}
|
||
}
|
||
|
||
// 累计公平性评分
|
||
if (dailyResult?.FairnessScore > 0)
|
||
{
|
||
totalFairnessScore += dailyResult.FairnessScore;
|
||
processedDates++;
|
||
}
|
||
|
||
// 记录详细分配信息用于调试
|
||
LogDailyAllocationDetails(date, dailyResult);
|
||
}
|
||
|
||
// 执行跨日期约束验证
|
||
var crossDateValidationResult = await ValidateCrossDateConstraintsAsync(allSuccessfulMatches, taskGroups);
|
||
if (!crossDateValidationResult.IsValid)
|
||
{
|
||
_logger.LogWarning("⚠️ 跨日期约束验证失败: {ValidationDetails}",
|
||
string.Join("; ", crossDateValidationResult.ValidationErrors));
|
||
|
||
// 将约束验证失败的任务移到失败列表
|
||
foreach (var failedTaskId in crossDateValidationResult.FailedTaskIds)
|
||
{
|
||
var failedMatch = allSuccessfulMatches.FirstOrDefault(m => m.TaskId == failedTaskId);
|
||
if (failedMatch != null)
|
||
{
|
||
allSuccessfulMatches.Remove(failedMatch);
|
||
allFailedTasks.Add(new FailedTaskInfo
|
||
{
|
||
TaskId = failedTaskId,
|
||
TaskCode = failedMatch.TaskCode,
|
||
FailureReason = "跨日期约束验证失败",
|
||
FailureType = FailureType.TimeConflict,
|
||
ConflictDetails = crossDateValidationResult.ValidationErrors
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
return new PersonnelAllocationResult
|
||
{
|
||
SuccessfulMatches = allSuccessfulMatches,
|
||
FailedTasks = allFailedTasks,
|
||
FairnessScore = (int)(processedDates > 0 ? totalFairnessScore / processedDates : 0),
|
||
AllocationStrategy = strategy.PersonnelStrategy.ToString(),
|
||
ProcessingDetails = $"处理了 {taskGroups.Count} 个日期分组，成功分配 {allSuccessfulMatches.Count} 个任务"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证跨日期约束
|
||
/// 约束分离设计：独立处理跨日期的人员工作负载、休息时间等约束
|
||
/// </summary>
|
||
private async Task<CrossDateValidationResult> ValidateCrossDateConstraintsAsync(
|
||
List<TaskPersonnelMatch> allMatches,
|
||
Dictionary<DateTime, List<WorkOrderEntity>> taskGroups)
|
||
{
|
||
var validationResult = new CrossDateValidationResult { IsValid = true };
|
||
var personnelWorkloadMap = new Dictionary<long, List<TaskPersonnelMatch>>();
|
||
|
||
// 按人员分组已分配的任务
|
||
foreach (var match in allMatches)
|
||
{
|
||
if (!personnelWorkloadMap.ContainsKey(match.PersonnelId))
|
||
personnelWorkloadMap[match.PersonnelId] = new List<TaskPersonnelMatch>();
|
||
|
||
personnelWorkloadMap[match.PersonnelId].Add(match);
|
||
}
|
||
|
||
// 检查每个人员的跨日期工作负载
|
||
foreach (var personnelGroup in personnelWorkloadMap)
|
||
{
|
||
var personnelId = personnelGroup.Key;
|
||
var personnelTasks = personnelGroup.Value;
|
||
|
||
// 检查连续工作天数限制（放宽为8天限制）
|
||
var workDates = personnelTasks
|
||
.Select(t => taskGroups.First(g => g.Value.Any(task => task.Id == t.TaskId)).Key)
|
||
.Distinct()
|
||
.OrderBy(d => d)
|
||
.ToList();
|
||
|
||
// 采用更宽松的连续工作天数检查
|
||
if (HasExcessiveContinuousWorkDays(workDates, maxContinuousDays: 8))
|
||
{
|
||
validationResult.IsValid = false;
|
||
validationResult.ValidationErrors.Add(
|
||
$"人员 {personnelId} 连续工作天数严重超过限制: {string.Join(", ", workDates.Select(d => d.ToString("MM-dd")))}");
|
||
|
||
// 仅将最后1天的任务标记为失败，而不是最后2天
|
||
var lastWorkDate = workDates.LastOrDefault();
|
||
var tasksToFail = personnelTasks
|
||
.Where(t => taskGroups.Any(g => g.Key == lastWorkDate && g.Value.Any(task => task.Id == t.TaskId)))
|
||
.Select(t => t.TaskId);
|
||
|
||
validationResult.FailedTaskIds.AddRange(tasksToFail);
|
||
|
||
_logger.LogWarning("⚠️ 人员 {PersonnelId} 连续工作天数过多，仅限制最后一天 {LastDate} 的任务",
|
||
personnelId, lastWorkDate.ToString("MM-dd"));
|
||
}
|
||
else if (workDates.Count >= 6)
|
||
{
|
||
// 6-8天连续工作：记录警告但不阻止
|
||
_logger.LogInformation("ℹ️ 人员 {PersonnelId} 连续工作 {WorkDays} 天，在可接受范围内: {Dates}",
|
||
personnelId, workDates.Count, string.Join(", ", workDates.Select(d => d.ToString("MM-dd"))));
|
||
}
|
||
|
||
// 检查每日工作时长限制
|
||
foreach (var date in workDates)
|
||
{
|
||
var dailyTasks = personnelTasks
|
||
.Where(t => taskGroups[date].Any(task => task.Id == t.TaskId))
|
||
.ToList();
|
||
|
||
if (dailyTasks.Count > 0)
|
||
{
|
||
var dailyWorkHours = CalculateDailyWorkHours(dailyTasks, taskGroups[date]);
|
||
if (dailyWorkHours > 12) // 假设每日工作时长不超过12小时
|
||
{
|
||
validationResult.IsValid = false;
|
||
validationResult.ValidationErrors.Add(
|
||
$"人员 {personnelId} 在 {date:MM-dd} 的工作时长 {dailyWorkHours:F1} 小时超过限制");
|
||
|
||
// 将当日最后的任务标记为失败
|
||
var lastTask = dailyTasks.OrderByDescending(t => t.TaskId).First();
|
||
validationResult.FailedTaskIds.Add(lastTask.TaskId);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
await Task.CompletedTask; // 保持异步方法契约
|
||
return validationResult;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查是否有过度的连续工作天数
|
||
/// 优化策略：根据任务紧急程度和业务需求灵活调整限制
|
||
/// </summary>
|
||
private bool HasExcessiveContinuousWorkDays(List<DateTime> workDates, int maxContinuousDays = 6)
|
||
{
|
||
// 如果工作日期少于限制天数，直接返回false
|
||
if (workDates.Count <= maxContinuousDays) return false;
|
||
|
||
// 排序工作日期
|
||
var sortedDates = workDates.OrderBy(d => d).ToList();
|
||
|
||
var consecutiveDays = 1;
|
||
var maxConsecutiveFound = 1;
|
||
|
||
for (int i = 1; i < sortedDates.Count; i++)
|
||
{
|
||
// 检查是否连续
|
||
if (sortedDates[i] == sortedDates[i - 1].AddDays(1))
|
||
{
|
||
consecutiveDays++;
|
||
maxConsecutiveFound = Math.Max(maxConsecutiveFound, consecutiveDays);
|
||
|
||
// 如果超过限制，记录详细信息但不立即返回true
|
||
if (consecutiveDays > maxContinuousDays)
|
||
{
|
||
_logger.LogWarning("🚨 发现连续工作 {ConsecutiveDays} 天，超过限制 {MaxDays} 天，日期范围: {StartDate} 到 {EndDate}",
|
||
consecutiveDays, maxContinuousDays,
|
||
sortedDates[i - consecutiveDays + 1].ToString("MM-dd"),
|
||
sortedDates[i].ToString("MM-dd"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
consecutiveDays = 1;
|
||
}
|
||
}
|
||
|
||
// 基于业务优先级决定是否真的阻止分配
|
||
bool shouldBlock = maxConsecutiveFound > maxContinuousDays + 1; // 允许适度超出
|
||
|
||
if (shouldBlock)
|
||
{
|
||
_logger.LogError("❌ 连续工作天数 {MaxConsecutive} 严重超过限制 {MaxAllowed}，阻止分配",
|
||
maxConsecutiveFound, maxContinuousDays + 1);
|
||
}
|
||
else if (maxConsecutiveFound > maxContinuousDays)
|
||
{
|
||
_logger.LogWarning("⚠️ 连续工作天数 {MaxConsecutive} 超过建议限制 {MaxRecommended}，但允许分配",
|
||
maxConsecutiveFound, maxContinuousDays);
|
||
}
|
||
|
||
return shouldBlock;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算每日工作时长
|
||
/// </summary>
|
||
private double CalculateDailyWorkHours(List<TaskPersonnelMatch> dailyTasks, List<WorkOrderEntity> dayTasks)
|
||
{
|
||
var totalMinutes = 0.0;
|
||
foreach (var match in dailyTasks)
|
||
{
|
||
var task = dayTasks.FirstOrDefault(t => t.Id == match.TaskId);
|
||
if (task != null)
|
||
{
|
||
var duration = (task.PlannedEndTime - task.PlannedStartTime).TotalMinutes;
|
||
totalMinutes += duration;
|
||
}
|
||
}
|
||
return totalMinutes / 60.0;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 记录每日分配详情（用于调试）
|
||
/// </summary>
|
||
private void LogDailyAllocationDetails(DateTime date, PersonnelAllocationResult? dailyResult)
|
||
{
|
||
if (dailyResult?.SuccessfulMatches != null)
|
||
{
|
||
_logger.LogDebug("📊 {Date} 分配详情:", date.ToString("yyyy-MM-dd"));
|
||
foreach (var match in dailyResult.SuccessfulMatches)
|
||
{
|
||
_logger.LogDebug(" 👤 任务 {TaskCode} → 人员 {PersonnelName} (评分: {Score:F1})",
|
||
match.TaskCode, match.PersonnelName, match.MatchScore);
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 新增数据模型
|
||
|
||
/// <summary>
|
||
/// 跨日期验证结果
|
||
/// </summary>
|
||
private class CrossDateValidationResult
|
||
{
|
||
public bool IsValid { get; set; }
|
||
public List<string> ValidationErrors { get; set; } = new List<string>();
|
||
public List<long> FailedTaskIds { get; set; } = new List<long>();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 执行降级人员分配策略
|
||
/// 深度业务思考：当标准分配失败率过高时，采用更宽松的约束条件重新分配
|
||
/// </summary>
|
||
private async Task ExecuteFallbackPersonnelAllocationAsync(
|
||
SmartIntegrationResult result,
|
||
List<WorkOrderEntity> allTasks,
|
||
IntegrationStrategy strategy)
|
||
{
|
||
var failedTaskIds = result.PersonnelAllocation.FailedTasks.Select(f => f.TaskId).ToHashSet();
|
||
var failedTasks = allTasks.Where(t => failedTaskIds.Contains(t.Id)).ToList();
|
||
|
||
_logger.LogInformation("🔄 降级重试: 尝试为 {FailedCount} 个失败任务重新分配", failedTasks.Count);
|
||
|
||
// 降级策略1：放松时间约束
|
||
var fallbackGlobalInput = new GlobalAllocationInput
|
||
{
|
||
Tasks = failedTasks,
|
||
ExcludedPersonnelIds = new List<long>()
|
||
// TODO: 未来版本支持更多降级策略
|
||
// AllowConstraintRelaxation = true,
|
||
// MaxContinuousWorkDays = 10,
|
||
// IgnoreDateConstraints = true
|
||
};
|
||
|
||
var fallbackGlobalResult = await _globalPersonnelAllocationService.AllocatePersonnelGloballyAsync(fallbackGlobalInput);
|
||
var fallbackResult = ConvertToPersonnelAllocationResult(fallbackGlobalResult);
|
||
|
||
if (fallbackResult?.SuccessfulMatches?.Any() == true)
|
||
{
|
||
// 合并降级成功的分配结果
|
||
result.PersonnelAllocation.SuccessfulMatches.AddRange(fallbackResult.SuccessfulMatches);
|
||
|
||
// 从失败列表中移除成功分配的任务
|
||
var recoveredTaskIds = fallbackResult.SuccessfulMatches.Select(m => m.TaskId).ToHashSet();
|
||
result.PersonnelAllocation.FailedTasks = result.PersonnelAllocation.FailedTasks
|
||
.Where(f => !recoveredTaskIds.Contains(f.TaskId))
|
||
.ToList();
|
||
|
||
_logger.LogInformation("✅ 降级重试成功: 额外分配了 {RecoveredCount} 个任务",
|
||
fallbackResult.SuccessfulMatches.Count);
|
||
|
||
// 更新分配摘要
|
||
result.PersonnelAllocation.ProcessingDetails += $"; 降级重试恢复了{fallbackResult.SuccessfulMatches.Count}个任务";
|
||
}
|
||
else
|
||
{
|
||
_logger.LogWarning("⚠️ 降级重试未能恢复任何任务");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 优化的分时段人员分配方法
|
||
/// 架构设计：增强错误处理和智能重分配机制
|
||
/// </summary>
|
||
private async Task<PersonnelAllocationResult> ExecuteOptimizedTimeSegmentedAllocationAsync(
|
||
Dictionary<DateTime, List<WorkOrderEntity>> taskGroups,
|
||
IntegrationStrategy strategy,
|
||
long operatorUserId,
|
||
string operatorName)
|
||
{
|
||
var allSuccessfulMatches = new List<TaskPersonnelMatch>();
|
||
var allFailedTasks = new List<FailedTaskInfo>();
|
||
var totalFairnessScore = 0.0;
|
||
var processedDates = 0;
|
||
|
||
// 按日期优先级排序：预分配任务较多的日期优先处理
|
||
var sortedDateGroups = taskGroups
|
||
.OrderBy(g => g.Value.Count(t => !t.AssignedPersonnelId.HasValue || t.AssignedPersonnelId.Value == 0))
|
||
.ThenBy(g => g.Key);
|
||
|
||
foreach (var dateGroup in sortedDateGroups)
|
||
{
|
||
var date = dateGroup.Key;
|
||
var dailyTasks = dateGroup.Value;
|
||
|
||
_logger.LogInformation("🗓️ 处理 {Date} 的 {TaskCount} 个任务 (预分配: {PreAssignedCount})",
|
||
date.ToString("yyyy-MM-dd"), dailyTasks.Count,
|
||
dailyTasks.Count(t => t.AssignedPersonnelId.HasValue && t.AssignedPersonnelId.Value > 0));
|
||
|
||
// 为当日任务执行人员分配，采用逐步放松约束的策略
|
||
var dailyResult = await ExecuteDailyAllocationWithProgressiveRelaxationAsync(
|
||
dailyTasks, strategy, allSuccessfulMatches);
|
||
|
||
if (dailyResult?.SuccessfulMatches != null)
|
||
{
|
||
allSuccessfulMatches.AddRange(dailyResult.SuccessfulMatches);
|
||
_logger.LogInformation(" ✅ {Date} 分配成功 {SuccessCount} 个任务",
|
||
date.ToString("MM-dd"), dailyResult.SuccessfulMatches.Count);
|
||
}
|
||
|
||
if (dailyResult?.FailedTasks != null)
|
||
{
|
||
allFailedTasks.AddRange(dailyResult.FailedTasks);
|
||
if (dailyResult.FailedTasks.Any())
|
||
{
|
||
_logger.LogWarning(" ⚠️ {Date} 分配失败 {FailedCount} 个任务",
|
||
date.ToString("MM-dd"), dailyResult.FailedTasks.Count);
|
||
}
|
||
}
|
||
|
||
// 累计公平性评分
|
||
if (dailyResult?.FairnessScore > 0)
|
||
{
|
||
totalFairnessScore += dailyResult.FairnessScore;
|
||
processedDates++;
|
||
}
|
||
}
|
||
|
||
return new PersonnelAllocationResult
|
||
{
|
||
SuccessfulMatches = allSuccessfulMatches,
|
||
FailedTasks = allFailedTasks,
|
||
FairnessScore = (int)(processedDates > 0 ? totalFairnessScore / processedDates : 0),
|
||
AllocationStrategy = strategy.PersonnelStrategy.ToString(),
|
||
ProcessingDetails = $"优化分时段处理: {taskGroups.Count}个日期组，成功分配{allSuccessfulMatches.Count}个任务"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 每日分配的渐进式约束放松策略
|
||
/// 深度业务思考：从严格约束开始，逐步放松直到找到可行解
|
||
/// </summary>
|
||
private async Task<PersonnelAllocationResult> ExecuteDailyAllocationWithProgressiveRelaxationAsync(
|
||
List<WorkOrderEntity> dailyTasks,
|
||
IntegrationStrategy strategy,
|
||
List<TaskPersonnelMatch> existingMatches)
|
||
{
|
||
// 策略1：标准约束
|
||
var standardGlobalInput = new GlobalAllocationInput
|
||
{
|
||
Tasks = dailyTasks,
|
||
ExcludedPersonnelIds = new List<long>()
|
||
// TODO: 未来版本支持现有分配考虑
|
||
// ExistingAllocations = existingMatches
|
||
};
|
||
|
||
var standardGlobalResult = await _globalPersonnelAllocationService.AllocatePersonnelGloballyAsync(standardGlobalInput);
|
||
var result = ConvertToPersonnelAllocationResult(standardGlobalResult);
|
||
|
||
// 如果标准策略成功率较高，直接返回
|
||
if (result?.SuccessfulMatches?.Count > 0 &&
|
||
(result.FailedTasks?.Count ?? 0) <= dailyTasks.Count * 0.3)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
// 策略2：放松班次规则
|
||
_logger.LogInformation(" 🔄 标准策略效果不佳，尝试放松班次规则...");
|
||
var relaxedGlobalInput = new GlobalAllocationInput
|
||
{
|
||
Tasks = dailyTasks,
|
||
ExcludedPersonnelIds = new List<long>()
|
||
// TODO: 未来版本支持约束放松
|
||
// AllowConstraintRelaxation = true
|
||
};
|
||
|
||
var relaxedGlobalResult = await _globalPersonnelAllocationService.AllocatePersonnelGloballyAsync(relaxedGlobalInput);
|
||
var relaxedResult = ConvertToPersonnelAllocationResult(relaxedGlobalResult);
|
||
|
||
if (relaxedResult?.SuccessfulMatches?.Count > result?.SuccessfulMatches?.Count)
|
||
{
|
||
return relaxedResult;
|
||
}
|
||
|
||
// 策略3：最宽松约束
|
||
_logger.LogInformation(" 🔄 尝试最宽松约束策略...");
|
||
var fallbackGlobalInput = new GlobalAllocationInput
|
||
{
|
||
Tasks = dailyTasks,
|
||
ExcludedPersonnelIds = new List<long>()
|
||
// TODO: 未来版本支持更多宽松约束
|
||
// MaxContinuousWorkDays = 10,
|
||
// IgnoreDateConstraints = true
|
||
};
|
||
|
||
var fallbackGlobalResult = await _globalPersonnelAllocationService.AllocatePersonnelGloballyAsync(fallbackGlobalInput);
|
||
var fallbackResult = ConvertToPersonnelAllocationResult(fallbackGlobalResult);
|
||
|
||
// 返回效果最好的结果
|
||
return SelectBestResult(result, relaxedResult, fallbackResult);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 选择最佳分配结果
|
||
/// </summary>
|
||
private PersonnelAllocationResult SelectBestResult(params PersonnelAllocationResult[] results)
|
||
{
|
||
return results
|
||
.Where(r => r != null)
|
||
.OrderByDescending(r => r.SuccessfulMatches?.Count ?? 0)
|
||
.ThenBy(r => r.FailedTasks?.Count ?? int.MaxValue)
|
||
.ThenByDescending(r => r.FairnessScore)
|
||
.FirstOrDefault() ?? new PersonnelAllocationResult
|
||
{
|
||
SuccessfulMatches = new List<TaskPersonnelMatch>(),
|
||
FailedTasks = new List<FailedTaskInfo>()
|
||
};
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region ISmartTaskIntegrationService 接口转发方法
|
||
|
||
/// <summary>
|
||
/// 转发到全局人员分配服务
|
||
/// </summary>
|
||
[HttpPost]
|
||
public async Task<PersonnelAllocationResult> AllocatePersonnelSmartlyAsync(PersonnelAllocationInput input)
|
||
{
|
||
// 将PersonnelAllocationInput转换为GlobalAllocationInput
|
||
var globalInput = new GlobalAllocationInput
|
||
{
|
||
Tasks = input.Tasks,
|
||
TaskIds = input.TaskIds,
|
||
ExcludedPersonnelIds = input.ExcludedPersonnelIds
|
||
};
|
||
|
||
var globalResult = await _globalPersonnelAllocationService.AllocatePersonnelGloballyAsync(globalInput);
|
||
return ConvertToPersonnelAllocationResult(globalResult);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 转发到设备分配服务
|
||
/// </summary>
|
||
[HttpPost]
|
||
public async Task<EquipmentAllocationResult> AllocateEquipmentSmartlyAsync(EquipmentAllocationInput input)
|
||
{
|
||
return await _equipmentAllocationService.AllocateEquipmentSmartlyAsync(input);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 转发到整合记录服务
|
||
/// </summary>
|
||
[HttpPost]
|
||
public async Task<IntegrationRecord> GenerateIntegrationRecordAsync(IntegrationRecordInput input)
|
||
{
|
||
return await _integrationRecordService.GenerateIntegrationRecordAsync(input);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取整合历史记录
|
||
/// </summary>
|
||
[HttpPost]
|
||
public async Task<List<IntegrationRecordListOutput>> GetIntegrationRecordsAsync(IntegrationRecordGetListInput input)
|
||
{
|
||
return await _integrationRecordService.GetIntegrationRecordsAsync(input);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取整合记录详细信息
|
||
/// </summary>
|
||
[HttpGet]
|
||
public async Task<IntegrationRecordWithTasksOutput?> GetIntegrationRecordDetailAsync(long integrationRecordId)
|
||
{
|
||
// 转发到整合记录服务或实现基本逻辑
|
||
return await _integrationRecordService.GetIntegrationRecordWithTasksAsync(integrationRecordId);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 发布任务
|
||
/// </summary>
|
||
/// <param name="input"></param>
|
||
/// <returns></returns>
|
||
[HttpPost]
|
||
public async Task<PublishIntegrationRecordResult> PublishIntegrationRecordAsync(PublishIntegrationRecordInput input)
|
||
{
|
||
return await _integrationRecordService.PublishIntegrationRecordAsync(input);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 转换全局分配结果为人员分配结果
|
||
/// 业务逻辑：适配不同服务间的数据结构差异，确保接口兼容性
|
||
/// </summary>
|
||
private PersonnelAllocationResult ConvertToPersonnelAllocationResult(GlobalAllocationResult globalResult)
|
||
{
|
||
return new PersonnelAllocationResult
|
||
{
|
||
IsSuccess = globalResult.IsSuccess,
|
||
SuccessfulMatches = globalResult.SuccessfulMatches?.Select(gm => new TaskPersonnelMatch
|
||
{
|
||
TaskId = gm.TaskId,
|
||
PersonnelId = gm.PersonnelId,
|
||
PersonnelName = gm.PersonnelName,
|
||
MatchScore = (int)gm.MatchScore,
|
||
TaskCode = $"WO_{gm.TaskId}",
|
||
MatchReason = gm.MatchReason
|
||
}).ToList() ?? new List<TaskPersonnelMatch>(),
|
||
FailedTasks = globalResult.FailedAllocations?.Select(gf => new FailedTaskInfo
|
||
{
|
||
TaskId = gf.TaskId,
|
||
TaskCode = gf.TaskCode,
|
||
FailureReason = gf.FailureReason,
|
||
FailureType = FailureType.PersonnelAllocationFailed,
|
||
ConflictDetails = gf.ConflictDetails
|
||
}).ToList() ?? new List<FailedTaskInfo>(),
|
||
FairnessScore = globalResult.FairnessAnalysis?.GiniCoefficient != null
|
||
? (int)((1.0 - globalResult.FairnessAnalysis.GiniCoefficient) * 100)
|
||
: 85,
|
||
AllocationStrategy = "GlobalOptimization",
|
||
ProcessingDetails = globalResult.AllocationSummary ?? "全局优化分配完成"
|
||
};
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
} |