using System.ComponentModel;
|
using System.Reflection;
|
using Newtonsoft.Json;
|
using SqlSugar;
|
using WIDESEA_Common.Constants;
|
using WIDESEA_Common.StockEnum;
|
using WIDESEA_Common.TaskEnum;
|
using WIDESEA_Core;
|
using WIDESEA_Core.Helper;
|
using WIDESEA_DTO.MES;
|
using WIDESEA_DTO.Task;
|
using WIDESEA_Model.Models;
|
|
namespace WIDESEA_TaskInfoService
|
{
|
public partial class TaskService
|
{
|
#region 手动任务
|
|
/// <summary>
|
/// 手动创建任务
|
/// </summary>
|
/// <param name="dto">手动创建任务参数</param>
|
/// <returns></returns>
|
public async Task<WebResponseContent> CreateManualTaskAsync(CreateManualTaskDto dto)
|
{
|
try
|
{
|
int taskType;
|
int taskStatus;
|
switch (dto.TaskType)
|
{
|
case "入库":
|
taskType = TaskInboundTypeEnum.Inbound.GetHashCode();
|
taskStatus = TaskInStatusEnum.InNew.GetHashCode();
|
break;
|
|
case "出库":
|
taskType = TaskOutboundTypeEnum.Outbound.GetHashCode();
|
taskStatus = TaskOutStatusEnum.OutNew.GetHashCode();
|
break;
|
|
case "移库":
|
taskType = TaskRelocationTypeEnum.Relocation.GetHashCode();
|
taskStatus = TaskRelocationStatusEnum.RelocationNew.GetHashCode();
|
break;
|
|
case "空箱入库":
|
taskType = TaskInboundTypeEnum.InEmpty.GetHashCode();
|
taskStatus = TaskInStatusEnum.InNew.GetHashCode();
|
break;
|
|
default:
|
return WebResponseContent.Instance.Error($"不支持的任务类型: {dto.TaskType}");
|
}
|
|
int taskNum = await BaseDal.GetTaskNo();
|
|
var task = new Dt_Task
|
{
|
TaskNum = taskNum,
|
PalletCode = dto.Barcode,
|
SourceAddress = dto.SourceAddress,
|
TargetAddress = dto.TargetAddress,
|
TaskType = taskType,
|
TaskStatus = taskStatus,
|
Grade = dto.Grade,
|
Roadway = dto.TargetAddress,
|
WarehouseId = dto.WarehouseId,
|
CurrentAddress = dto.SourceAddress,
|
NextAddress = dto.TargetAddress,
|
Creater = "manual",
|
CreateDate = DateTime.Now,
|
ModifyDate = DateTime.Now
|
};
|
|
var wmsTaskDtos = new List<WMSTaskDTO>()
|
{
|
new()
|
{
|
TaskNum = task.TaskNum,
|
PalletCode = task.PalletCode,
|
SourceAddress = task.SourceAddress,
|
TargetAddress = task.TargetAddress,
|
TaskType = task.TaskType,
|
Roadway = task.Roadway,
|
TaskStatus = task.TaskStatus,
|
WarehouseId = task.WarehouseId
|
}
|
};
|
|
return await _unitOfWorkManage.BeginTranAsync(async () =>
|
{
|
// 保存到数据库并同步发送给WCS
|
var result = await BaseDal.AddDataAsync(task) > 0;
|
if (!result)
|
return WebResponseContent.Instance.Error("创建任务失败");
|
|
var wcsResult = _httpClientHelper.Post<WebResponseContent>(
|
"http://localhost:9292/api/Task/ReceiveManualTask",
|
wmsTaskDtos.ToJson());
|
|
if (!wcsResult.IsSuccess || !wcsResult.Data.Status)
|
return WebResponseContent.Instance.Error($"任务已创建但发送给WCS失败:{wcsResult.ErrorMessage}\r\n {wcsResult.Data?.Message}");
|
|
return WebResponseContent.Instance.OK($"手动创建任务成功，任务号: {taskNum}");
|
});
|
}
|
catch (Exception ex)
|
{
|
return WebResponseContent.Instance.Error($"手动创建任务异常: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 手动下发任务到WCS（批量处理）
|
/// </summary>
|
/// <param name="dtos">下发任务参数列表</param>
|
/// <returns>批量下发结果</returns>
|
public async Task<WebResponseContent> DispatchTasksToWCSAsync(List<DispatchTaskDto> dtos)
|
{
|
try
|
{
|
if (dtos == null || !dtos.Any())
|
return WebResponseContent.Instance.Error("请选择要下发的任务");
|
|
var resultDto = new DispatchResultDto
|
{
|
SuccessCount = 0,
|
FailCount = 0,
|
FailResults = new List<DispatchTaskResultDto>()
|
};
|
|
// 第一步：查询并校验所有任务状态，收集有效任务
|
var validTasks = new List<(DispatchTaskDto Dto, Dt_Task Task)>();
|
|
foreach (var dto in dtos)
|
{
|
var task = await BaseDal.QueryFirstAsync(t => t.TaskId == dto.TaskId);
|
if (task == null)
|
{
|
resultDto.FailResults.Add(new DispatchTaskResultDto
|
{
|
TaskId = dto.TaskId,
|
TaskNum = 0,
|
Success = false,
|
ErrorMessage = "任务不存在"
|
});
|
resultDto.FailCount++;
|
continue;
|
}
|
|
// 校验任务状态：仅入库新单/出库新单/移库新单可下发
|
bool canDispatch = false;
|
if (task.TaskType == TaskInboundTypeEnum.Inbound.GetHashCode()
|
&& task.TaskStatus == TaskInStatusEnum.InNew.GetHashCode())
|
canDispatch = true;
|
else if (task.TaskType == TaskOutboundTypeEnum.Outbound.GetHashCode()
|
&& task.TaskStatus == TaskOutStatusEnum.OutNew.GetHashCode())
|
canDispatch = true;
|
else if (task.TaskType == TaskRelocationTypeEnum.Relocation.GetHashCode()
|
&& task.TaskStatus == TaskRelocationStatusEnum.RelocationNew.GetHashCode())
|
canDispatch = true;
|
|
if (!canDispatch)
|
{
|
var statusName = GetTaskStatusName(task.TaskType, task.TaskStatus);
|
resultDto.FailResults.Add(new DispatchTaskResultDto
|
{
|
TaskId = dto.TaskId,
|
TaskNum = task.TaskNum,
|
Success = false,
|
ErrorMessage = $"任务状态[{statusName}]不允许下发"
|
});
|
resultDto.FailCount++;
|
continue;
|
}
|
|
validTasks.Add((dto, task));
|
}
|
|
// 如果全部校验失败，直接返回
|
if (validTasks.Count == 0)
|
return WebResponseContent.Instance.Error($"下发失败，共{resultDto.FailCount}个任务");
|
|
// 第二步：构造所有WMSTaskDTO，一次性调用WCS
|
var wmsTaskDtos = validTasks.Select(vt => new WMSTaskDTO
|
{
|
Id = vt.Task.TaskId,
|
TaskNum = vt.Task.TaskNum,
|
PalletCode = vt.Dto.PalletCode,
|
SourceAddress = vt.Dto.SourceAddress,
|
TargetAddress = vt.Dto.TargetAddress,
|
CurrentAddress = vt.Dto.SourceAddress,
|
NextAddress = vt.Dto.TargetAddress,
|
TaskType = vt.Task.TaskType,
|
TaskStatus = vt.Task.TaskStatus,
|
Roadway = vt.Task.Roadway,
|
Grade = vt.Dto.Grade,
|
WarehouseId = vt.Task.WarehouseId,
|
PalletType = vt.Task.PalletType
|
}).ToList();
|
|
// 一次性调用WCS批量接口
|
var wcsResult = _httpClientHelper.Post<WebResponseContent>(
|
"http://localhost:9292/api/Task/ReceiveManualTask",
|
wmsTaskDtos.ToJson());
|
|
if (wcsResult == null || !wcsResult.IsSuccess)
|
{
|
// WCS调用失败，所有任务都算失败
|
// 尝试从WCS响应中解析错误详情
|
string errorDetail = "";
|
if (wcsResult?.Data != null)
|
{
|
// 尝试将Data转换为错误信息
|
try
|
{
|
var errorData = wcsResult.Data.ToString();
|
errorDetail = $"WCS错误: {errorData}";
|
}
|
catch
|
{
|
errorDetail = wcsResult?.ErrorMessage ?? "WCS响应异常";
|
}
|
}
|
else
|
{
|
errorDetail = wcsResult?.ErrorMessage ?? "WCS响应异常";
|
}
|
|
foreach (var vt in validTasks)
|
{
|
resultDto.FailResults.Add(new DispatchTaskResultDto
|
{
|
TaskId = vt.Dto.TaskId,
|
TaskNum = vt.Task.TaskNum,
|
Success = false,
|
ErrorMessage = $"{errorDetail} (任务号:{vt.Task.TaskNum}, 托盘:{vt.Dto.PalletCode})"
|
});
|
resultDto.FailCount++;
|
}
|
resultDto.SuccessCount = 0;
|
return WebResponseContent.Instance.Error($"WCS批量下发失败，共{resultDto.FailCount}个任务");
|
}
|
|
// WCS调用成功，解析返回的结构化数据
|
ReceiveTaskResultDto wcsResultData = null;
|
try
|
{
|
if (wcsResult.Data?.Data != null)
|
{
|
var jsonStr = wcsResult.Data.Data.ToString();
|
if (!string.IsNullOrEmpty(jsonStr) && jsonStr.Contains("duplicateTasks"))
|
{
|
wcsResultData = JsonConvert.DeserializeObject<ReceiveTaskResultDto>(jsonStr);
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
// 解析WCS返回数据失败，记录日志但继续处理
|
Console.WriteLine($"解析WCS返回数据异常: {ex.Message}");
|
}
|
|
// 如果有重复任务，记录到失败结果中
|
if (wcsResultData?.DuplicateTasks != null && wcsResultData.DuplicateTasks.Count > 0)
|
{
|
foreach (var dup in wcsResultData.DuplicateTasks)
|
{
|
var statusName = GetTaskStatusName(dup.TaskType, dup.TaskStatus);
|
resultDto.FailResults.Add(new DispatchTaskResultDto
|
{
|
TaskId = 0, // 重复任务可能没有WMS的TaskId
|
TaskNum = dup.TaskNum,
|
Success = false,
|
ErrorMessage = $"WCS中已存在该任务(托盘:{dup.PalletCode}, 状态:{statusName})"
|
});
|
resultDto.FailCount++;
|
}
|
}
|
|
// 第三步：WCS调用成功后，批量更新DB
|
foreach (var vt in validTasks)
|
{
|
vt.Task.PalletCode = vt.Dto.PalletCode;
|
vt.Task.SourceAddress = vt.Dto.SourceAddress;
|
vt.Task.TargetAddress = vt.Dto.TargetAddress;
|
vt.Task.CurrentAddress = vt.Dto.SourceAddress;
|
vt.Task.NextAddress = vt.Dto.TargetAddress;
|
vt.Task.Grade = vt.Dto.Grade;
|
vt.Task.Dispatchertime = DateTime.Now;
|
}
|
|
// 批量更新DB
|
var tasksToUpdate = validTasks.Select(vt => vt.Task).ToList();
|
await BaseDal.UpdateDataAsync(tasksToUpdate);
|
|
resultDto.SuccessCount = validTasks.Count - (wcsResultData?.DuplicateTasks?.Count ?? 0);
|
|
if (resultDto.FailCount == 0)
|
return WebResponseContent.Instance.OK($"成功下发{resultDto.SuccessCount}个任务", resultDto);
|
|
var errorResponse = WebResponseContent.Instance.Error($"部分下发成功{resultDto.SuccessCount}个，失败{resultDto.FailCount}个");
|
errorResponse.Data = resultDto;
|
return errorResponse;
|
}
|
catch (Exception ex)
|
{
|
return WebResponseContent.Instance.Error($"下发任务异常: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 获取任务状态名称
|
/// </summary>
|
/// <param name="taskType">任务类型</param>
|
/// <param name="taskStatus">任务状态</param>
|
/// <returns>状态的中文描述</returns>
|
private string GetTaskStatusName(int taskType, int taskStatus)
|
{
|
FieldInfo? fieldInfo = taskType switch
|
{
|
_ when taskType == TaskInboundTypeEnum.Inbound.GetHashCode() => typeof(TaskInStatusEnum).GetField(((TaskInStatusEnum)taskStatus).ToString()),
|
_ when taskType == TaskOutboundTypeEnum.Outbound.GetHashCode() => typeof(TaskOutStatusEnum).GetField(((TaskOutStatusEnum)taskStatus).ToString()),
|
_ when taskType == TaskRelocationTypeEnum.Relocation.GetHashCode() => typeof(TaskRelocationStatusEnum).GetField(((TaskRelocationStatusEnum)taskStatus).ToString()),
|
_ => null
|
};
|
|
var descAttr = fieldInfo?.GetCustomAttributes(typeof(DescriptionAttribute), false)
|
.FirstOrDefault() as DescriptionAttribute;
|
return descAttr?.Description ?? taskStatus.ToString();
|
}
|
|
/// <summary>
|
/// 组盘/拆盘操作并创建入库任务，完成后下发WCS
|
/// </summary>
|
/// <param name="dto">组盘/拆盘操作参数</param>
|
/// <returns>操作结果</returns>
|
public async Task<WebResponseContent> PalletOperationAndCreateTaskAsync(PalletOperationTaskDto dto)
|
{
|
try
|
{
|
// 1. 参数校验
|
if (string.IsNullOrWhiteSpace(dto.PalletCode))
|
return WebResponseContent.Instance.Error("托盘号不能为空");
|
|
if (string.IsNullOrWhiteSpace(dto.Action)
|
|| (dto.Action != "组盘" && dto.Action != "拆盘"))
|
return WebResponseContent.Instance.Error("执行动作必须是'组盘'或'拆盘'");
|
|
if (string.IsNullOrWhiteSpace(dto.LineId))
|
return WebResponseContent.Instance.Error("线体编号不能为空");
|
|
if (string.IsNullOrWhiteSpace(dto.WarehouseCode))
|
return WebResponseContent.Instance.Error("仓库编号不能为空");
|
|
if (string.IsNullOrWhiteSpace(dto.RobotName))
|
return WebResponseContent.Instance.Error("机械手名称不能为空");
|
|
// 组盘时电芯列表必传
|
if (dto.Action == "组盘" && (dto.Cells == null || !dto.Cells.Any()))
|
return WebResponseContent.Instance.Error("组盘时电芯列表不能为空");
|
|
// 2. 根据仓库编号查询仓库信息，获取 WarehouseId、targetAddress 和 roadway
|
var warehouse = _sqlSugarClient.Queryable<Dt_Warehouse>()
|
.First(w => w.WarehouseCode == dto.WarehouseCode);
|
if (warehouse == null)
|
return WebResponseContent.Instance.Error($"未找到仓库编号为[{dto.WarehouseCode}]的仓库");
|
|
int warehouseId = warehouse.WarehouseId;
|
string targetAddress = warehouse.WarehouseCode;
|
string roadway = warehouse.WarehouseCode;
|
|
// 3. 根据动作类型执行不同流程
|
if (dto.Action == "组盘")
|
return await ExecuteGroupPalletAsync(dto, warehouseId, targetAddress, roadway);
|
|
return await ExecuteSplitPalletAsync(dto, warehouseId, targetAddress, roadway);
|
}
|
catch (Exception ex)
|
{
|
return WebResponseContent.Instance.Error($"组盘/拆盘操作异常: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 执行组盘操作：添加库存 → 直接调用MES绑定 → 创建入库任务 → 下发WCS
|
/// </summary>
|
private async Task<WebResponseContent> ExecuteGroupPalletAsync(
|
PalletOperationTaskDto dto, int warehouseId, string targetAddress, string roadway)
|
{
|
return await _unitOfWorkManage.BeginTranAsync(async () =>
|
{
|
// 1. 创建库存主记录（不绑定货位）
|
var stockInfo = new Dt_StockInfo
|
{
|
PalletCode = dto.PalletCode,
|
PalletType = 0,
|
WarehouseId = warehouseId,
|
LocationId = 0,
|
StockStatus = 0,
|
MesUploadStatus = 0
|
};
|
var stockId = await _stockInfoService.Repository.AddDataAsync(stockInfo);
|
if (stockId <= 0)
|
return WebResponseContent.Instance.Error("创建库存记录失败");
|
|
// 2. 批量创建库存明细
|
var details = dto.Cells.Select((cell, i) => new Dt_StockInfoDetail
|
{
|
StockId = (int)stockId,
|
MaterielCode = cell.SfcCode,
|
MaterielName = "",
|
OrderNo = "",
|
ProductionDate = DateTime.Now.ToString("yyyy-MM-dd"),
|
EffectiveDate = "",
|
SerialNumber = cell.SfcCode,
|
StockQuantity = 1,
|
OutboundQuantity = 0,
|
Status = 0,
|
InboundOrderRowNo = Convert.ToInt32(cell.Channel),
|
Remark = cell.Channel
|
}).ToList();
|
if (await _sqlSugarClient.Insertable(details).ExecuteCommandAsync() <= 0)
|
return WebResponseContent.Instance.Error("创建库存明细失败");
|
|
// 3. 调用MES绑定
|
var (equipmentCode, resourceCode, token) = ResolveMesConfig(dto.RobotName);
|
var bindRequest = new BindContainerRequest
|
{
|
ContainerCode = dto.PalletCode,
|
EquipmentCode = equipmentCode,
|
ResourceCode = resourceCode,
|
LocalTime = DateTime.Now,
|
OperationType = StockConstants.MES_BIND_OPERATION_TYPE,
|
ContainerSfcList = dto.Cells.Select((cell, i) => new ContainerSfcItem
|
{
|
Sfc = cell.SfcCode,
|
Location = cell.Channel
|
}).ToList()
|
};
|
var mesResult = string.IsNullOrWhiteSpace(token)
|
? _mesService.BindContainer(bindRequest)
|
: _mesService.BindContainer(bindRequest, token);
|
if (!CheckMesResult(mesResult, out var mesError))
|
return WebResponseContent.Instance.Error($"MES组盘绑定失败: {mesError}");
|
|
// 4. 创建入库任务并下发WCS
|
return await CreateTaskAndDispatchAsync(dto, warehouseId, targetAddress, roadway,
|
TaskInboundTypeEnum.Inbound, "组盘成功并创建入库任务");
|
});
|
}
|
|
/// <summary>
|
/// 执行拆盘操作：查询库存 → 直接调用MES解绑 → 清除库存货位 → 创建空托盘入库任务 → 下发WCS
|
/// </summary>
|
private async Task<WebResponseContent> ExecuteSplitPalletAsync(
|
PalletOperationTaskDto dto, int warehouseId, string targetAddress, string roadway)
|
{
|
return await _unitOfWorkManage.BeginTranAsync(async () =>
|
{
|
// 1. 导航查询库存及明细
|
var stockInfo = await _stockInfoService.Repository
|
.QueryDataNavFirstAsync(s => s.PalletCode == dto.PalletCode);
|
if (stockInfo == null)
|
return WebResponseContent.Instance.Error($"未找到托盘[{dto.PalletCode}]的库存记录");
|
|
var sfcList = stockInfo.Details?.Select(d => d.SerialNumber).ToList()
|
?? new List<string>();
|
if (!sfcList.Any())
|
return WebResponseContent.Instance.Error($"托盘[{dto.PalletCode}]下无电芯数据");
|
|
// 2. 调用MES解绑
|
var (equipmentCode, resourceCode, token) = ResolveMesConfig(dto.RobotName);
|
var unbindRequest = new UnBindContainerRequest
|
{
|
EquipmentCode = equipmentCode,
|
ResourceCode = resourceCode,
|
LocalTime = DateTime.Now,
|
ContainCode = dto.PalletCode,
|
SfcList = sfcList
|
};
|
var mesResult = string.IsNullOrWhiteSpace(token)
|
? _mesService.UnBindContainer(unbindRequest)
|
: _mesService.UnBindContainer(unbindRequest, token);
|
if (!CheckMesResult(mesResult, out var mesError))
|
return WebResponseContent.Instance.Error($"MES拆盘解绑失败: {mesError}");
|
|
// 3. 清除库存绑定的货位
|
stockInfo.LocationId = 0;
|
stockInfo.LocationCode = null;
|
await _sqlSugarClient.Updateable(stockInfo)
|
.UpdateColumns(s => new { s.LocationId, s.LocationCode })
|
.ExecuteCommandAsync();
|
|
// 4. 创建空托盘入库任务并下发WCS
|
return await CreateTaskAndDispatchAsync(dto, warehouseId, targetAddress, roadway,
|
TaskInboundTypeEnum.InEmpty, "拆盘成功并创建空托盘入库任务");
|
});
|
}
|
|
/// <summary>
|
/// 解析MES设备配置，返回 (equipmentCode, resourceCode, token)
|
/// </summary>
|
private (string equipmentCode, string resourceCode, string token) ResolveMesConfig(string deviceName)
|
{
|
var config = _mesDeviceConfigService.GetByDeviceName(deviceName);
|
return (
|
config?.EquipmentCode ?? StockConstants.MES_EQUIPMENT_CODE,
|
config?.ResourceCode ?? StockConstants.MES_RESOURCE_CODE,
|
config?.Token
|
);
|
}
|
|
/// <summary>
|
/// 检查MES返回结果，失败时通过 error 输出错误信息
|
/// </summary>
|
private bool CheckMesResult(HttpResponseResult<MesResponse> result, out string error)
|
{
|
if (result?.Data != null && result.Data.IsSuccess)
|
{
|
error = null;
|
return true;
|
}
|
|
error = result?.Data?.Msg ?? result?.ErrorMessage ?? "未知错误";
|
return false;
|
}
|
|
/// <summary>
|
/// 创建入库任务并下发WCS
|
/// </summary>
|
private async Task<WebResponseContent> CreateTaskAndDispatchAsync(
|
PalletOperationTaskDto dto, int warehouseId, string targetAddress, string roadway,
|
TaskInboundTypeEnum taskType, string successMessage)
|
{
|
int taskNum = await BaseDal.GetTaskNo();
|
var task = new Dt_Task
|
{
|
TaskNum = taskNum,
|
PalletCode = dto.PalletCode,
|
SourceAddress = dto.LineId,
|
TargetAddress = targetAddress,
|
TaskType = taskType.GetHashCode(),
|
TaskStatus = TaskInStatusEnum.InNew.GetHashCode(),
|
Grade = dto.Grade,
|
Roadway = roadway,
|
WarehouseId = warehouseId,
|
CurrentAddress = dto.LineId,
|
NextAddress = targetAddress,
|
Creater = "manual",
|
CreateDate = DateTime.Now,
|
ModifyDate = DateTime.Now
|
};
|
|
if (await BaseDal.AddDataAsync(task) <= 0)
|
return WebResponseContent.Instance.Error("创建任务失败");
|
|
var wmsTaskDto = new WMSTaskDTO
|
{
|
TaskNum = task.TaskNum,
|
PalletCode = task.PalletCode,
|
SourceAddress = task.SourceAddress,
|
TargetAddress = task.TargetAddress,
|
TaskType = task.TaskType,
|
Roadway = task.Roadway,
|
TaskStatus = task.TaskStatus,
|
WarehouseId = task.WarehouseId
|
};
|
|
var wcsResult = _httpClientHelper.Post<WebResponseContent>(
|
"http://localhost:9292/api/Task/ReceiveManualTask",
|
new List<WMSTaskDTO> { wmsTaskDto }.ToJson());
|
|
if (!wcsResult.IsSuccess || !wcsResult.Data.Status)
|
return WebResponseContent.Instance.Error(
|
$"任务已创建但发送给WCS失败: {wcsResult.ErrorMessage}\r\n {wcsResult.Data?.Message}");
|
|
return WebResponseContent.Instance.OK($"{successMessage}，任务号: {taskNum}");
|
}
|
|
#endregion 手动任务
|
}
|
}
|
