DeLi/FuJiLiTiKu.git

#region << 版 本 注 释 >>
/*----------------------------------------------------------------
 * 命名空间：WIDESEAWCS_TaskInfoService
 * 创建者：胡童庆
 * 创建时间：2024/8/2 16:13:36
 * 版本：V1.0.0
 * 描述：
 *
 * ----------------------------------------------------------------
 * 修改人：
 * 修改时间：
 * 版本：V1.0.1
 * 修改说明：
 * 
 *----------------------------------------------------------------*/
#endregion << 版 本 注 释 >>
 
using AutoMapper;
using Microsoft.AspNetCore.Mvc.RazorPages;
using NetTaste;
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
using SqlSugar;
using StackExchange.Profiling.Internal;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Metadata;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Comm.Http;
using WIDESEA_Common.Log;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Core.Enums;
using WIDESEAWCS_Core.Utilities;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_TaskInfoRepository;
using static Microsoft.IO.RecyclableMemoryStreamManager;
 
namespace WIDESEAWCS_TaskInfoService
{
    public partial class TaskService : ServiceBase<Dt_Task, ITaskRepository>, ITaskService
    {
        private readonly IRouterService _routerService;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly ITaskExecuteDetailRepository _taskExecuteDetailRepository;
        private readonly ITask_HtyService _task_HtyService;
        private readonly ITask_HtyRepository _task_HtyRepository;
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IDt_roadwayinfoService _Dt_roadwayinfoService;
 
        private Dictionary<string, OrderByType> _taskOrderBy = new()
            {
                {nameof(Dt_Task.Grade),OrderByType.Desc },
                {nameof(Dt_Task.CreateDate),OrderByType.Asc},
            };
 
        public Dictionary<string, OrderByType> TaskOrderBy { get { return _taskOrderBy; } set { _taskOrderBy = value; } }
 
        public string urlWMSIsRelocations = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSIsRelocations"];
        public string urlWMSInOutTaskReporting = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSInOutTaskReporting"];
        public string urlWMSTaskCompleted = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSTaskCompleted"];
 
        public TaskService(ITaskRepository BaseDal, IRouterService routerService, ITaskExecuteDetailService taskExecuteDetailService, ITaskExecuteDetailRepository taskExecuteDetailRepository, IMapper mapper, ITask_HtyService task_HtyService, ITask_HtyRepository task_HtyRepository, IUnitOfWorkManage unitOfWork, IDt_roadwayinfoService dt_RoadwayinfoService) : base(BaseDal)
        {
            _routerService = routerService;
            _taskExecuteDetailService = taskExecuteDetailService;
            _taskExecuteDetailRepository = taskExecuteDetailRepository;
            _task_HtyService = task_HtyService;
            _task_HtyRepository = task_HtyRepository;
            _mapper = mapper;
            _unitOfWorkManage = unitOfWork;
            _Dt_roadwayinfoService = dt_RoadwayinfoService;
        }
 
 
 
 
 
        /// <summary>
        /// 任务完成
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns></returns>
        public WebResponseContent StackCraneTaskCompleted(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
 
                if (task.TaskType == (int)TaskTypeEnum.Outbound)
                {
                    if (task.TaskStatus == (int)TaskOutStatusEnum.SC_OutExecuting)
                    {
                        //传入状态后，需要在方法里面进行地址更改
                        UpdateTaskStatusToNext(task.TaskNum);
 
                        /*content = HttpHelper.Get<WebResponseContent>($"{urlWMSTaskCompleted}?taskNum={task.TaskNum}");
 
                        if (!content.Status)
                        {
                            WriteLog.GetLog("任务完成").Write($"失败信息：{content.Message}", "任务完成上报WMS");
                            return content;
                        }
*/
                    }
                    else if (task.TaskStatus == (int)TaskOutStatusEnum.Line_OutExecuting)
                    {
                        task.TaskStatus = (int)TaskOutStatusEnum.OutFinish;
 
                        task.ModifyDate = DateTime.Now;
                        task.Modifier = "System";
                        BaseDal.DeleteData(task);
                        _task_HtyService.AddTaskHty(task);
                        _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"入库完成");
 
                        //上传WMS输送线完成
                    }
                    else
                    {
                        throw new Exception($"任务状态错误,任务完成中，没有这个状态的完成，任务号:【{taskNum}】");
                    }
 
                }
                else if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)
                {
                    if (task.TaskStatus == (int)TaskInStatusEnum.Line_InExecuting)
                    {
                        task.TaskStatus = (int)TaskInStatusEnum.Line_InFinish;
                        BaseDal.UpdateData(task);
 
                        //完成后，需要申请wms进行入库
                    }
                    else if (task.TaskStatus == (int)TaskInStatusEnum.SC_InExecuting)
                    {
                        task.TaskStatus = (int)TaskInStatusEnum.InFinish;
 
                        task.ModifyDate = DateTime.Now;
                        task.Modifier = "System";
                        BaseDal.DeleteData(task);
                        _task_HtyService.AddTaskHty(task);
                        _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"入库完成");
 
                        //上传WMS输送线完成
                    }
                    else
                    {
                        throw new Exception($"任务状态错误,任务完成中，没有这个状态的完成，任务号:【{taskNum}】");
                    }
                }
                else
                {
                    throw new Exception($"任务类型错误,未找到该任务类型,任务号:【{taskNum}】,任务类型:【{task.TaskType}】");
                }
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error($"任务完成异常,任务号:【{taskNum}】，原因：{ex.Message}");
            }
            return content;
        }
 
 
 
        /// <summary>
        /// 将任务状态修改为下一个状态
        /// </summary>
        /// <param name="taskNum">任务号</param>
        public WebResponseContent UpdateTaskStatusToNext(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
                return UpdateTaskStatusToNext(task);
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }
 
        /// <summary>
        /// 将任务状态修改为下一个状态
        /// </summary>
        /// <param name="task">任务实体对象</param>
        /// <returns></returns>
        public WebResponseContent UpdateTaskStatusToNext([NotNull] Dt_Task task)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                int oldState = task.TaskStatus;
                if (task.TaskType == (int)TaskTypeEnum.Outbound)
                {
                    if (task.TaskStatus >= (int)TaskOutStatusEnum.OutFinish)
                    {
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskStatus}】");
                    }
                    int nextStatus = task.TaskStatus.GetNextNotCompletedStatus<TaskOutStatusEnum>();
 
                    task.TaskStatus = nextStatus;
                    task.Dispatchertime = DateTime.Now;
 
                    //上报wms堆垛机执行中
                    TaskReportRequest taskReport = new TaskReportRequest{
                        TaskNum = task.TaskNum,
                        TaskStatus=task.TaskStatus,
                        CurrentAddress = task.CurrentAddress,
                        NextAddress = task.NextAddress,
                    };
 
                    content = HttpHelper.Post<WebResponseContent>($"{urlWMSInOutTaskReporting}", taskReport);
                    if(!content.Status) return content;
 
                }
                else if (task.TaskType == (int)TaskTypeEnum.Inbound)
                {
                    if (task.TaskStatus >= (int)TaskInStatusEnum.InFinish)
                    {
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskStatus}】");
                    }
                    int nextStatus = task.TaskStatus.GetNextNotCompletedStatus<TaskOutStatusEnum>();
                    task.TaskStatus = nextStatus;
                    task.Dispatchertime = DateTime.Now;
 
                }
                else if (task.TaskType == (int)TaskTypeEnum.Relocation)
                {
                    if (task.TaskStatus >= (int)TaskRelocationStatusEnum.SC_RelocationFinish)
                    {
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskStatus}】");
                    }
                    int nextStatus = task.TaskStatus.GetNextNotCompletedStatus<TaskRelocationStatusEnum>();
                    task.TaskStatus = nextStatus;
                    task.Dispatchertime = DateTime.Now;
                }
                else
                {
                    throw new Exception($"任务类型错误,未找到该任务类型,任务号:【{task.TaskNum}】,任务类型:【{task.TaskType}】");
                }
 
                if (task.TaskStatus <= 0)
                {
                    return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskStatus}】");
                }
 
 
                task.ModifyDate = DateTime.Now;
                task.Modifier = "System";
                BaseDal.UpdateData(task);
 
                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, App.User.UserId > 0 ? $"人工手动将任务状态从【{oldState}】跳转到【{task.TaskStatus}】" : $"系统自动流程，任务状态从【{oldState}】转到【{task.TaskStatus}】");
 
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error("WCS接口执行下一任务状态错误："+ex.Message);
            }
            return content;
        }
 
        /// <summary>
        /// 更新任务异常信息显示
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <param name="message">异常信息</param>
        public WebResponseContent UpdateTaskExceptionMessage(int taskNum, string message)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
                if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                {
                    task.TaskStatus = (int)TaskOutStatusEnum.OutPending;
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                {
                    task.TaskStatus = (int)TaskInStatusEnum.InPending;
                }
                task.ExceptionMessage = message;
                task.ModifyDate = DateTime.Now;
                BaseDal.UpdateData(task);
 
                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, task.ExceptionMessage);
 
                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }
 
 
 
 
 
 
 
 
 
        /// <summary>
        /// 恢复挂起任务
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns>返回处理结果</returns>
        public WebResponseContent TaskStatusRecovery(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
                if (task.TaskStatus != (int)TaskInStatusEnum.InPending && task.TaskStatus != (int)TaskOutStatusEnum.OutPending)
                {
                    return content = WebResponseContent.Instance.Error($"该任务状态不可恢复,任务号:【{taskNum}】,任务状态:【{task.TaskStatus}】");
                }
 
                Dt_TaskExecuteDetail taskExecuteDetail = _taskExecuteDetailRepository.QueryFirst(x => x.TaskId == task.TaskId && x.IsNormal, new Dictionary<string, OrderByType> { { nameof(Dt_TaskExecuteDetail.TaskDetailId), OrderByType.Desc } });
                if (taskExecuteDetail != null)
                {
                    task.TaskStatus = taskExecuteDetail.TaskStatus;
                }
                else
                {
                    if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                    {
                        task.TaskStatus = (int)TaskOutStatusEnum.OutNew;
                    }
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                    {
                        task.TaskStatus = (int)TaskInStatusEnum.InNew;
                    }
                    //todo
                }
 
                task.ExceptionMessage = string.Empty;
 
                BaseDal.UpdateData(task);
 
                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"人工恢复挂起任务,恢复挂起时任务状态【{task.TaskStatus}】");
 
                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }
 
        /// <summary>
        /// 回滚任务状态
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns>返回处理结果</returns>
        public WebResponseContent RollbackTaskStatusToLast(int taskNum)
        {
            WebResponseContent content = new();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
 
                int oldState = task.TaskStatus;
                Dt_TaskExecuteDetail taskExecuteDetail = _taskExecuteDetailRepository.QueryFirst(x => x.TaskId == task.TaskId && x.TaskStatus < task.TaskStatus && x.TaskStatus > 0, new Dictionary<string, OrderByType> { { nameof(Dt_TaskExecuteDetail.TaskDetailId), OrderByType.Desc } });
                if (taskExecuteDetail != null)
                {
                    task.TaskStatus = taskExecuteDetail.TaskStatus;
                    task.CurrentAddress = taskExecuteDetail.CurrentAddress;
                    task.NextAddress = taskExecuteDetail.NextAddress;
                }
                else
                {
                    return content = WebResponseContent.Instance.Error($"未找到任务明细信息,该任务状态不可回滚到上一步,任务号:【{taskNum}】,任务状态:【{task.TaskStatus}】");
                }
 
                task.ExceptionMessage = string.Empty;
 
                BaseDal.UpdateData(task);
 
                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"人工将任务状态从【{oldState}】回滚到【{task.TaskStatus}】");
 
                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }
 
 
 
        public WebResponseContent DeleteWCSTask(int tasknum)
        {
            Dt_Task tasks = BaseDal.QueryFirst(x => x.TaskNum == tasknum);
            if (tasks == null)
            {
                return WebResponseContent.Instance.Error();
            }
            else
            {
                try
                {
                    _task_HtyService.AddTaskHty(tasks);
                    BaseDal.DeleteData(tasks);
                    WriteLog.Write_Log("WMS手动删除任务", "删除成功", $"申请删除的条码：{tasks.TaskNum},托盘条码：{tasks.PalletCode}", new { 信息 = "删除成功" });
                    return WebResponseContent.Instance.OK();
 
                }
                catch (Exception ex)
                {
                    WriteLog.Write_Log("WMS手动删除任务", "删除失败", $"申请删除的条码：{tasks.TaskNum},托盘条码：{tasks.PalletCode}", new { 信息 = ex.Message });
                    return WebResponseContent.Instance.Error();
                }
            }
 
        }
 
 
        public void wcs_PLCto09(string SCLLinStack, string Logtype, string Magessadd)
        {
            WriteLog.Write_Log("任务完成交互", SCLLinStack, Logtype, new { 信息 = Magessadd });
        }
 
 
 
        //============================================以下是后续新增内容查找任务=============================================================
        /// <summary>
        /// 根据设备编号、当前地址按照优先级以及创建时间排序查询任务池新增的任务
        /// </summary>
        /// <param name="deviceNo">设备编号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns>返回任务实体对象，可能为null</returns>
        public List<Dt_Task> QueryStackerCraneTask(string deviceNo, string currentAddress = "")
        {
            return BaseDal.QueryData(x => x.Roadway == deviceNo && ((x.TaskStatus == (int)TaskInStatusEnum.Line_InFinish && !string.IsNullOrEmpty(x.NextAddress)) || x.TaskStatus == (int)TaskOutStatusEnum.OutNew), TaskOrderBy);
        }
 
 
        /// <summary>
        /// 获取当前设备是否有在执行中的任务
        /// </summary>
        /// <param name="deviceNo"></param>
        /// <returns></returns>
        public Dt_Task CutStackerCraneTask(string deviceNo)
        {
            Dt_Task dt_Task = BaseDal.QueryFirst(x => x.Roadway == deviceNo && (x.TaskStatus == (int)TaskOutStatusEnum.SC_OutExecuting || x.TaskStatus == (int)TaskInStatusEnum.SC_InExecuting || x.TaskStatus == (int)TaskRelocationStatusEnum.SC_RelocationExecuting));
            return dt_Task;
        }
 
        public Dt_Task RequestWMSTaskMovelibrary(Dt_Task dt_Task)
        {
            WebResponseContent content = new WebResponseContent();
 
            content = HttpHelper.Get<WebResponseContent>($"{urlWMSIsRelocations}?tasknum={dt_Task.TaskNum}");
 
            if (!content.Status)
            {
                WriteLog.GetLog("PLC日志").Write($"失败信息：{content.Message}", "移库信息");
                return null;
            }
 
            if (content.Data == null) return null;
 
            Dt_Task WMStask = JsonConvert.DeserializeObject<Dt_Task>(content.Data.ToString());
 
            if (WMStask.TaskNum != dt_Task.TaskNum)
            {
                //任务不一样,则判断是否是移库或当前已有出库任务
 
                if (WMStask.TaskType == (int)TaskTypeEnum.Relocation)
                {
                    Dt_Task _TaskRe = BaseDal.QueryData(x => x.PalletCode == WMStask.PalletCode).FirstOrDefault();
                    if (_TaskRe == null) { BaseDal.AddData(WMStask); return WMStask; }
                    else
                    {
                        return _TaskRe;
                    }
                    
                }
                else
                {
                    return WMStask;
                }
            }
            else
            {
                //任务一样，则返回当前的任务
                return dt_Task;
            }
        }
 
    }
}