忽略项

陈勇

2024-11-14 2c4c125072e1b88c994efc9bb6f1ff5ef754d41b

忽略项

 Code Management/WCS/WIDESEAWCS_Client/src/api/http.js

@@ -19,7 +19,7 @@
}

else if (process.env.NODE_ENV == 'production') {
    axios.defaults.baseURL = 'http://115.159.85.185:9291/';
    axios.defaults.baseURL = 'http://127.0.0.1:9291/';
}
if (!axios.defaults.baseURL.endsWith('/')) {
    axios.defaults.baseURL+="/";

 Code Management/WCS/WIDESEAWCS_Client/src/extension/quartzJob/deviceInfo.js

@@ -31,7 +31,7 @@
        icon: "el-icon-document", //按钮图标vue2版本见iview文档icon，vue3版本见element ui文档icon(注意不是element puls文档)
        type: "primary", //按钮样式vue2版本见iview文档button，vue3版本见element ui文档button
        onClick: function () {
          this.$Message.success("点击了按钮");
          this.$Message.success("开启服务");
        },
      });
    },

 Code Management/WCS/WIDESEAWCS_Client/src/views/Login.vue

@@ -95,9 +95,9 @@
    const loading = ref(false);
    const codeImgSrc = ref('');
    const userInfo = reactive({
      userName: '',
      password: '',
      verificationCode: '',
      userName: 'admin',
      password: '123456',
      verificationCode: '1234',
      UUID: undefined
    });


 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Common/TaskEnum/TaskEnumHelper.cs

@@ -22,7 +22,7 @@
            {
                return TaskTypeGroup.OutbondGroup;
            }
            else if (!int.TryParse(Enum.Parse<TaskInStatusEnum>(taskType.ToString()).ToString(), out result))
            else if (!int.TryParse(Enum.Parse<TaskInboundTypeEnum>(taskType.ToString()).ToString(), out result))
            {
                return TaskTypeGroup.InboundGroup;
            }

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Common/TaskEnum/TaskTypeEnum.cs

@@ -71,6 +71,12 @@
        /// </summary>
        [Description("空托盘出库")]
        OutTray = 104,

        /// <summary>
        /// ç©ºæ‰˜ç›˜å‡ºåº“
        /// </summary>
        [Description("空托盘出库")]
        OutNG = 105,
    }

    public enum TaskRelocationTypeEnum

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Core/Helper/HttpHelper.cs

@@ -2,6 +2,7 @@
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;

@@ -9,16 +10,22 @@
{
    public class HttpHelper
    {
        public static async Task<string> GetAsync(string serviceAddress, string contentType = "application/json", Dictionary<string, string>? headers = null)
        public static async Task<string> GetAsync(string serviceAddress, Dictionary<string, object> parameters, string contentType = "application/json", Dictionary<string, string>? headers = null)
        {
            try
            {
                string result = string.Empty;
                using HttpClient httpClient = new HttpClient();
                httpClient.Timeout = new TimeSpan(0, 0, 60);
                // å°†å‚数拼接到URL中
                string queryString = string.Join("&", parameters.Select(x => $"{x.Key}={x.Value}"));
                serviceAddress += "?" + queryString;

                foreach (var header in headers)
                    httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
                if (headers != null)
                {
                    foreach (var header in headers)
                        httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
                }

                result = await httpClient.GetAsync(serviceAddress).Result.Content.ReadAsStringAsync();
                return result;
@@ -41,9 +48,11 @@
                    using HttpClient httpClient = new HttpClient();
                    httpClient.Timeout = new TimeSpan(0, 0, 60);

                    foreach (var header in headers)
                        httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);

                    if (headers != null)
                    {
                        foreach (var header in headers)
                            httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
                    }
                    result = await httpClient.PostAsync(serviceAddress, httpContent).Result.Content.ReadAsStringAsync();
                }
                return result;

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_DTO/MOM/RequestEqptRunDto.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WIDESEAWCS_DTO.MOM
{
    public class RequestEqptRunDto : BasicDto
    {
        /// <summary>
        /// äººå‘˜å¯†ç 
        /// </summary>
        public string Password { get; set; }

        /// <summary>
        /// è®¾å¤‡æ¨¡å¼
        /// </summary>
        public string EquipmentModel { get; set; }
    }
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_DTO/WMS/RequestTaskDto.cs

@@ -1,10 +1,4 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WIDESEAWCS_DTO.WMS
namespace WIDESEAWCS_DTO.WMS
{
    public class RequestTaskDto
    {
@@ -17,5 +11,15 @@
        /// æ‰˜ç›˜å·
        /// </summary>
        public string PalletCode { get; set; }

        /// <summary>
        /// ç©ºæ‰˜ç›˜å¯å…¥å··åˆ°
        /// </summary>
        public string PositionList { get; set; }

        /// <summary>
        /// ä»»åŠ¡ç±»åž‹
        /// </summary>
        public string RequestType { get; set; } = string.Empty;
    }
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoService/ITaskService.cs

@@ -73,6 +73,23 @@
        /// <returns></returns>
        Dt_Task QueryConveyorLineTask(string deviceNo, string currentAddress);


        /// <summary>
        /// æ ¹æ®è®¾å¤‡ç¼–号、当前地址查询输送线未执行的任务
        /// </summary>
        /// <param name="deviceNo">设备编号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns></returns>
        Dt_Task QueryNextConveyorLineTask(string deviceNo, string currentAddress);

        /// <summary>
        /// æ ¹æ®æ‰˜ç›˜å·ã€å½“前地址查询输送线未执行的任务
        /// </summary>
        /// <param name="Barcode">托盘号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns></returns>
        Dt_Task QueryBarCodeConveyorLineTask(string Barcode, string currentAddress);

        /// <summary>
        /// æ ¹æ®ä»»åŠ¡å·ã€ä¸‹ä¸€åœ°å€æŸ¥è¯¢è¾“送线执行中的任务
        /// </summary>

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Model/Models/ProcessParameters/Platform.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,94 @@
using Magicodes.ExporterAndImporter.Core;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Core.DB.Models;

namespace WIDESEAWCS_Model.Models
{
    [SugarTable("Dt_Platform", "设备工艺参数")]
    public class Platform : BaseEntity
    {
        /// <summary>
        /// ä¸»é”®ID
        /// </summary>
        [ImporterHeader(Name = "主键")]
        [ExporterHeader(DisplayName = "主键")]
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true, ColumnDescription = "主键")]
        public int Id { get; set; }
        /// <summary>
        /// ç«™å°ç¼–号，唯一标识每个站台的编号
        /// </summary>
        [ImporterHeader(Name = "站台编号，唯一标识每个站台的编号")]
        [ExporterHeader(DisplayName = "站台编号，唯一标识每个站台的编号")]
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "站台编号，唯一标识每个站台的编号")]
        public string PlatCode { get; set; }

        /// <summary>
        /// ç«™å°åç§°ï¼Œç«™å°çš„名称或描述
        /// </summary>
        [ImporterHeader(Name = "站台名称")]
        [ExporterHeader(DisplayName = "站台名称")]
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "站台名称")]
        public string PlatformName { get; set; }

        /// <summary>
        /// å¯¹åº”堆垛机
        /// </summary>
        [ImporterHeader(Name = "对应堆垛机")]
        [ExporterHeader(DisplayName = "对应堆垛机")]
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "对应堆垛机")]
        public string Stacker { get; set; }

        /// <summary>
        /// æ‰§è¡Œæ–¹æ³•
        /// </summary>
        [ImporterHeader(Name = "执行方法")]
        [ExporterHeader(DisplayName = "执行方法")]
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "执行方法")]
        public string ExecutionMethod { get; set; }

        /// <summary>
        /// ç«™å°ç±»åž‹ï¼Œç«™å°çš„类型
        /// </summary>
        [ImporterHeader(Name = "站台类型")]
        [ExporterHeader(DisplayName = "站台类型")]
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "站台类型")]
        public string PlatformType { get; set; }

        /// <summary>
        /// å¯¹åº”PLC编号，与站台对应的PLC的编号
        /// </summary>
        [ImporterHeader(Name = "对应PLC编号")]
        [ExporterHeader(DisplayName = "对应PLC编号")]
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "对应PLC编号")]
        public string PLCCode { get; set; }

        /// <summary>
        /// ç«™å°ä½ç½®
        /// </summary>
        [ImporterHeader(Name = "站台位置")]
        [ExporterHeader(DisplayName = "站台位置")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "站台位置")]
        public string Location { get; set; }

        /// <summary>
        /// ç«™å°å®¹é‡
        /// </summary>
        [ImporterHeader(Name = "站台容量")]
        [ExporterHeader(DisplayName = "站台容量")]
        [SugarColumn(IsNullable = true, ColumnDescription = "站台容量")]
        public int Capacity { get; set; }

        /// <summary>
        /// ç«™å°çŠ¶æ€ï¼Œé»˜è®¤ä¸º'Active'
        /// </summary>
        [ImporterHeader(Name = "站台状态")]
        [ExporterHeader(DisplayName = "站台状态")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "站台状态")]
        public string Status { get; set; } = "Active";
    }
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_ProcessParameters/IPlatFormRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
namespace WIDESEAWCS_IProcessRepository;

public interface IPlatFormRepository : IRepository<Platform>
{
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_ProcessRepository/PlatFormRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,8 @@
namespace WIDESEAWCS_ProcessRepository;

public class PlatFormRepository : RepositoryBase<Platform>, IPlatFormRepository
{
    public PlatFormRepository(IUnitOfWorkManage unitOfWorkManage) : base(unitOfWorkManage)
    {
    }
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_QuartzJob/ConveyorLine/CommonConveyorLine.cs

@@ -224,7 +224,7 @@

            if (devicePro == null)
            {
                throw new Exception("未找到协议信息");
                throw new Exception("未找到协议信息:" + deviceChildCode);
            }
            else
            {
@@ -247,7 +247,7 @@

            if (devicePro == null)
            {
                throw new Exception("未找到协议信息");
                throw new Exception("未找到协议信息:" + deviceChildCode);
            }
            else
            {

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Server/bin/Debug/net6.0/Log_PLCReadWrite/1ºÅ¶Ñ¶â»ú/Logs_20241029105644.txt

ÎļþÒÑɾ³ý

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/TaskService.cs

@@ -22,6 +22,7 @@
using Newtonsoft.Json;
using SqlSugar;
using System.Diagnostics.CodeAnalysis;
using System.Threading.Tasks;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseServices;
@@ -131,47 +132,55 @@
            WebResponseContent content = new WebResponseContent();
            try
            {
                #region çœŸå®žæ•°æ®
                #region è¯·æ±‚入库任务巷道
                // TODO: è°ƒç”¨æŽ¥å£èŽ·å–下一个地址
                //// åˆ›å»ºè¯·æ±‚对象
                //RequestTaskDto request = new RequestTaskDto()
                //{
                //    Position = sourceAddress,
                //    PalletCode = palletCode,
                //};

                //// å‘送请求并等待响应
                //var result = HttpHelper.PostAsync("http:127.0.0.1:8098/api/Task/RequestTaskAsync", request.ToJsonString()).Result;

                //// ååºåˆ—化响应内容
                //content = JsonConvert.DeserializeObject<WebResponseContent>(result);

                //// æ£€æŸ¥çŠ¶æ€å¹¶è¿”回
                //if (!content.Status)
                //    return content;

                //// ååºåˆ—化任务数据
                //WMSTaskDTO task = JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());

                //// å¤„理任务并返回结果
                //content = ReceiveWMSTask(new List<WMSTaskDTO> { task });

                #endregion

                WMSTaskDTO taskDTO = new WMSTaskDTO()
                // åˆ›å»ºè¯·æ±‚对象
                RequestTaskDto request = new RequestTaskDto()
                {
                    TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
                    Grade = 1,
                    Position = sourceAddress,
                    PalletCode = palletCode,
                    RoadWay = "CHSC01",
                    SourceAddress = sourceAddress,
                    TargetAddress = "CHSC01",
                    TaskState = (int)TaskInStatusEnum.InNew,
                    Id = 0,
                    TaskType = (int)TaskInboundTypeEnum.Inbound
                };

                content = ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
                // å‘送请求并等待响应
                var result = HttpHelper.PostAsync("http://127.0.0.1:5000/api/Task/RequestTaskAsync", request.ToJsonString()).Result;

                // ååºåˆ—化响应内容
                content = JsonConvert.DeserializeObject<WebResponseContent>(result);

                WMSTaskDTO task = new WMSTaskDTO();
                // æ£€æŸ¥çŠ¶æ€å¹¶è¿”回
                if (!content.Status)
                {
                    task = new WMSTaskDTO()
                    {
                        TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
                        Grade = 1,
                        PalletCode = palletCode,
                        RoadWay = "CHSC01",
                        SourceAddress = sourceAddress,
                        TargetAddress = "1020",
                        TaskState = (int)TaskOutStatusEnum.Line_OutExecuting,
                        Id = 0,
                        TaskType = (int)TaskOutboundTypeEnum.Outbound
                    };

                    Dt_Task task1 = _mapper.Map<Dt_Task>(task);
                    task1.CurrentAddress = task.SourceAddress;
                    task1.NextAddress = "1020";
                    BaseDal.AddData(task1);
                    return content.OK();
                }
                else
                {
                    // ååºåˆ—化任务数据
                    task = JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());
                    // å¤„理任务并返回结果
                    content = ReceiveWMSTask(new List<WMSTaskDTO> { task });
                }



                #endregion
            }
            catch (Exception ex)
            {
@@ -189,6 +198,28 @@
        public Dt_Task QueryConveyorLineTask(string deviceNo, string currentAddress)
        {
            return BaseDal.QueryFirst(x => (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.InNew || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish) && x.CurrentAddress == currentAddress, TaskOrderBy);
        }

        /// <summary>
        /// æ ¹æ®è®¾å¤‡ç¼–号、当前地址查询输送线未执行的任务
        /// </summary>
        /// <param name="deviceNo">设备编号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns></returns>
        public Dt_Task QueryNextConveyorLineTask(string deviceNo, string currentAddress)
        {
            return BaseDal.QueryFirst(x => (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.InNew || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish) && x.NextAddress == currentAddress, TaskOrderBy);
        }

        /// <summary>
        /// æ ¹æ®æ‰˜ç›˜å·ã€å½“前地址查询输送线未执行的任务
        /// </summary>
        /// <param name="Barcode">托盘号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns></returns>
        public Dt_Task QueryBarCodeConveyorLineTask(string Barcode, string currentAddress)
        {
            return BaseDal.QueryFirst(x => (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.InNew || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish) && x.CurrentAddress == currentAddress && x.PalletCode == Barcode, TaskOrderBy);
        }

        /// <summary>
@@ -397,36 +428,33 @@

                    if (task.TaskState == (int)TaskInStatusEnum.Line_InFinish)
                    {
                        Random random = new Random();

                        #region å…¥åº“调用接口获取货位地址
                        // TODO: è°ƒç”¨æŽ¥å£èŽ·å–货位地址
                        // åˆ›å»ºè¯·æ±‚对象
                        RequestTaskDto taskDto = new RequestTaskDto()
                        {
                            Position = task.NextAddress,
                            PalletCode = task.PalletCode,
                        };

                        // å‘送请求并等待响应
                        var abc = HttpHelper.PostAsync("http://127.0.0.1:5000/api/Task/RequestLocationTaskAsync", taskDto.ToJsonString()).Result;
                        if (abc == null)
                            return content.Error();
                        // ååºåˆ—化响应内容
                        content = JsonConvert.DeserializeObject<WebResponseContent>(abc);

                        // æ£€æŸ¥çŠ¶æ€å¹¶è¿”回
                        if (!content.Status)
                            return content;

                        // ååºåˆ—化任务数据
                        WMSTaskDTO taskResult = JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());

                        task.CurrentAddress = task.NextAddress;
                        task.NextAddress = $"{random.Next(1, 1).ToString().PadLeft(3, '0')}-{random.Next(1, 1).ToString().PadLeft(3, '0')}-{random.Next(1, 1).ToString().PadLeft(3, '0')}";
                        task.NextAddress = taskResult.TargetAddress;
                        task.TargetAddress = task.NextAddress;

                        #region çœŸå®žæ•°æ®
                        // TODO: è°ƒç”¨æŽ¥å£èŽ·å–下一个地址
                        //// åˆ›å»ºè¯·æ±‚对象
                        //RequestTaskDto request = new RequestTaskDto()
                        //{
                        //    Position = task.NextAddress,
                        //    PalletCode = task.PalletCode,
                        //};

                        //// å‘送请求并等待响应
                        //var result = HttpHelper.PostAsync("http:127.0.0.1:8098/api/Task/RequestTaskAsync", request.ToJsonString()).Result;

                        //// ååºåˆ—化响应内容
                        //content = JsonConvert.DeserializeObject<WebResponseContent>(result);

                        //// æ£€æŸ¥çŠ¶æ€å¹¶è¿”回
                        //if (!content.Status)
                        //    return content;

                        //// ååºåˆ—化任务数据
                        //WMSTaskDTO taskResult = JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());

                        //task.CurrentAddress = task.NextAddress;
                        //task.NextAddress = taskResult.TargetAddress;
                        //task.TargetAddress = task.NextAddress;
                        #endregion

                    }
@@ -446,6 +474,16 @@
                BaseDal.UpdateData(task);

                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, App.User.UserId > 0 ? $"人工手动将任务状态从【{oldState}】跳转到【{task.TaskState}】" : $"系统自动流程，任务状态从【{oldState}】转到【{task.TaskState}】");

                #region  æ›´æ–°ä»»åŠ¡çŠ¶æ€
                object request = new
                {
                    TaskNum = task.TaskNum,
                    TaskState = task.TaskState
                };
                var result = HttpHelper.PostAsync("http://127.0.0.1:5000/api/Task/UpdateTaskStatus", request.ToJsonString()).Result;
                content = JsonConvert.DeserializeObject<WebResponseContent>(result);
                #endregion

                content = WebResponseContent.Instance.OK();
            }
@@ -518,13 +556,13 @@
                    BaseDal.UpdateData(task);

                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机出库完成");
                    //todo åŒæ­¥åˆ°WMS


                    //暂不考虑多个出库口
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup && task.TaskState == (int)TaskInStatusEnum.SC_InExecuting)
                {
                    //todo
                    //todo åŒæ­¥åˆ°WMS
                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskInStatusEnum>();
                    task.TaskState = nextStatus;
                    task.ModifyDate = DateTime.Now;
@@ -533,24 +571,6 @@
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机入库完成");


                    //var x = new { taskNum = taskNum };
                    //var result = HttpHelper.GetAsync("http:127.0.0.1:8098/api/Task/CompleteTaskAsync", x.ToJsonString()).Result;
                    //content = JsonConvert.DeserializeObject<WebResponseContent>(result);

                    //WMSTaskDTO taskDTO = new WMSTaskDTO()
                    //{
                    //    TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
                    //    Grade = 1,
                    //    PalletCode = task.PalletCode + "S",
                    //    RoadWay = "SC01",
                    //    SourceAddress = task.TargetAddress,
                    //    TargetAddress = "CLOutAreaA",
                    //    TaskState = (int)TaskOutStatusEnum.OutNew,
                    //    Id = 0,
                    //    TaskType = (int)TaskOutboundTypeEnum.Outbound
                    //};

                    //content = ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
                {
@@ -563,6 +583,25 @@
                {
                    throw new Exception($"任务类型错误,未找到该任务类型,任务号:【{taskNum}】,任务类型:【{task.TaskType}】");
                }


                #region WMS同步任务完成
                var keys = new Dictionary<string, object>()
                {
                    {"taskNum", taskNum}
                };
                var result = HttpHelper.GetAsync($"http://127.0.0.1:5000/api/Task/CompleteTaskAsync", keys).Result;
                content = JsonConvert.DeserializeObject<WebResponseContent>(result);
                #endregion
                #region  æ›´æ–°ä»»åŠ¡çŠ¶æ€
                object request = new
                {
                    TaskNum = task.TaskNum,
                    TaskState = task.TaskState
                };
                result = HttpHelper.PostAsync("http://127.0.0.1:5000/api/Task/UpdateTaskStatus", request.ToJsonString()).Result;
                content = JsonConvert.DeserializeObject<WebResponseContent>(result);
                #endregion
                //content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ConveyorLineJob/CommonConveyorLineJob.cs

@@ -27,6 +27,7 @@
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_IProcessRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
@@ -39,24 +40,23 @@
namespace WIDESEAWCS_Tasks
{
    [DisallowConcurrentExecution]
    public class CommonConveyorLineJob : JobBase, IJob
    public partial class CommonConveyorLineJob : JobBase, IJob
    {
        private readonly List<string> _deviceCodes1 = new List<string>() { "1063", "1061", "1060" };
        private readonly List<string> _deviceCodes2 = new List<string>() { "1067", "1069", "1068" };
        private readonly string[] HCTrayCode = { "1012", "1013" };
        private readonly ITaskService _taskService;
        public readonly ITaskService _taskService;
        private readonly ITaskRepository _taskRepository;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly IRouterService _routerService;
        private readonly IPlatFormRepository _platFormRepository;
        private readonly IMapper _mapper;

        public CommonConveyorLineJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IMapper mapper, ITaskRepository taskRepository)
        public CommonConveyorLineJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IMapper mapper, ITaskRepository taskRepository, IPlatFormRepository platFormRepository)
        {
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
            _routerService = routerService;
            _mapper = mapper;
            _taskRepository = taskRepository;
            _platFormRepository = platFormRepository;
        }

        public Task Execute(IJobExecutionContext context)
@@ -108,35 +108,49 @@
                                    }
                                }
                            }

                            Platform platform = _platFormRepository.QueryFirst(x => x.PLCCode == conveyorLine.DeviceCode && x.PlatCode == childDeviceCode && x.Status == "Active");
                            if (platform != null)
                            {
                                if (command.InteractiveSignal != 2)
                                {
                                    MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                                    if (method != null)
                                    {
                                        command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                                        int count = string.IsNullOrEmpty(platform.Location) ? 0 + 1 : platform.Location.Split(',').Count() + 1;
                                        method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                                    }
                                }
                                else
                                {
                                    if (!string.IsNullOrEmpty(platform.Location))
                                    {
                                        var strings = platform.Location.Split(',').ToList();
                                        foreach (var ite in strings)
                                        {
                                            int index = strings.FindIndex(p => p == ite);
                                            ConveyorLineTaskCommand command1 = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(ite);
                                            if (command1.InteractiveSignal != 2)
                                            {
                                                MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                                                if (method != null)
                                                {
                                                    command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                                                    int count = strings.Count - index;
                                                    method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        //});

                        //tasks.Add(task);
                        Task.WaitAll(tasks.ToArray());
                    }
                    //for (int i = 0; i < _deviceCodes1.Count; i++)
                    //{
                    //    ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(_deviceCodes1[i]);
                    //    if (command.InteractiveSignal != 2)
                    //    {
                    //        EmptyTrayReturn(conveyorLine, command, _deviceCodes1[_deviceCodes1.Count - 1], i);
                    //    }
                    //}
                    //for (int i = 0; i < _deviceCodes2.Count; i++)
                    //{
                    //    ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(_deviceCodes2[i]);
                    //    if (command.InteractiveSignal != 2)
                    //    {
                    //        EmptyTrayReturn(conveyorLine, command, _deviceCodes2[_deviceCodes1.Count - 1], i);
                    //    }
                    //}
                    foreach (var item in HCTrayCode)
                    {
                        ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(item);
                        if (command.InteractiveSignal != 2)
                        {
                            ChuanhuaOutbound(conveyorLine, command, HCTrayCode[0], 0);
                        }
                    }
                    Task.WaitAll(tasks.ToArray());
                }
            }
            catch (Exception ex)
@@ -148,6 +162,7 @@
                //WriteDebug("CommonConveyorLineJob", "test");
                //Console.Out.WriteLine(DateTime.Now);
            }

            return Task.CompletedTask;
        }

@@ -160,205 +175,28 @@
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        public void RequestInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            var taskNew = _taskService.QueryCraneConveyorLineTask(command.Barcode.ObjToInt(), childDeviceCode);
            var Taskout = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
            if (Taskout != null)
            try
            {
                // ç©ºæ‰˜ç›˜ä»»åŠ¡
                if (Taskout.TaskType == (int)TaskOutboundTypeEnum.OutTray)
                // èŽ·å–下一个任务
                var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
                //var taskOut = _taskService.QueryNextConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
                //return;
                // å¤„理出库任务
                HandleTaskOut(conveyorLine, command, childDeviceCode, ProtocalDetailValue, task);

                // å¦‚果没有出库任务，处理新任务
                if (task == null && command.Barcode != "NoRead")
                {
                    if (Taskout.TaskState == (int)TaskOutStatusEnum.SC_OutFinish)
                    {
                        ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(Taskout);
                        taskCommand.InteractiveSignal = command.InteractiveSignal;
                        if (command.Barcode == "")
                        {
                            taskCommand.TargetAddress = 1092;
                        }
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                        _taskService.UpdateTaskStatusToNext(Taskout);
                    }
                    else if (Taskout.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting)
                    {
                        if (command.Barcode == "")
                        {
                            ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(Taskout);
                            taskCommand.InteractiveSignal = command.InteractiveSignal;
                            taskCommand.TargetAddress = 1092;
                            conveyorLine.SendCommand(taskCommand, childDeviceCode);

                            ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                            _taskService.UpdateTaskStatusToNext(Taskout);
                        }
                    }
                }
                else if (Taskout.TaskType == (int)TaskOutboundTypeEnum.Outbound)
                {
                    if (Taskout.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                    {
                        ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(Taskout);
                        taskCommand.InteractiveSignal = command.InteractiveSignal;
                        if (command.Barcode == "")
                        {
                            //todo æ²¡æœ‰æ˜Žç¡®å¼‚常口，送到目标巷道的NG口
                            //taskCommand.TargetAddress = 1092;
                        }
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                        _taskService.UpdateTaskStatusToNext(Taskout);
                    }
                    else if (Taskout.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting)
                    {
                        if (command.Barcode == "")
                        {
                            ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(Taskout);
                            taskCommand.InteractiveSignal = command.InteractiveSignal;
                            // todo  é€åˆ°ç›®æ ‡å··é“çš„NG口
                            taskCommand.TargetAddress = 1092;
                            conveyorLine.SendCommand(taskCommand, childDeviceCode);

                            ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                            _taskService.UpdateTaskStatusToNext(Taskout);
                        }
                        else
                        {
                            // todo è°ƒç”¨WMS任务完成接口
                            var x = new { taskNum = Taskout.TaskNum };
                            var result = HttpHelper.GetAsync("http:127.0.0.1:8098/api/Task/CompleteTaskAsync", x.ToJsonString()).Result;
                            WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);
                            if (content.Status)
                            {
                                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                                _taskService.UpdateTaskStatusToNext(Taskout);
                            }
                        }
                    }
                    HandleNewTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
                }
            }
            if (taskNew == null)
            catch (Exception ex)
            {
                if (_taskService.RequestWMSTask(command.Barcode, childDeviceCode).Status)
                {
                    Dt_Task task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
                    if (task != null)
                    {
                        ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                        taskCommand.InteractiveSignal = command.InteractiveSignal;
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                        _taskService.UpdateTaskStatusToNext(task);
                    }
                }
                return;
            }
        }

        //
        /// <summary>
        /// ç©ºæ‰˜ç›˜å›žæµ
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="index">读取的第一个位置</param>
        public void EmptyTrayReturn(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int index)
        {
            var tasks = _taskRepository.QueryData(x => (x.TaskState == (int)TaskOutStatusEnum.OutNew || x.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting) && x.TaskType == (int)TaskOutboundTypeEnum.OutTray);
            if (tasks.Count <= index)
            {
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                {
                    TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
                    Grade = 1,
                    PalletCode = DateTime.Now.ToString("yyyyMMddHHmmss"),
                    RoadWay = "CHSC01",
                    SourceAddress = "001-001-001",
                    TargetAddress = childDeviceCode,
                    TaskState = (int)TaskOutStatusEnum.OutNew,
                    Id = 0,
                    TaskType = (int)TaskOutboundTypeEnum.OutTray
                };

                #region çœŸå®žæ•°æ®

                // TODO: è°ƒç”¨æŽ¥å£èŽ·å–下一个地址
                //RequestTaskDto request = new RequestTaskDto()
                //{
                //    Position = sourceAddress,
                //    PalletCode = palletCode,
                //};

                //// å‘送请求并等待响应
                //var result = HttpHelper.PostAsync("http:127.0.0.1:8098/api/Task/RequestTaskAsync", request.ToJsonString()).Result;

                //// ååºåˆ—化响应内容
                //WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);

                //// æ£€æŸ¥çŠ¶æ€å¹¶è¿”回
                ////if (!content.Status)
                ////    return content;

                //// ååºåˆ—化任务数据
                //WMSTaskDTO task = JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());

                #endregion

                var content = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
                if (content.Status)
                {
                    Console.WriteLine("空托盘呼叫成功");
                }
            }
        }

        /// <summary>
        /// é™ˆåŒ–出库
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="index">线体当前bool读取偏移地址</param>
        public void ChuanhuaOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int index)
        {
            var tasks = _taskRepository.QueryData(x => (x.TaskState == (int)TaskOutStatusEnum.OutNew || x.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting) && x.TaskType == (int)TaskOutboundTypeEnum.Outbound);
            if (tasks.Count <= index)
            {
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                {
                    TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
                    Grade = 1,
                    PalletCode = DateTime.Now.ToString("MMddHHmmss"),
                    RoadWay = "CHSC01",
                    SourceAddress = "001-001-001",
                    TargetAddress = childDeviceCode,
                    TaskState = (int)TaskOutStatusEnum.OutNew,
                    Id = 0,
                    TaskType = (int)TaskOutboundTypeEnum.Outbound,
                };

                var content = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
                if (content.Status)
                {
                    Console.WriteLine("出库呼叫成功");
                }
            }
            else
            {
                Dt_Task task = tasks[index];
                if (task != null)
                {
                    ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                    taskCommand.InteractiveSignal = command.InteractiveSignal;
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                }
            }
        }
        #region è¾“送线请求入库下一地址

        /// <summary>
        /// è¾“送线请求入库下一地址
@@ -366,20 +204,22 @@
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        public void RequestInNextAddress(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        {
            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null)
            {
                Dt_Task? newTask = _taskService.UpdatePosition(task.TaskNum, task.CurrentAddress);
                if (newTask != null)
                {
                    ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(newTask);
                    taskCommand.InteractiveSignal = command.InteractiveSignal;
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                }
            }
        }
        //public void RequestInNextAddress(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        //{
        //    Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
        //    if (task != null)
        //    {
        //        Dt_Task? newTask = _taskService.UpdatePosition(task.TaskNum, task.CurrentAddress);
        //        if (newTask != null)
        //        {
        //            ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(newTask);
        //            taskCommand.InteractiveSignal = command.InteractiveSignal;
        //            conveyorLine.SendCommand(taskCommand, childDeviceCode);
        //        }
        //    }
        //}

        #endregion

        /// <summary>
        /// è¾“送线入库完成
@@ -397,7 +237,8 @@

                //conveyorLine.SetValue(ConveyorLineDBName.WriteInteractiveSignal, 0, childDeviceCode);
                WebResponseContent content = _taskService.UpdateTaskStatusToNext(task);
                Console.Out.WriteLine(content.Serialize());

                //Console.Out.WriteLine(content.Serialize());
            }
        }

@@ -407,7 +248,8 @@
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        public void RequestOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        public void RequestOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            Dt_Task task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
            if (task != null)
@@ -416,6 +258,7 @@
                taskCommand.InteractiveSignal = command.InteractiveSignal;
                conveyorLine.SendCommand(taskCommand, childDeviceCode);

                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                _taskService.UpdateTaskStatusToNext(task);
            }
        }
@@ -447,18 +290,101 @@
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        public void ConveyorLineOutFinish(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        public void ConveyorLineOutFinish(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null)
            {
                conveyorLine.SetValue(ConveyorLineDBName.WriteInteractiveSignal, 0, childDeviceCode);
                WebResponseContent content = _taskService.UpdateTaskStatusToNext(task);
                Console.Out.WriteLine(content.Serialize());
                WebResponseContent content = new WebResponseContent();
                ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                taskCommand.InteractiveSignal = command.InteractiveSignal;
                if (task.PalletCode != command.Barcode)
                {
                    var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == task.TargetAddress).Capacity;
                    taskCommand.TargetAddress = NGAddress;
                }
                else
                {
                    taskCommand.TargetAddress = 0;
                }

                conveyorLine.SendCommand(taskCommand, childDeviceCode);
                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                content = _taskService.UpdateTaskStatusToNext(task);
            }
        }

        /// <summary>
        /// ç›‘测空托盘实盘出库
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="index">线体当前bool读取偏移地址</param>
        public async void EmptyTrayReturn(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int index, Platform platform)
        {
            try
            {
                TaskOutboundTypeEnum taskOutboundTypeEnum;
                if (platform.PlatformType.Contains("OutTray"))
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.OutTray;
                else
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.Outbound;
                await CheckAndCreateTask(taskOutboundTypeEnum, childDeviceCode, index, platform.Stacker.Split(',')[0], platform.Stacker.Split(',').ToList());
            }
            catch (Exception)
            {
            }
        }

        /// <summary>
        /// æ£€æŸ¥ä»»åŠ¡å¹¶åˆ›å»ºæ–°ä»»åŠ¡
        /// </summary>
        private async Task CheckAndCreateTask(TaskOutboundTypeEnum taskType, string childDeviceCode, int index, string roadWay, List<string> roadways = null)
        {
            var tasks = _taskRepository.QueryData(x => x.TaskType == (int)taskType && x.TargetAddress == childDeviceCode);
            if (tasks.Count < index)
            {
                #region è°ƒç”¨WMS获取出库任务

                WMSTaskDTO taskDTO = new WMSTaskDTO();
                object dynamic = new
                {
                    position = childDeviceCode,
                    tag = (int)taskType,
                    areaCdoe = roadWay,
                    roadways = roadways
                };
                var result = await HttpHelper.PostAsync("http://localhost:5000/api/Task/RequestTrayOutTaskAsync", dynamic.ToJsonString());

                WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);

                // æ£€æŸ¥çŠ¶æ€å¹¶è¿”回
                if (!content.Status)
                    return;

                taskDTO = JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());

                #endregion

                CreateAndSendTask(taskDTO);
            }
        }

        /// <summary>
        /// åˆ›å»ºä»»åŠ¡
        /// </summary>
        public WebResponseContent CreateAndSendTask(WMSTaskDTO taskDTO)
        {
            var content = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
            if (content.Status)
            {
                Console.WriteLine($"{taskDTO.TaskType}呼叫成功");
            }
            return content;
        }

        /// <summary>
        /// è¾“送线交互完成
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ConveyorLineJob/Task/RequestInbound.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,195 @@
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using HslCommunication;
using OfficeOpenXml.ConditionalFormatting;
using WIDESEAWCS_DTO.WMS;

namespace WIDESEAWCS_Tasks
{
    public partial class CommonConveyorLineJob
    {
        /// <summary>
        /// å¤„理出库任务
        /// </summary>
        private void HandleTaskOut(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue, Dt_Task taskOut)
        {
            // å¦‚果没有任务，直接返回
            if (taskOut == null) return;

            // æ˜ å°„任务命令
            var taskCommand = MapTaskCommand(taskOut, command);

            // æ ¹æ®ä¸åŒçš„任务类型和状态执行不同的逻辑
            bool isOutTray = taskOut.TaskType == (int)TaskOutboundTypeEnum.OutTray;
            bool isOutboundAndOutFinish = taskOut.TaskType == (int)TaskOutboundTypeEnum.Outbound && taskOut.TaskState == (int)TaskOutStatusEnum.SC_OutFinish;
            bool isOutboundAndLineOutExecuting = taskOut.TaskType == (int)TaskOutboundTypeEnum.Outbound && taskOut.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting;

            if (isOutTray || isOutboundAndOutFinish || isOutboundAndLineOutExecuting)
            {
                // å‘送命令到输送线
                conveyorLine.SendCommand(taskCommand, childDeviceCode);
                // æ ‡è®°å‘送完成
                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                // æ›´æ–°ä»»åŠ¡çŠ¶æ€
                _taskService.UpdateTaskStatusToNext(taskOut);
            }
            else if (taskOut.TaskType == (int)TaskOutboundTypeEnum.OutTray && taskOut.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting)
            {
                // å®ŒæˆWMS任务
                CompleteWmsTask(taskOut, command, conveyorLine, childDeviceCode, ProtocalDetailValue);
            }
        }

        /// <summary>
        /// å¤„理新任务
        /// </summary>
        private void HandleNewTask(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            // ç‰¹å®šæ¡ä»¶ä¸‹åˆ›å»ºå¹¶å‘送空托盘入库任务
            if ((conveyorLine.DeviceCode == "1003" && childDeviceCode == "1016") || (conveyorLine.DeviceCode == "1005" && childDeviceCode == "1048"))
            {
                // è¯·æ±‚WMS空托盘任务
                CreateAndSendEmptyTrayTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
            }
            else if ((conveyorLine.DeviceCode == "1001" && childDeviceCode == "1088") || (conveyorLine.DeviceCode == "1004" && childDeviceCode == "1339"))
            {
                // è¯·æ±‚WMS入库任务
                RequestWmsTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
            }
            else if ((conveyorLine.DeviceCode == "1001" && childDeviceCode == "1073") || (conveyorLine.DeviceCode == "1003" && childDeviceCode == "1002"))
            {
                //TODO å‘送直接去NG口任务
            }
        }

        /// <summary>
        /// æ˜ å°„任务命令
        /// </summary>
        private ConveyorLineTaskCommand MapTaskCommand(Dt_Task task, ConveyorLineTaskCommand command)
        {
            // ä½¿ç”¨mapper映射任务命令
            var comm = _mapper.Map<ConveyorLineTaskCommand>(task);
            comm.InteractiveSignal = command.InteractiveSignal;
            return comm;
        }

        /// <summary>
        /// å®ŒæˆWMS任务
        /// </summary>
        private void CompleteWmsTask(Dt_Task taskOut, ConveyorLineTaskCommand command, CommonConveyorLine conveyorLine, string childDeviceCode, int ProtocalDetailValue)
        {
            // å¦‚果没有条码信息，则设置目标地址为NG地址
            if (command.Barcode == "NoRead")
            {
                var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == taskOut.TargetAddress).Capacity;
                taskOut.TargetAddress = NGAddress.ToString();
            }

            // TODO调用WMS任务完成接口
            var keys = new Dictionary<string, object>()
                {
                    {"taskNum", taskOut.TaskNum}
                };
            var result = HttpHelper.GetAsync($"http://127.0.0.1:5000/api/Task/CompleteTaskAsync", keys).Result;
            WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);
            if (content.Status)
            {
                // æ ‡è®°å‘送完成
                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                // æ›´æ–°ä»»åŠ¡çŠ¶æ€
                _taskService.UpdateTaskStatusToNext(taskOut);
            }
        }

        /// <summary>
        /// åˆ›å»ºå¹¶å‘送空托盘任务
        /// </summary>
        public void CreateAndSendEmptyTrayTask(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            if (command.Barcode != "NoRead")
            {
                // åˆ›å»ºç©ºæ‰˜ç›˜ä»»åŠ¡DTO
                WMSTaskDTO taskDTO = CreateEmptyTrayTaskDto(command.Barcode, childDeviceCode);
                // åˆ›å»ºå¹¶å‘送任务
                WebResponseContent content = CreateAndSendTask(taskDTO);
                if (content.Status)
                {
                    // æŸ¥è¯¢ä»»åŠ¡
                    Dt_Task task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
                    if (task != null)
                    {
                        // æ˜ å°„任务命令
                        ConveyorLineTaskCommand taskCommand = MapTaskCommand(task, command);
                        // å‘送命令到输送线
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);
                        // æ ‡è®°å‘送完成
                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                        // æ›´æ–°ä»»åŠ¡çŠ¶æ€
                        _taskService.UpdateTaskStatusToNext(task);
                    }
                }
            }
        }

        /// <summary>
        /// åˆ›å»ºç©ºæ‰˜ç›˜ä»»åŠ¡DTO
        /// </summary>
        private WMSTaskDTO CreateEmptyTrayTaskDto(string barcode, string childDeviceCode)
        {
            #region å‘WMS请求空托盘任务
            WMSTaskDTO wMSTaskDTO = new WMSTaskDTO();
            RequestTaskDto request = new RequestTaskDto()
            {
                Position = childDeviceCode,
                PalletCode = barcode,
            };
            var result = HttpHelper.PostAsync("http://127.0.0.1:5000/api/Task/RequestTrayInTaskAsync", request.ToJsonString()).Result;
            if (result == null)
                return wMSTaskDTO;

            WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);
            // æ£€æŸ¥çŠ¶æ€å¹¶è¿”回
            if (!content.Status)
                return wMSTaskDTO;

            return JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());

            #endregion å‘WMS请求空托盘任务
        }

        /// <summary>
        /// è¯·æ±‚WMS任务
        /// </summary>
        private void RequestWmsTask(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            // è¯·æ±‚WMS任务
            if (_taskService.RequestWMSTask(command.Barcode, childDeviceCode).Status)
            {
                // æŸ¥è¯¢ä»»åŠ¡
                Dt_Task task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
                if (task != null)
                {
                    // æ˜ å°„任务命令
                    ConveyorLineTaskCommand taskCommand = MapTaskCommand(task, command);
                    // å‘送命令到输送线
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    // æ ‡è®°å‘送完成
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    // æ›´æ–°ä»»åŠ¡çŠ¶æ€
                    _taskService.UpdateTaskStatusToNext(task);
                }
            }
        }
    }
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/StackerCraneJob/CommonStackerCraneJob.cs

@@ -48,9 +48,7 @@
                CommonStackerCrane commonStackerCrane = (CommonStackerCrane)context.JobDetail.JobDataMap.Get("JobParams");
                if (commonStackerCrane != null)
                {
                    //EqptRun(commonStackerCrane);
                    //EqptAlive(commonStackerCrane);
                    //EqptStatus(commonStackerCrane);
                    //Console.Out.WriteLine(commonStackerCrane.DeviceName);
                    if (!commonStackerCrane.IsEventSubscribed)
                    {
@@ -157,6 +155,10 @@
                    task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);
                }
            }
            else if (task == null)
            {
                task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);
            }

            return task;
        }
@@ -177,7 +179,7 @@
                    CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
                    //if (conveyorLine.IsOccupied(router.ChildPosi))//出库站台未被占用
                    //{
                        return task;
                    return task;
                    //}
                }
                else
@@ -297,52 +299,6 @@
            return stackerCraneTaskCommand;
        }

        /// <summary>
        /// è®¾å¤‡ä¸ŽMOM系统对接，设备上线
        /// </summary>
        /// <param name="commonStackerCrane"></param>
        public async void EqptRun(CommonStackerCrane commonStackerCrane)
        {
            if (!commonStackerCrane.StackerOnline)
            {
                BasicDto dto = new BasicDto
                {
                    EmployeeNo = "T00001",
                    EquipmentCode = commonStackerCrane.DeviceCode,
                    RequestTime = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
                    SessionId = Guid.NewGuid().ToString(),
                    Software = commonStackerCrane.DeviceName,
                };
                var respone = await HttpHelper.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/EqptRun", dto.ToJsonString());
                if (respone != null)
                {
                    var result = JsonConvert.DeserializeObject<ResponseEqptRunDto>(respone);
                    if (result != null && result.Success)
                    {
                        var process = _processRepository.QueryData(x => x.EquipmentName == commonStackerCrane.DeviceName).FirstOrDefault();
                        if (process == null)
                        {
                            ResponeRunDto runDto = JsonConvert.DeserializeObject<ResponeRunDto>(respone);
                            process = new Dt_EquipmentProcess()
                            {
                                EquipmentName = commonStackerCrane.DeviceCode,
                                EquipmentType = commonStackerCrane.DeviceName.Substring(commonStackerCrane.DeviceCode.IndexOf("堆垛机")),
                                WipOrderNo = runDto.WipOrderNo,
                                ProductDesc = runDto.ProductDesc,
                                ProcessValue = JsonConvert.SerializeObject(result)
                            };
                            var isResult = await _processRepository.AddDataAsync(process) > 0;
                        }
                        else
                        {
                            process.ProcessValue = JsonConvert.SerializeObject(result);
                            var isResult = await _processRepository.UpdateDataAsync(process);
                        }
                        commonStackerCrane.StackerOnline = true;
                    }
                }
            }
        }

        /// <summary>
        /// è®¾å¤‡å¿ƒè·³
@@ -375,82 +331,5 @@
            }
        }

        /// <summary>
        /// è®¾å¤‡çŠ¶æ€
        /// </summary>
        /// <param name="commonStackerCrane"></param>
        public async void EqptStatus(CommonStackerCrane commonStackerCrane)
        {
            string code = string.Empty;
            RequestAlertDto requestAlert = new RequestAlertDto()
            {
                EmployeeNo = "T00001",
                EquipmentCode = commonStackerCrane.DeviceCode,
                RequestTime = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
                SessionId = Guid.NewGuid().ToString(),
                Software = commonStackerCrane.DeviceName,
                AlertInfo = new List<AlertInfoDto>()
            };
            switch (commonStackerCrane.Status)
            {
                case DeviceStatus.Idle:
                    code = "Waiting";
                    break;

                case DeviceStatus.Working:
                    code = "Running";
                    break;

                case DeviceStatus.Fault:
                    code = "Alerting";
                    var alert = new AlertInfoDto()
                    {
                        AlertCode = "1001",
                        AlertDescription = commonStackerCrane.StackerCraneStatusDes,
                        AlertReset = "1"
                    };
                    requestAlert.AlertInfo.Add(alert);

                    await HttpHelper.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/EqptAlive", requestAlert.ToJsonString());

                    break;

                case DeviceStatus.Unkonw:
                    code = "Down";
                    break;

                case DeviceStatus.Offline:
                    code = "Maintenance";
                    break;

                default:
                    break;
            }
            if (code != "Alerting")
            {
                requestAlert.AlertInfo = new List<AlertInfoDto>();
                var alert = new AlertInfoDto()
                {
                    AlertCode = "1001",
                    AlertDescription = commonStackerCrane.StackerCraneStatusDes,
                    AlertReset = "0"
                };
                await HttpHelper.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/EqptAlive", requestAlert.ToJsonString());
            }
            RequestEqptStatusDto requestEqptStatus = new RequestEqptStatusDto()
            {
                EmployeeNo = "T00001",
                EquipmentCode = commonStackerCrane.DeviceCode,
                RequestTime = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
                SessionId = Guid.NewGuid().ToString(),
                Software = commonStackerCrane.DeviceName,
                ChangeTime = DateTime.Now.ToString(),
                Description = commonStackerCrane.StackerCraneStatusDes,
                LocationID = "NA",
                ReasonCode = "123",
                StatusCode = code
            };
            var respone = await HttpHelper.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/EqptStatus", requestEqptStatus.ToJsonString());
        }
    }
}

 Code Management/WMS/WIDESEA_WMSClient/src/router/tables.js

@@ -216,6 +216,14 @@
    meta: {
      keepAlive: false
    }
  },
  {
    path: '/ProductionModel',
    name: 'ProductionModel',
    component: () => import('@/views/widesea_wms/MOM/ProductionModel.vue'),
    meta: {
      keepAlive: false
    }
  }
]
export default tables

 Code Management/WMS/WIDESEA_WMSClient/src/views/widesea_wms/MOM/Extend/Add.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,76 @@
<template>
    <div>
        <vol-box v-model="showDetialBox" :lazy="true" :height="350" :width="600" :padding="15" title="料框属性维护">
            <el-form :inline="true" :model="TrayBarcodePropertys" label-width="auto" class="demo-form-inline">
                <el-form-item label="料框属性:">
                    <el-input v-model="TrayBarcodePropertys.TrayBarcodeProperty" placeholder="料框属性" />
                </el-form-item>
                <el-form-item label="托盘容量:">
                    <el-input v-model="TrayBarcodePropertys.Capacity" placeholder="托盘容量" />
                </el-form-item>
                <el-button @click="addProductType" type="primary">添加产品工序</el-button>
                <el-button @click="save" type="success">提交数据</el-button>
                <el-row>
                    <el-col :span="12">
                        <el-form-item label="工序:" v-for="(input, index) in TrayBarcodePropertys.ProcessCodes"
                            :key="index">
                            <el-input v-model="input.ProcessCode" placeholder="工序" />
                        </el-form-item>
                    </el-col>
                    <el-col :span="12">
                        <el-form-item label="产品类型:" v-for="(input, index) in TrayBarcodePropertys.ProductTypes"
                            :key="index">
                            <el-input v-model="input.ProductType" placeholder="产品类型" />
                        </el-form-item>
                    </el-col>
                </el-row>
            </el-form>
        </vol-box>
    </div>
</template>

<script>
import VolBox from "@/components/basic/VolBox.vue";
import http from "@/../src/api/http.js";
export default {
    components: { VolBox },
    data() {
        return {
            showDetialBox: false,
            TrayBarcodePropertys: {
                TrayBarcodeProperty: '',
                Capacity: 0,
                ProcessCodes: [{ ProcessCode: '', }],
                ProductTypes: [{ ProductType: '', }]
            }
        }
    },
    methods: {
        addProductType() {
            this.TrayBarcodePropertys.ProductTypes.push({ ProductType: '' })
            this.TrayBarcodePropertys.ProcessCodes.push({ ProcessCode: '' })
        },
        open() {
            this.showDetialBox = true
        },
        save() {
            console.log(this.TrayBarcodePropertys)
            let data = ({...this.TrayBarcodePropertys, ProcessCodes:JSON.stringify(this.TrayBarcodePropertys.ProcessCodes) , ProductTypes:JSON.stringify(this.TrayBarcodePropertys.ProductTypes)});
            
            debugger;
            http.post('api/Production/AddData', data).then(res => {
                if (res.code == 200) {
                    // ElMessage.success(res.msg)
                    this.$message.success('添加成功')
                    this.$parent.load();
                } else {
                    // ElMessage.error(res.msg)
                    this.$message.error(x.message)
                }
            })
        }
    }
}
</script>

<style lang="scss" scoped></style>

 Code Management/WMS/WIDESEA_WMSClient/src/views/widesea_wms/MOM/ProductionModel.js

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,77 @@
/*****************************************************************************************
**  Author:jxx 2022
**  QQ:283591387
**完整文档见：http://v2.volcore.xyz/document/api ã€ä»£ç ç”Ÿæˆé¡µé¢ViewGrid】
**常用示例见：http://v2.volcore.xyz/document/vueDev
**后台操作见：http://v2.volcore.xyz/document/netCoreDev
*****************************************************************************************/
//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码
import gridBody from "./Extend/Add.vue"; //自定义扩展查询界面中表格体组件

let extension = {
  components: {
    //查询界面扩展组件
    gridHeader: '',
    gridBody: gridBody,
    gridFooter: '',
    //新建、编辑弹出框扩展组件
    modelHeader: '',
    modelBody: '',
    modelFooter: ''
  },
  tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
  buttons: { view: [], box: [], detail: [] }, //扩展的按钮
  methods: {
     //下面这些方法可以保留也可以删除
    onInit() {  //框架初始化配置前，
        //示例：在按钮的最前面添加一个按钮
          this.buttons.unshift({  //也可以用push或者splice方法来修改buttons数组
            name: '按钮', //按钮名称
            icon: 'el-icon-document', //按钮图标vue2版本见iview文档icon，vue3版本见element ui文档icon(注意不是element puls文档)
            type: 'primary', //按钮样式vue2版本见iview文档button，vue3版本见element ui文档button
            onClick: function () {
              console.log("🚀 ~ onInit ~ gridBody:", gridBody)
              this.$refs.gridBody.open();
            }
          });

        //示例：设置修改新建、编辑弹出框字段标签的长度
        this.boxOptions.labelWidth = 150;
    },
    onInited() {
      //框架初始化配置后
      //如果要配置明细表,在此方法操作
      //this.detailOptions.columns.forEach(column=>{ });
    },
    searchBefore(param) {
      //界面查询前,可以给param.wheres添加查询参数
      //返回false，则不会执行查询
      return true;
    },
    searchAfter(result) {
      //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
      return true;
    },
    addBefore(formData) {
      //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
      return true;
    },
    updateBefore(formData) {
      //编辑保存前formData为对象，包括明细表、删除行的Id
      return true;
    },
    rowClick({ row, column, event }) {
      //查询界面点击行事件
      this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
    },
    modelOpenAfter(row) {
      //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
      //(1)判断是编辑还是新建操作： this.currentAction=='Add';
      //(2)给弹出框设置默认值
      //(3)this.editFormFields.字段='xxx';
      //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
      //看不懂就把输出看：console.log(this.editFormOptions)
    }
  }
};
export default extension;

 Code Management/WMS/WIDESEA_WMSClient/src/views/widesea_wms/MOM/ProductionModel.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,68 @@
<!--
*Author：jxx
 *Contact：283591387@qq.com
 *代码由框架生成,任何更改都可能导致被代码生成器覆盖
 *业务请在@/extension/widesea_wms/material/Dt_MaterielInfo.js此处编写
 -->
 <template>
    <view-grid ref="grid" :columns="columns" :detail="detail" :editFormFields="editFormFields"
        :editFormOptions="editFormOptions" :searchFormFields="searchFormFields" :searchFormOptions="searchFormOptions"
        :table="table" :extend="extend">
    </view-grid>
</template>
<script>
import extend from "./ProductionModel.js";
import { ref, defineComponent } from "vue";
export default defineComponent({
    setup() {
        const table = ref({
            key: 'materielID',
            footer: "Foots",
            cnName: '料框属性',
            name: 'ProductionModel',
            url: "/Production/",
            sortName: "MaterielID"
        });
        const editFormFields = ref({
            "TrayBarcodeProperty": "",
            "Capacity": "",

        });
        const editFormOptions = ref([
            [
                { "title": "料框属性", "field": "TrayBarcodeProperty", type: "text" },
                { "title": "托盘容量", "field": "Capacity", type: "text" },
            ]
        ]);
        const searchFormFields = ref({});
        const searchFormOptions = ref([
            [
                { "title": "料框属性", "field": "TrayBarcodeProperty", type: "text" },
                { "title": "托盘容量", "field": "Capacity", type: "text" },
            ]
        ]);
        const columns = ref([{ field: 'id', title: 'ID', type: 'int', width: 110, hidden: true, readonly: true, require: true, align: 'left' },
        { field: 'trayBarcodeProperty', title: '料框属性', type: 'string', width: 110, align: 'left', sort: true },
        { field: 'processCodes', title: '工序集合', type: 'string', width: 120, align: 'left' },
        { field: 'productTypes', title: '物料编码/工艺型号集合', type: 'string', width: 110, align: 'left' },
        { field: 'capacity', title: '托盘容量', type: 'string', width: 110, align: 'left' }]);
        const detail = ref({
            cnName: "#detailCnName",
            table: "#detailTable",
            columns: [],
            sortName: "",
            key: ""
        });
        return {
            table,
            extend,
            editFormFields,
            editFormOptions,
            searchFormFields,
            searchFormOptions,
            columns,
            detail,
        };
    },
});
</script>

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseRepository/UnitOfWorks/IUnitOfWorkManage.cs

@@ -21,5 +21,6 @@
        void CommitTran(MethodInfo method);
        void RollbackTran();
        void RollbackTran(MethodInfo method);
        Task UseTranAsync(Func<Task> action);
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseRepository/UnitOfWorks/UnitOfWorkManage.cs

@@ -190,5 +190,26 @@
                }
            }
        }

        public async Task UseTranAsync(Func<Task> action)
        {
            // å¼€å§‹äº‹åŠ¡
            _sqlSugarClient.Ado.BeginTran();

            try
            {
                // æ‰§è¡Œä¼ å…¥çš„操作
                await action();

                // æäº¤äº‹åŠ¡
                await _sqlSugarClient.Ado.CommitTranAsync();
            }
            catch (Exception ex)
            {
                // å›žæ»šäº‹åŠ¡
                await _sqlSugarClient.Ado.RollbackTranAsync();
                throw new Exception (ex.Message); // é‡æ–°æŠ›å‡ºå¼‚常，以便调用方可以处理
            }
        }
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Core/DB/Models/BaseEntity.cs

@@ -50,7 +50,7 @@
        [ImporterHeader(Name = "创建者")]
        [ExporterHeader(DisplayName = "创建者")]
        [SugarColumn(IsNullable = false, IsOnlyIgnoreUpdate = true, ColumnDescription = "创建者")]
        public string Creater { get; set; }
        public string Creater { get; set; } = "Systeam";

        /// <summary>
        /// åˆ›å»ºæ—¶é—´

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Core/HostedService/SeedDataHostedService.cs

@@ -49,7 +49,7 @@
                {
                    // ä½¿ç”¨ myScopedService æ‰§è¡Œä»»åŠ¡

                    //await DBSeed.SeedAsync(_dbContext, _webRootPath);
                    await DBSeed.SeedAsync(_dbContext, _webRootPath);

                    //多租户 åŒæ­¥
                    //await DBSeed.TenantSeedAsync(_dbContext);

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/Basic/RequestTaskDto.cs

@@ -11,4 +11,22 @@
    /// æ‰˜ç›˜å·
    /// </summary>
    public string PalletCode { get; set; }

    /// <summary>
    /// ç©ºæ‰˜ç›˜å¯å…¥å··åˆ°
    /// </summary>
    public string PositionList { get; set; }

    /// <summary>
    /// ä»»åŠ¡ç±»åž‹
    /// </summary>
    public string RequestType { get; set; } = string.Empty;
}

public class RequestOutTaskDto
{
    public string   Position { get; set; }
    public int Tag { get; set; }
    public string AreaCdoe { get; set; }
    public List<string> Roadways { get; set; }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/Basic/UpdateStatusDto.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WIDESEA_DTO
{
    public class UpdateStatusDto
    {
        /// <summary>
        /// ä»»åŠ¡å·
        /// </summary>
        public int TaskNum { get; set; }

        /// <summary>
        /// ä»»åŠ¡çŠ¶æ€
        /// </summary>
        public int TaskState { get; set; }
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MOM/CellState/CellStateDto.cs

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MOM/CellState/ResultTrayCellsStatus.cs

ÎļþÃû´Ó Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MOM/ResultTrayCellsStatus.cs ÐÞ¸Ä
@@ -1,5 +1,8 @@
namespace WIDESEA_DTO.MOM
{
    /// <summary>
    /// æ‰˜ç›˜ç”µèŠ¯çŠ¶æ€
    /// </summary>
    public class ResultTrayCellsStatus : BasicResult
    {
        /// <summary>
@@ -16,6 +19,16 @@
        /// ç»‘定代码
        /// </summary>
        public string BindCode { get; set; }

        /// <summary>
        /// ç”Ÿäº§äº§çº¿
        /// </summary>
        public string ProductionLine { get; set; }

        /// <summary>
        /// å½“前工艺工序代码
        /// </summary>
        public string ProcessCode { get; set; }

        /// <summary>
        /// æ–™æ¡†å±žæ€§åˆ—表
@@ -38,6 +51,8 @@
        /// </summary>
        public int PositionNo { get; set; }

        //public string BindCode { get; set; }

        /// <summary>
        /// ç”µèŠ¯çŠ¶æ€
        /// </summary>
@@ -57,9 +72,30 @@
        /// <summary>
        /// å·¥åº
        /// </summary>
        public string ProcessCode { get; set; }
        public List<ProcessCodes> ProcessCodes { get; set; } = new List<ProcessCodes>();

        /// <summary>
        /// æ‰˜ç›˜å®¹é‡
        /// </summary>
        public double Capacity { get; set; }

        /// <summary>
        /// é€‚用物料编码/工艺型号
        /// </summary>
        public List<ProductTypes> ProductType { get; set; } = new List<ProductTypes>();
    }

    public class ProcessCodes
    {
        /// <summary>
        /// å·¥åº
        /// </summary>
        public string ProcessCode { get; set; }
    }

    public class ProductTypes
    {
        /// <summary>
        /// é€‚用物料编码/工艺型号
        /// </summary>
        public string ProductType { get; set; }

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MOM/CellState/TrayCellUnbindDto.cs

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MOM/CellState/TrayCellsStatusDto.cs

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MOM/CellState/TrayUnbindDto.cs

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MOM/Dt_EquipmentProcess.cs

@@ -2,6 +2,7 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
@@ -59,4 +60,105 @@
        [SugarColumn(IsNullable = false, Length = int.MaxValue, ColumnDescription = "工艺参数值")]
        public string ProcessValue { get; set; }
    }

    /// <summary>
    /// è¡¨ç¤ºå·¥è‰ºè·¯çº¿ä¸Šè®¾å¤‡å‚数信息的模型。
    /// </summary>
    public class EBParameterInfo
    {
        /// <summary>
        /// å‚数编码。
        /// </summary>
        [Required(ErrorMessage = "参数编码是必填项。")]
        [StringLength(50, ErrorMessage = "参数编码长度不能超过50个字符。")]
        public string ParameterCode { get; set; }

        /// <summary>
        /// å‚数类型。
        /// </summary>
        [Required(ErrorMessage = "参数类型是必填项。")]
        [StringLength(50, ErrorMessage = "参数类型长度不能超过50个字符。")]
        public string ParameterType { get; set; }

        /// <summary>
        /// æŽ¨èå€¼ã€‚
        /// </summary>
        [StringLength(50, ErrorMessage = "推荐值长度不能超过50个字符。")]
        public string TargetValue { get; set; }

        /// <summary>
        /// å•ä½ã€‚
        /// </summary>
        public string UOMCode { get; set; }

        /// <summary>
        /// æŽ§åˆ¶ä¸Šé™å€¼ã€‚
        /// </summary>
        [StringLength(50, ErrorMessage = "控制上限值长度不能超过50个字符。")]
        public string UpperControlLimit { get; set; }

        /// <summary>
        /// æŽ§åˆ¶ä¸‹é™å€¼ã€‚
        /// </summary>
        [StringLength(50, ErrorMessage = "控制下限值长度不能超过50个字符。")]
        public string LowerControlLimit { get; set; }

        /// <summary>
        /// è§„格上限值。
        /// </summary>
        [StringLength(50, ErrorMessage = "规格上限值长度不能超过50个字符。")]
        public string UpperSpecificationsLimit { get; set; }

        /// <summary>
        /// è§„格下限值。
        /// </summary>
        [StringLength(50, ErrorMessage = "规格下限值长度不能超过50个字符。")]
        public string LowerSpecificationsLimit { get; set; }

        /// <summary>
        /// å‚数描述。
        /// </summary>
        public string Description { get; set; }

        /// <summary>
        /// å·¥è‰ºè·¯çº¿ä¸Šå½“前设备参数信息是否可用。
        /// TRUE è¡¨ç¤ºå¯ç”¨ï¼ŒFALSE è¡¨ç¤ºä¸å¯ç”¨ã€‚
        /// </summary>
        [Required(ErrorMessage = "设备参数信息是否可用是必填项。")]
        public string EquipmentAvailabilityFlag { get; set; }
    }


    public class ResponseEqptRunDto : BasicResult
    {
        /// <summary>
        /// äº§å“åç§°
        /// </summary>
        public string ProductDesc { get; set; }

        /// <summary>
        /// é¦–件数量
        /// </summary>
        public string FirstArticleNum { get; set; }

        /// <summary>
        /// è°ƒæœºæ•°é‡
        /// </summary>
        public string DebugNum { get; set; }

        /// <summary>
        /// å‚数版本信息
        /// </summary>
        public string ParamVersion { get; set; }

        /// <summary>
        /// æ˜¯å¦éœ€è¦è¯»å–参数
        /// </summary>
        public bool ParamRefreshFlag { get; set; }

        /// <summary>
        /// å‚数信息
        /// </summary>
        public List<EBParameterInfo> ParameterInfo { get; set; }
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MOM/ResponeAgingInputDto.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WIDESEA_DTO.MOM
{
    /// <summary>
    /// å…¥åº“
    /// </summary>
    public class ResponeAgingInputDto : BasicResult
    {
        /// <summary>
        /// æ–™æ¡†å±žæ€§ï¼Œç”¨äºŽæ ‡è¯†æ–™æ¡†çš„唯一属性。
        /// </summary>
        public string TrayBarcodeProperty { get; set; }

        /// <summary>
        /// å·¥å•ç¼–码或产品型号，用于关联具体的生产任务。
        /// </summary>
        public string BindCode { get; set; }

        /// <summary>
        /// ç”Ÿäº§äº§çº¿
        /// </summary>
        public string ProductionLine { get; set; }

        /// <summary>
        /// å…³è”工序返回时间，记录注液或静置时长。
        /// </summary>
        public string LinedProcessFeedbackTime { get; set; }

        /// <summary>
        /// ç‰¹å¾å‚数返回(静置时长)
        /// </summary>
        public string SpecialParameterDuration { get; set; }

        /// <summary>
        /// å•ä½
        /// </summary>
        public string UomCode { get; set; }
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_IStoragIntegrationServices/MOM/AgingInOrOutInput/IAgingInOrOutInputService.cs

@@ -10,12 +10,12 @@
    /// </summary>
    /// <param name="input">入库数据</param>
    /// <returns></returns>
    Task<dynamic> GetOCVInputAsync(AgingInputDto input);
    Task<WebResponseContent> GetOCVInputAsync(AgingInputDto input);

    /// <summary>
    /// é™ç½®\陈化出库（整托盘）
    /// </summary>
    /// <param name="input">出库数据</param>
    /// <returns></returns>
    Task<dynamic> GetOCVOutputAsync(AgingOutputDto input);
    Task<WebResponseContent> GetOCVOutputAsync(AgingOutputDto input);
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_IStorageTaskService/Task/IDt_TaskService.cs

@@ -124,7 +124,7 @@
    Task<WebResponseContent> CompleteAsync(int taskNum);

    /// <summary>
    /// è¯·æ±‚任务
    /// è¯·æ±‚任务巷道
    /// </summary>
    /// <param name="position"></param>
    /// <param name="areaCode"></param>
@@ -134,9 +134,35 @@
    Task<WebResponseContent> RequestTaskAsync(RequestTaskDto input);

    /// <summary>
    /// è¯·æ±‚任务货位
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    Task<WebResponseContent> UpdateExistingTask(RequestTaskDto input);

    /// <summary>
    /// è¯·æ±‚空托盘任务
    /// </summary>
    /// <param name="position"></param>
    /// <param name="input"></param>
    /// <returns></returns>
    Task<WebResponseContent> RequestTrayTaskAsync(string position);
    Task<WebResponseContent> RequestTrayInTaskAsync(RequestTaskDto input);

    /// <summary>
    /// è¯·æ±‚托盘任务
    /// </summary>
    /// <param name="position">目标位置</param>
    /// <param name="tag">托盘类型（1：实盘，2：空盘）</param>
    /// <param name="areaCode">区域编码</param>
    /// <param name="roadways">巷道列表</param>
    /// <returns>返回结果集</returns>
    Task<WebResponseContent> RequestTrayOutTaskAsync(string position, int tag, string areaCode, List<string> roadways);


    /// <summary>
    /// ä»»åŠ¡çŠ¶æ€ä¿®æ”¹
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    Task<WebResponseContent> UpdateTaskStatus(int taskNum, int taskState);

}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/BasicModel/DtBoxingInfoDetail.cs

@@ -20,7 +20,7 @@
    public int BoxingInfoId { get; set; }

    /// <summary>
    /// ç‰©æ–™ç¼–码
    /// ç‰©æ–™ç¼–码 ç»‘定代码
    /// </summary>
    [Required]
    [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "物料编号")]
@@ -34,7 +34,7 @@
    public string MaterielName { get; set; }

    /// <summary>
    /// å•æ®ç¼–号
    /// å•æ®ç¼–号 / é€šé“
    /// </summary>
    [Required]
    [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "单据编号")]
@@ -48,7 +48,7 @@
    public string BatchNo { get; set; }

    /// <summary>
    /// åºåˆ—号
    /// åºåˆ—号(电芯)
    /// </summary>
    [Required]
    [SugarColumn(IsNullable = false, Length = 100, ColumnDescription = "序列号")]
@@ -68,14 +68,14 @@
    public decimal OutboundQuantity { get; set; }

    /// <summary>
    /// ç»„盘状态
    /// ç»„盘状态 ç”µèŠ¯çŠ¶æ€
    /// </summary>
    [Required]
    [SugarColumn(IsNullable = false, ColumnDescription = "组盘状态")]
    public int Status { get; set; }

    /// <summary>
    /// å¤‡æ³¨
    /// å¤‡æ³¨ // æ–™æ¡†å±žæ€§Json
    /// </summary>
    [SugarColumn(IsNullable = true, ColumnDescription = "备注")]
    public string Remark { get; set; }

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/BasicModel/DtStockInfo.cs

@@ -36,10 +36,26 @@
        public bool IsFull { get; set; }

        /// <summary>
        /// å¤‡æ³¨
        /// å¤‡æ³¨ (静制\陈化时间)
        /// </summary>
        [SugarColumn(IsNullable = true, ColumnDescription = "备注")]
        public string Remark { get; set; }

        /// <summary>
        /// å…³è”工序返回时间（注液\静置时长）
        /// </summary>
        public string LinedProcessFeedbackTime { get; set; }

        /// <summary>
        /// ç‰¹å¾å‚数返回(静置时长)
        /// </summary>
        public string SpecialParameterDuration { get; set; }

        /// <summary>
        /// åŒºåŸŸç¼–码
        /// </summary>
        [SugarColumn(IsNullable = true, ColumnDescription = "区域编码")]
        public string AreaCode { get; set; }

        /// <summary>
        /// åº“存明细
@@ -52,7 +68,7 @@
        /// è´§ä½æ•°æ®
        /// </summary>
        [SugarColumn(ColumnName = "LocationInfo")]
        [Navigate(NavigateType.OneToOne,nameof(LocationCode), nameof(DtLocationInfo.LocationCode))]
        [Navigate(NavigateType.OneToOne, nameof(LocationCode), nameof(DtLocationInfo.LocationCode))]
        public DtLocationInfo? LocationInfo { get; set; }
    }
}
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/MOM/ProductionModel.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,79 @@
using Newtonsoft.Json;
using SqlSugar;
using WIDESEA_Core.DB.Models;

namespace WIDESEA_Model.Models
{
    /// <summary>
    /// è¡¨ç¤ºç”Ÿäº§è¿‡ç¨‹ä¸­çš„料框属性和相关工序信息的模型。
    /// </summary>
    [SugarTable("ProductionModel", "料框属性")]
    public class ProductionModel : BaseEntity
    {
        /// <summary>
        /// å¤‡  æ³¨:主键，自动增长
        /// </summary>
        [SugarColumn(ColumnName = "Id", IsPrimaryKey = true, IsIdentity = true, ColumnDescription = "主键，自动增长")]
        public int Id { get; set; }

        /// <summary>
        /// æ–™æ¡†å±žæ€§ï¼Œç”¨äºŽæ ‡è¯†æ–™æ¡†çš„唯一属性。
        /// </summary>
        [SugarColumn(ColumnName = "TrayBarcodeProperty", ColumnDescription = "料框属性", IsNullable = false)]
        public string TrayBarcodeProperty { get; set; }

        /// <summary>
        /// å·¥åºé›†åˆï¼ŒåŒ…含所有相关的工序代码。
        /// </summary>
        [SugarColumn(ColumnName = "ProcessCodes", ColumnDescription = "工序集合", IsNullable = false, Length = int.MaxValue)]
        public string ProcessCodes { get; set; }

        /// <summary>
        /// é€‚用物料编码/工艺型号集合，包含所有相关的物料编码或工艺型号。
        /// </summary>
        [SugarColumn(ColumnName = "ProductTypes", ColumnDescription = "适用物料编码", IsNullable = false, Length = int.MaxValue)]
        public string ProductTypes { get; set; }

        /// <summary>
        /// æ‰˜ç›˜å®¹é‡ï¼Œè¡¨ç¤ºæ–™æ¡†å¯ä»¥æ‰¿è½½çš„最大物品数量。
        /// </summary>
        [SugarColumn(ColumnName = "Capacity", ColumnDescription = "托盘容量", IsNullable = false)]
        public int Capacity { get; set; }

        /// <summary>
        /// èŽ·å–或设置工序集合，反序列化JSON字符串为List<ProcessCodes>。
        /// </summary>
        [SugarColumn(IsIgnore = true)]
        public List<ProcessCodesDTO> GetProcessCodes
        {
            get { return JsonConvert.DeserializeObject<List<ProcessCodesDTO>>(ProcessCodes); }
            set { ProcessCodes = JsonConvert.SerializeObject(value); }
        }

        /// <summary>
        /// èŽ·å–或设置适用物料编码/工艺型号集合，反序列化JSON字符串为List<string>。
        /// </summary>
        [SugarColumn(IsIgnore = true)]
        public List<ProductTypesDTO> GetProductTypes
        {
            get { return JsonConvert.DeserializeObject<List<ProductTypesDTO>>(ProductTypes); }
            set { ProductTypes = JsonConvert.SerializeObject(value); }
        }
    }

    public class ProcessCodesDTO
    {
        /// <summary>
        /// å·¥åº
        /// </summary>
        public string ProcessCode { get; set; }
    }

    public class ProductTypesDTO
    {
        /// <summary>
        /// é€‚用物料编码/工艺型号
        /// </summary>
        public string ProductType { get; set; }
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StoragIntegrationServices/MOM/AgingInOrOutInput/AgingInOrOutInputService.cs

@@ -1,7 +1,9 @@
using LogLibrary.Log;
using Masuit.Tools;
using WIDESEA_Common;
using WIDESEA_Core;
using WIDESEA_DTO;
using WIDESEA_DTO.MOM;
using WIDESEA_IStoragIntegrationServices;

namespace WIDESEA_StoragIntegrationServices;
@@ -15,21 +17,17 @@
    /// </summary>
    /// <param name="input">入库数据</param>
    /// <returns></returns>
    public async Task<dynamic> GetOCVInputAsync(AgingInputDto input)
    public async Task<WebResponseContent> GetOCVInputAsync(AgingInputDto input)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "陈化机";
            input.EquipmentCode = "P1K10040";
            input.EmployeeNo = "T00001";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/AgingInput", inputJson);
            if (x != null)
            {

            }
            content.OK(data: x);

            LogFactory.GetLog("静置陈化入库（整托盘）").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("静置陈化入库（整托盘）").Info(true, x);
@@ -40,7 +38,7 @@
            LogFactory.GetLog("静置陈化入库（整托盘）").Error(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("静置陈化入库（整托盘）").Error(true, err.StackTrace);
        }
        return Task.FromResult<dynamic>(null);
        return content;
    }

    /// <summary>
@@ -48,17 +46,17 @@
    /// </summary>
    /// <param name="input">出库数据</param>
    /// <returns></returns>
    public async Task<dynamic> GetOCVOutputAsync(AgingOutputDto input)
    public async Task<WebResponseContent> GetOCVOutputAsync(AgingOutputDto input)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "陈化机";
            input.EquipmentCode = "P1K10040";
            input.EmployeeNo = "T00001";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ"); ;
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ"); 
            var inputJson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/AgingOutput", inputJson);
            content.OK(data: x);
            LogFactory.GetLog("静置陈化出库（整托盘）").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("静置陈化出库（整托盘）").Info(true, x);
        }
@@ -67,7 +65,8 @@
            Console.WriteLine(err.Message.ToString());
            LogFactory.GetLog("静置/陈化出库（整托盘）").Error(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("静置/陈化出库（整托盘)").Error(true, err.StackTrace);
            content.Error(err.Message);
        }
        return Task.FromResult<dynamic>(null);
        return content;
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StoragIntegrationServices/MOM/CellState/CellStateService.cs

@@ -1,13 +1,10 @@
using LogLibrary.Log;
using Masuit.Tools;
using Newtonsoft.Json;
using WIDESEA_Common;
using WIDESEA_Core;
using WIDESEA_DTO;
using WIDESEA_DTO.MOM;
using WIDESEA_IStorageBasicService;
using WIDESEA_IStoragIntegrationServices;
using WIDESEA_Model.Models;

namespace WIDESEA_StoragIntegrationServices;

@@ -33,40 +30,42 @@
        try
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "陈化机";
            input.EquipmentCode = "P1K10040";
            input.EmployeeNo = "T00001";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/CellState", inputJson);
            if (x != null)
            {
                ResultCellState result = JsonConvert.DeserializeObject<ResultCellState>(x);
                DtBoxingInfo boxingInfo = new DtBoxingInfo()
                {
                    IsFull = true,
                    PalletCode = "",
                };
                var details = new List<DtBoxingInfoDetail>();
                foreach (var item in result.SerialNos)
                {
                    DtBoxingInfoDetail detail = new DtBoxingInfoDetail()
                    {
                        SerialNumber = item.SerialNo,
                        OrderNo = item.BindCode,
                        Status = item.SerialNoStatus,
                    };
                    details.Add(detail);
                }
                boxingInfo.BoxingInfoDetails = details;
                var abc = await _boxingInfoService.AddBoxingInfoAsync(boxingInfo);
                if (abc.Status)
                    return content.OK("组盘成功");
                else
                    return content.Error("组盘失败");
            }
            #region
            //if (x != null)
            //{
            //    ResultCellState result = JsonConvert.DeserializeObject<ResultCellState>(x);
            //    DtBoxingInfo boxingInfo = new DtBoxingInfo()
            //    {
            //        IsFull = true,
            //        PalletCode = "",
            //    };
            //    var details = new List<DtBoxingInfoDetail>();
            //    foreach (var item in result.SerialNos)
            //    {
            //        DtBoxingInfoDetail detail = new DtBoxingInfoDetail()
            //        {
            //            SerialNumber = item.SerialNo,
            //            OrderNo = item.BindCode,
            //            Status = item.SerialNoStatus,
            //        };
            //        details.Add(detail);
            //    }
            //    boxingInfo.BoxingInfoDetails = details;
            //    var abc = await _boxingInfoService.AddBoxingInfoAsync(boxingInfo);
            //    if (abc.Status)
            //        return content.OK("组盘成功");
            //    else
            //        return content.Error("组盘失败");
            //}
            #endregion

            LogFactory.GetLog("单电芯属性获取").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("单电芯属性获取").Info(true, x);
            return x;
        }
        catch (Exception err)
        {
@@ -88,39 +87,36 @@
        try
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "陈化机";
            input.EquipmentCode = "P1K10040";
            input.EmployeeNo = "T00001";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/TrayCellsStatus", inputJson);
            if (x != null)
            {
                ResultTrayCellsStatus result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(x);
                DtBoxingInfo boxingInfo = new DtBoxingInfo()
                {
                    IsFull = true,
                    PalletCode = result.TrayBarcode,
                };
                var details = new List<DtBoxingInfoDetail>();
                foreach (var item in result.SerialNos)
                {
                    DtBoxingInfoDetail detail = new DtBoxingInfoDetail()
                    {
                        SerialNumber = item.SerialNo,
                        OrderNo = item.PositionNo.ToString(),
                        Status = item.SerialNoStatus,
                        Remark = result.TrayBarcodePropertys.ToJsonString(),
                        MaterielCode = result.BindCode,
                    };
                    details.Add(detail);
                }
                boxingInfo.BoxingInfoDetails = details;
                var abc = await _boxingInfoService.AddBoxingInfoAsync(boxingInfo);
                if (abc.Status)
                    content.OK("组盘成功", result);
                else
                    content.Error("组盘失败");
                // ååºåˆ—化ResultTrayCellsStatus对象
                //ResultTrayCellsStatus result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(x);

                //// åˆ›å»ºDtBoxingInfo对象
                //DtBoxingInfo boxingInfo = new DtBoxingInfo
                //{
                //    IsFull = true,
                //    PalletCode = result.TrayBarcode,
                //};

                //// ä½¿ç”¨LINQ创建DtBoxingInfoDetail对象列表
                //var details = result.SerialNos.Select(item => new DtBoxingInfoDetail
                //{
                //    SerialNumber = item.SerialNo,
                //    OrderNo = item.PositionNo.ToString(),
                //    Status = item.SerialNoStatus,
                //    Remark = result.TrayBarcodePropertys.ToJsonString(),
                //    MaterielCode = result.BindCode,
                //}).ToList();

                //// èµ‹å€¼DtBoxingInfoDetails
                //boxingInfo.BoxingInfoDetails = details;
                //var abc = await _boxingInfoService.AddBoxingInfoAsync(boxingInfo);
                    content.OK("组盘成功", x);
            }
            LogFactory.GetLog("整盘电芯属性获取").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("整盘电芯属性获取").Info(true, x);

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StoragIntegrationServices/MOM/ProcessApply/ProcessApplyService.cs

@@ -24,16 +24,14 @@
        try
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "陈化机";
            input.EquipmentCode = "P1K10040";
            input.EmployeeNo = "T00001";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputIson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/ProcessApply", inputIson);
            if (x != null)
            {
                var ResultProcess = JsonConvert.DeserializeObject<ResultProcessApply>(x);
                content.OK(data: ResultProcess);
                //var ResultProcess = JsonConvert.DeserializeObject<ResultProcessApply>(x);
                content.OK(data: x);
            }
            LogFactory.GetLog("工艺路线申请").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("工艺路线申请").Info(true, x);

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StoragIntegrationServices/MOM/Unbind/UnbindService.cs

@@ -26,12 +26,11 @@
        try
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "陈化机";
            input.EquipmentCode = "P1K10040";
            input.Software = "WMS";
            input.EquipmentCode = "ECH001-B";
            input.EmployeeNo = "T00001";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            Console.WriteLine();
            LogFactory.GetLog("托盘单电芯解绑1").Info(true, JsonConvert.SerializeObject(inputJson));
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/TrayCellUnbind", inputJson);
            LogFactory.GetLog("托盘单电芯解绑").Info(true, $"\r\r--------------------------------------");
@@ -56,8 +55,8 @@
        try
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "陈化机";
            input.EquipmentCode = "P1K10040";
            input.Software = "WMS";
            input.EquipmentCode = "ECH001-B";
            input.EmployeeNo = "T00001";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageBasicRepository/Production/IProductionRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WIDESEA_StorageBasicRepository
{
    public interface IProductionRepository : IRepository<ProductionModel>
    {
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageBasicRepository/Production/ProductionRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WIDESEA_StorageBasicRepository
{
    public class ProductionRepository : RepositoryBase<ProductionModel>, IProductionRepository
    {
        public ProductionRepository(IUnitOfWorkManage unitOfWorkManage) : base(unitOfWorkManage)
        {
        }
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageBasicServices/Production/IProductionService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
namespace WIDESEA_StorageBasicServices;

public interface IProductionService : IService<ProductionModel>
{
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageBasicServices/Production/ProductionService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,10 @@
using WIDESEA_StorageBasicRepository;

namespace WIDESEA_StorageBasicServices;

public class ProductionService : ServiceBase<ProductionModel, IProductionRepository>, IProductionService
{
    public ProductionService(IProductionRepository BaseDal) : base(BaseDal)
    {
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageTaskServices/Task/Dt_TaskService.cs

@@ -1,8 +1,14 @@
using Mapster;
using log4net.Core;
using Mapster;
using Masuit.Tools;
using WIDESEA_DTO.MOM;
using WIDESEA_DTO.WMS;
using WIDESEA_IStorageBasicRepository;
using WIDESEA_IStoragIntegrationServices;
using WIDESEA_Model.Models;
using WIDESEA_StorageBasicRepository;
using WIDESEA_StorageTaskRepository;
using WIDESEA_StoragIntegrationServices;

namespace WIDESEA_StorageOutTaskServices;

@@ -12,6 +18,7 @@
    private readonly IUnitOfWorkManage _unitOfWorkManage;
    private readonly IDt_OutOrderRepository _outOrderRepository;
    private readonly IStockInfoRepository _stockInfoRepository;
    private readonly IStockInfoDetailRepository _stockInfoDetailRepository;
    private readonly IDt_Task_HtyRepository _task_HtyRepository;
    private readonly IDt_OutOrderAndStockRepository _outOrderAndStockRepository;
    private readonly IDt_OutOrderAndStock_HtyRepository _outOrderAndStock_HtyRepository;
@@ -22,10 +29,12 @@
    private readonly IPointStackerRelationRepository _pointStackerRelationRepository;
    private readonly ITaskExecuteDetailRepository _taskExecuteDetailRepository;
    private readonly ILocationStatusChangeRecordRepository _locationStatusChangeRecordRepository;
    private readonly IBoxingInfoRepository _boxingInfoRepository;
    private readonly ICellStateService _cellStateService;
    private readonly IProcessApplyService _processApplyService;
    private readonly IDt_AreaInfoRepository _areaInfoRepository;
    private readonly IBoxingInfoRepository _boxingInfoRepository; //组盘
    private readonly ICellStateService _cellStateService; //电芯属性
    private readonly IProcessApplyService _processApplyService; //工艺路线
    private readonly IDt_AreaInfoRepository _areaInfoRepository; //区域
    private readonly IAgingInOrOutInputService _agingInOrOutInputService; //静置\陈化
    private readonly IProductionRepository _productionRepository; //生产

    public Dt_TaskService(IDt_TaskRepository BaseDal,
                                IUnitOfWorkManage unitOfWorkManage,
@@ -44,7 +53,10 @@
                                IBoxingInfoRepository boxingInfoRepository,
                                ICellStateService cellStateService,
                                IProcessApplyService processApplyService,
                                IDt_AreaInfoRepository areaInfoRepository) : base(BaseDal)
                                IDt_AreaInfoRepository areaInfoRepository,
                                IAgingInOrOutInputService agingInOrOutInputService,
                                IStockInfoDetailRepository stockInfoDetailRepository,
                                IProductionRepository productionRepository) : base(BaseDal)
    {
        _unitOfWorkManage = unitOfWorkManage;
        _outOrderRepository = outOrderRepository;
@@ -63,75 +75,143 @@
        _cellStateService = cellStateService;
        _processApplyService = processApplyService;
        _areaInfoRepository = areaInfoRepository;
        _agingInOrOutInputService = agingInOrOutInputService;
        _stockInfoDetailRepository = stockInfoDetailRepository;
        _productionRepository = productionRepository;
    }

    #region å¤–部接口方法

    #region å †åž›æœºå‡ºåº“任务完成
    #region å‡ºåº“任务完成

    /// <summary>
    /// å †åž›æœºå‡ºåº“任务完成
    /// </summary>
    /// <param name="saveModel">任务数据合集</param>
    /// <returns>返回结果集</returns>

    public async Task<WebResponseContent> CompleteStackTaskAsync(Dt_Task task, DtStockInfo stock)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // æ›´æ–°åº“存状态
            // è®¾ç½®åº“位状态为空闲
            stock.LocationInfo.LocationStatus = LocationEnum.Free.ObjToInt();
            // è®¾ç½®åº“存状态为出库
            stock.StockInfoDetails.ForEach(x =>
            if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
            {
                x.Status = 2;
            });
                var process = await SqlSugarHelper.Db.Queryable<Dt_EquipmentProcess>()
                    .FirstAsync(x => x.EquipmentName == task.Roadway);
                var info = JsonConvert.DeserializeObject<ResponseEqptRunDto>(process.ProcessValue);

            // æ›´æ–°ä»»åŠ¡çŠ¶æ€
            task.TaskState = TaskOutStatusEnum.SC_OutFinish.ObjToInt();
            task.CurrentAddress = task.NextAddress;
            task.NextAddress = task.TargetAddress;
                var agingOutputDto = MapToAgingOutputDto(stock, info);
                content = await _agingInOrOutInputService.GetOCVOutputAsync(agingOutputDto);
                ValidateResponse(content);
            }

            LogFactory.GetLog("任务完成").InfoFormat(true, "堆垛机出库完成", "更新库存状态与任务状态");
            // æ›´æ–°åº“存状态和任务状态
            (var loc, var tas) = UpdateStockAndTaskStatus(stock, task);

            // äº‹åŠ¡å¤„理
            // å¼€å§‹äº‹åŠ¡
            _unitOfWorkManage.BeginTran();
            // æ›´æ–°åº“存信息
            var isStockUpdated = _stockInfoRepository.UpdateData(stock);
            // æ›´æ–°ä»»åŠ¡ä¿¡æ¯
            var isTaskUpdated = await Update(task);
            await _unitOfWorkManage.UseTranAsync(async () =>
            {
                await UpdateLocationAsync(loc);
                await DeleteStockInfoAsync(stock.Id);
                await DeleteStockInfoDetailsAsync(stock.StockInfoDetails);
                //await DeleteTaskAsync(task.TaskId);
            });

            // å¦‚果库存信息和任务信息都更新成功
            if (isStockUpdated && isTaskUpdated)
            {
                // è®°å½•æ—¥å¿—
                LogFactory.GetLog("任务完成").InfoFormat(true, "堆垛机出库完成", $"事务处理完成，库存状态更新：{isStockUpdated}，任务状态更新:{isTaskUpdated}");
                // æäº¤äº‹åŠ¡
                _unitOfWorkManage.CommitTran();
                // è¿”回成功结果
                return content.OK("任务完成成功");
            }
            else
            {
                // è®°å½•æ—¥å¿—
                LogFactory.GetLog("任务完成").InfoFormat(true, "堆垛机出库完成", $"事务处理失败，库存状态更新：{isStockUpdated}，任务状态更新:{isTaskUpdated}");
                // å›žæ»šäº‹åŠ¡
                _unitOfWorkManage.RollbackTran();
                // è¿”回失败结果
                return content.Error("任务或库存更新失败");
            }
            return content.OK("任务完成成功");
        }
        catch (Exception err)
        {
            LogFactory.GetLog("任务完成").InfoFormat(true, $"系统异常，异常信息：{err.Message}", "");
            Console.WriteLine(err.Message);
            LogFactory.GetLog("任务完成").Error(true, $"系统异常，异常信息：{err.Message}");
            return content.Error(err.Message);
        }
    }

    #endregion å †åž›æœºå‡ºåº“任务完成
    private AgingOutputDto MapToAgingOutputDto(DtStockInfo stock, ResponseEqptRunDto info)
    {
        // TODO Value值根据MOM下发的静置时间到当前时间的分钟数
        return new AgingOutputDto
        {
            OpFlag = 1,
            Software = "WMS",
            EquipmentCode = "ECH001-B",
            TrayBarcode = stock.PalletCode,
            SerialNos = stock.StockInfoDetails.Select(x => new SerialNoOutDto
            {
                SlotNo = x.OrderNo.ToInt32(),
                SerialNo = x.SerialNumber,
                SerialNoResult = true,
                ParameterInfo = info.ParameterInfo.Select(y => new ParameterInfo()
                {
                    LowerLomit = y.LowerControlLimit,
                    UpperLimit = y.UpperControlLimit,
                    ParameterResult = y.EquipmentAvailabilityFlag,
                    ParameterCode = y.ParameterCode,
                    ParameterDesc = y.Description,
                    TargetValue = y.TargetValue,
                    Value = ( DateTime.Parse(stock.LinedProcessFeedbackTime, null, System.Globalization.DateTimeStyles.RoundtripKind).ToLocalTime() - stock.CreateDate).TotalMinutes.ToString(),
                    DefectCode = y.UOMCode
                }).ToList()
            }).ToList()
        };
    }

    private void ValidateResponse(WebResponseContent content)
    {
        var result = JsonConvert.DeserializeObject<BasicResult>(content.Data.ToString());
        if (!result.Success)
        {
            throw new Exception(result.MOMMessage);
        }
    }

    private (DtLocationInfo, Dt_Task) UpdateStockAndTaskStatus(DtStockInfo stock, Dt_Task task)
    {
        var location = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
        var details = _stockInfoDetailRepository.QueryData(x => x.StockId == stock.Id);

        location.LocationStatus = (int)LocationEnum.Free;
        task.TaskState = (int)TaskOutStatusEnum.OutFinish;
        //task.CurrentAddress = task.NextAddress;
        //task.NextAddress = task.TargetAddress;

        LogFactory.GetLog("任务完成").Info(true, "更新库存状态与任务状态");
        return (location, task);
    }

    private async Task DeleteStockInfoAsync(int stockId)
    {
        var isStockUpdated = await _stockInfoRepository.DeleteDataByIdAsync(stockId);
        if (!isStockUpdated)
        {
            throw new Exception("库存信息更新失败");
        }
    }

    private async Task UpdateLocationAsync(DtLocationInfo info)
    {
        var isStockUpdated = await _locationRepository.UpdateDataAsync(info);
        if (!isStockUpdated)
        {
            throw new Exception("库存信息更新失败");
        }
    }

    private async Task DeleteStockInfoDetailsAsync(IEnumerable<DtStockInfoDetail> details)
    {
        var ids = details.Select(x => (object)x.Id).ToArray();
        var isStockDetailUpdated = await _stockInfoDetailRepository.DeleteDataByIdsAsync(ids);
        if (!isStockDetailUpdated)
        {
            throw new Exception("库存详情信息更新失败");
        }
    }

    private async Task DeleteTaskAsync(int taskId)
    {
        var isTaskUpdated = await BaseDal.DeleteDataByIdAsync(taskId);
        if (!isTaskUpdated)
        {
            throw new Exception("任务信息更新失败");
        }
    }

    #endregion å‡ºåº“任务完成

    #region ç§»åº“任务完成

@@ -169,51 +249,110 @@
    #region å…¥åº“任务完成

    /// <summary>
    /// å…¥åº“任务完成
    /// å®Œæˆå…¥åº“任务
    /// </summary>
    /// <param name="task">任务数据合集</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> CompleteInboundTaskAsync(Dt_Task task)
    {
        // åˆå§‹åŒ–响应内容
        WebResponseContent content = new WebResponseContent();
        try
        {
            // èŽ·å–装箱信息和目标位置信息
            var boxing = await _boxingInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);
            var locationInf = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress);

            var boxDetail = boxing.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
            // åˆ›å»ºåº“存实例模型
            DtStockInfo stock = new DtStockInfo()
            {
                PalletCode = task.PalletCode,
                LocationCode = task.TargetAddress,
                CreateDate = DateTime.Now,
                Creater = "system",
                IsFull = boxing.IsFull,
                StockInfoDetails = boxDetail,
                LocationInfo = new DtLocationInfo()
            };
            // æ›´æ–°ç›®æ ‡ä½ç½®çŠ¶æ€ä¸ºåº“存中
            locationInf.LocationStatus = (int)LocationEnum.InStock;

            // åˆ›å»ºåŽ†å²ä»»åŠ¡å®žä¾‹æ¨¡åž‹
            var taskHty = CreateHistoricalTask(task);

            // ä¿®æ”¹è´§ä½ä¿¡æ¯ä¸ºæœ‰è´§
            var locationInf = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress);
            locationInf.LocationStatus = (int)LocationEnum.InStock;

            LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务完成", $"货位地址：{task.TargetAddress},修改后货位数据：{locationInf}");
            // æ ¹æ®æ˜¯å¦æœ‰ç»„盘信息创建库存实例模型
            DtStockInfo stock = boxing == null ? CreateEmptyPalletStock(task, locationInf) : CreateFullPalletStock(task, locationInf, boxing);

            // æ‰§è¡Œæ•°æ®åº“事务
            bool isResult = await ExecuteTransaction(stock, taskHty, locationInf, task.TaskId);
            if (isResult)
            {
                content.OK("入库任务完成成功");
            }
            else
            {
                content.Error("入库任务完成失败");
            }
        }
        catch (Exception err)
        {
            // è®°å½•å¼‚常信息到控制台和日志
            Console.WriteLine(err.Message.ToString());
            LogFactory.GetLog("任务完成").Error(true, err);
        }
        return content;
    }

    /// <summary>
    /// åˆ›å»ºç©ºæ‰˜ç›˜çš„库存实例模型
    /// </summary>
    private DtStockInfo CreateEmptyPalletStock(Dt_Task task, DtLocationInfo locationInf)
    {
        return new DtStockInfo()
        {
            PalletCode = task.PalletCode,
            LocationCode = task.TargetAddress,
            CreateDate = DateTime.Now,
            Creater = "system",
            IsFull = false,
            AreaCode = task.Roadway,
            StockInfoDetails = new List<DtStockInfoDetail>()
            {
                new DtStockInfoDetail()
                {
                    MaterielCode = "空托盘",
                    Id = 0,
                }
            }
        };
    }

    /// <summary>
    /// åˆ›å»ºå®žç›˜çš„库存实例模型并调用MOM入库
    /// </summary>
    private DtStockInfo CreateFullPalletStock(Dt_Task task, DtLocationInfo locationInf, DtBoxingInfo boxing)
    {
        var boxDetail = boxing.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
        var stock = new DtStockInfo()
        {
            PalletCode = task.PalletCode,
            LocationCode = task.TargetAddress,
            CreateDate = DateTime.Now,
            Creater = "system",
            IsFull = boxing.IsFull,
            AreaCode = task.Roadway,
            StockInfoDetails = boxDetail,
        };

        // å¤„理请求参数
        AgingInputDto agingInputDto = new AgingInputDto()
        {
            SerialNos = boxing.BoxingInfoDetails
                .Select(item => new SerialNoInDto { SerialNo = item.SerialNumber, PositionNo = item.OrderNo })
                .ToList(),
            TrayBarcode = task.PalletCode,
            OpFlag = 1,
            EquipmentCode = "ECH001-B",
            Software = "WMS"
        };
        var result = _agingInOrOutInputService.GetOCVInputAsync(agingInputDto).Result;
        var respone = JsonConvert.DeserializeObject<ResponeAgingInputDto>(result.Data.ToString());
        stock.LinedProcessFeedbackTime = respone.LinedProcessFeedbackTime;
        stock.SpecialParameterDuration = respone.SpecialParameterDuration;

        // è®°å½•æ—¥å¿—
        LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务完成", $"货位地址：{task.TargetAddress},修改后货位数据：{locationInf}");

        return stock;
    }

    #endregion å…¥åº“任务完成
@@ -221,13 +360,15 @@
    #region ä»»åŠ¡å®Œæˆ

    /// <summary>
    /// ä»»åŠ¡å®Œæˆ
    /// å®Œæˆä»»åŠ¡
    /// </summary>
    /// <param name="taskNum">任务号</param>
    /// <returns></returns>
    /// <param name="taskNum">任务编号</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> CompleteAsync(int taskNum)
    {
        // åˆå§‹åŒ–响应内容
        WebResponseContent content = new WebResponseContent();

        // æå–任务数据
        LogFactory.GetLog("任务完成").InfoFormat(true, "提取任务数据", $"任务号：{taskNum}");

@@ -240,55 +381,32 @@
        LogFactory.GetLog("任务完成").InfoFormat(true, "验证任务是否存在", JsonConvert.SerializeObject(task));

        // éªŒè¯åº“存是否存在
        var stock = await _stockInfoRepository.QueryFirstAsync(x => x.PalletCode == task.PalletCode);
        if (stock == null)
        var stock = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);

        // æ ¹æ®ä»»åŠ¡ç±»åž‹è°ƒç”¨ç›¸åº”的完成任务方法
        switch (task.TaskType)
        {
            LogFactory.GetLog("任务完成").InfoFormat(true, "库存不存在存在，判断是否是入库任务", $"{task.TaskType}");
            if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)
            {
            case (int)TaskInboundTypeEnum.Inbound:
            case (int)TaskInboundTypeEnum.InTray:
                LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务", "");
                return await CompleteInboundTaskAsync(task);
            }
            else
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "库存不存在也不是入库任务", "");
                return content.Error("库存不存在");
            }
        }
        LogFactory.GetLog("任务完成").InfoFormat(true, "验证库存是否存在", JsonConvert.SerializeObject(stock));

        if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
        {
            LogFactory.GetLog("任务完成").InfoFormat(true, "出库任务", "");
            if (task.TaskState == TaskOutStatusEnum.SC_OutExecuting.ObjToInt())
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "堆垛机出库完成", "");
            case (int)TaskOutboundTypeEnum.OutTray:
            case (int)TaskOutboundTypeEnum.Outbound:
                LogFactory.GetLog("任务完成").InfoFormat(true, "出库任务", "");
                return await CompleteStackTaskAsync(task, stock);
            }
            else
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "库存不存在也不是入库任务", "");
                return content.Error("库存不存在");
            }
        }
        else if (task.TaskType == (int)TaskTypeEnum.RelocationIn)
        {
            LogFactory.GetLog("任务完成").InfoFormat(true, "移库任务完成", "");
            return await CompleteTransferTaskAsync(task, stock);
        }
        else
        {
            LogFactory.GetLog("任务完成").InfoFormat(true, $"任务状态异常", "无参数");
            return content.Error("任务状态异常");

            default:
                return content.Error("任务类型不存在");
        }
    }

    #endregion ä»»åŠ¡å®Œæˆ

    #region è¯·æ±‚任务
    #region è¯·æ±‚任务入库

    /// <summary>
    /// è¯·æ±‚任务
    /// è¯·æ±‚任务巷道
    /// </summary>
    /// <param name="input">请求模型</param>
    /// <returns>包含任务信息的响应内容</returns>
@@ -299,10 +417,34 @@

        try
        {
            // è°ƒç”¨BaseDal.QueryFirstAsync方法，查询任务
            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
            if (task != null)
            {
                //if (task.TaskState == (int)TaskInStatusEnum.InNew)
                {
                    // åˆ›å»ºWMS任务
                    WMSTaskDTO taskDTO = new WMSTaskDTO()
                    {
                        TaskNum = task.TaskNum.Value,
                        Grade = 1,
                        PalletCode = task.PalletCode,
                        RoadWay = task.Roadway,
                        SourceAddress = task.SourceAddress,
                        TargetAddress = task.Roadway,
                        TaskState = task.TaskState.Value,
                        Id = 0,
                        TaskType = task.TaskType,
                    };
                    return content.OK(data: taskDTO);
                }
            }
            // åˆ›å»ºä¸€ä¸ªTrayCellsStatusDto对象，并赋值
            TrayCellsStatusDto trayCells = new TrayCellsStatusDto()
            {
                TrayBarcode = input.PalletCode
                Software = "WMS",
                TrayBarcode = input.PalletCode,
                EquipmentCode = "ECH001-B"
            };

            // è°ƒç”¨GetTrayCellStatusAsync方法，获取整盘电芯
@@ -310,18 +452,44 @@
            // å¦‚果状态为false，则返回content
            if (!content.Status) return content;

            // è°ƒç”¨GetProcessApplyAsync方法，获取工艺申请
            ProcessApplyDto process = await GetProcessApplyAsync(content);
            // æ·»åŠ ç»„盘信息
            // å°†content.Data转换为ResultTrayCellsStatus对象
            var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
            if (result.SerialNos.Count <= 0)
                return content.Error(result.MOMMessage);

            // TODO èŽ·å–本地料框属性与整盘电芯属性获取的值进行对比，如果一致则继续，否则返回错误信息
            var productions = await _productionRepository.QueryDataAsync(x => result.TrayBarcodePropertys.Select(x => x.TrayBarcodeProperty).ToList().Contains(x.TrayBarcodeProperty));
            if (productions.Count <= 0)
                return content.Error("料框属性不存在");

            // è°ƒç”¨CreateBoxingInfo方法，创建组盘信息

            var boxing = await CreateBoxingInfo(result, input.PalletCode);
            if (boxing == null) return content.Error("组盘失败");

            // è°ƒç”¨GetProcessApplyAsync方法，获取工艺路线
            ProcessApplyDto process = await GetProcessApplyAsync(result);

            // å¦‚æžœprocess为null，则返回content
            if (process == null) return content;

            // è°ƒç”¨GetProcessResponseAsync方法，获取工艺响应
            var processResponse = await GetProcessResponseAsync(process, input.Position);
            // è°ƒç”¨_processApplyService.GetProcessApplyAsync方法，获取工艺申请
            content = await _processApplyService.GetProcessApplyAsync(process);

            // è°ƒç”¨BaseDal.QueryFirstAsync方法，查询任务
            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
            // å¦‚æžœtask不为null，则调用UpdateExistingTask方法，更新任务；否则调用CreateNewTask方法，创建新任务
            content = task != null ? await UpdateExistingTask(input, task) : await CreateNewTask(processResponse, input);
            // å¦‚果状态为false，则返回null
            if (!content.Status) return content.Error("工艺申请失败");

            //// è°ƒç”¨GetProcessResponseAsync方法，获取工艺响应
            //var processResponse = await GetProcessResponseAsync(process, input.Position);

            List<string> strings = input.Position == "1088" ? new List<string>() { "CHSC01" } : new List<string>() { "JZSC01" };
            // è°ƒç”¨CreateNewTask方法，创建新任务
            content =  await CreateNewTask(input, strings);
            if (content.Status)
            {
                var isBox = await _boxingInfoRepository.AddDataNavAsync(boxing);
            }
        }
        catch (Exception err)
        {
@@ -334,6 +502,70 @@
        return content;
    }

    /// <summary>
    /// æ›´æ–°ä»»åŠ¡è´§ä½
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<WebResponseContent> UpdateExistingTask(RequestTaskDto input)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
            if (task == null)
                return content.Error($"暂未找到【{input.PalletCode}】的任务");

            return content = await UpdateExistingTask(input, task);

        }
        catch (Exception err)
        {

            throw;
        }
    }

    /// <summary>
    /// ç©ºæ‰˜ç›˜å…¥åº“申请
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<WebResponseContent> RequestTrayInTaskAsync(RequestTaskDto input)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {

            // è°ƒç”¨BaseDal.QueryFirstAsync方法，查询任务
            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
            if (task != null && task.TaskState == (int)TaskInStatusEnum.InNew)
            {
                // åˆ›å»ºWMS任务
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                {
                    TaskNum = task.TaskNum.Value,
                    Grade = 1,
                    PalletCode = task.PalletCode,
                    RoadWay = task.Roadway,
                    SourceAddress = task.SourceAddress,
                    TargetAddress = task.Roadway,
                    TaskState = task.TaskState.Value,
                    Id = 0,
                    TaskType = task.TaskType,
                };
                return content.OK(data: task);
            }

            return await CreateNewTask(input, null, 1);
        }
        catch (Exception)
        {

            throw;
        }
    }

    // èŽ·å–托盘单元格状态
    private async Task<WebResponseContent> GetTrayCellStatusAsync(TrayCellsStatusDto trayCells)
    {
@@ -341,19 +573,34 @@
        return await _cellStateService.GetTrayCellStatusAsync(trayCells);
    }

    // èŽ·å–工艺申请
    private async Task<ProcessApplyDto> GetProcessApplyAsync(WebResponseContent content)
    // èŽ·å–组盘信息
    private async Task<DtBoxingInfo> CreateBoxingInfo(ResultTrayCellsStatus result, string palletCode)
    {
        // å¦‚果状态为false，则返回null
        if (!content.Status) return null;
        return new DtBoxingInfo
        {
            PalletCode = palletCode,
            IsFull = true,
            BoxingInfoDetails = result.SerialNos.Select(serialNoObj => new DtBoxingInfoDetail
            {
                SerialNumber = serialNoObj.SerialNo,
                OrderNo = serialNoObj.PositionNo.ToString(),
                Status = serialNoObj.SerialNoStatus,
                MaterielCode = result.BindCode,
                Remark = result.TrayBarcodePropertys.ToJsonString(),
            }).ToList()
        };
    }

        // å°†content.Data转换为ResultTrayCellsStatus对象
        var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
    // èŽ·å–工艺申请
    private async Task<ProcessApplyDto> GetProcessApplyAsync(ResultTrayCellsStatus content)
    {
        // åˆ›å»ºä¸€ä¸ªProcessApplyDto对象，并赋值
        return new ProcessApplyDto()
        {
            WipOrderNo = result.BindCode,
            SerialNos = result.SerialNos.Select(item => new SerialNos
            EquipmentCode = "ECH001-B",
            Software = "WMS",
            //WipOrderNo = result.BindCode,
            SerialNos = content.SerialNos.Select(item => new SerialNos
            {
                SerialNo = item.SerialNo
            }).ToList()
@@ -378,7 +625,13 @@
        {
            case "1088":
                return SqlSugarHelper.Db.Queryable<Dt_EquipmentProcess>()
                    .Where(x => x.EquipmentType == "陈化" && x.WipOrderNo == apply.WipOrderNo && x.ProductDesc == apply.ProductNo)
                    .Where(x => x.EquipmentType == "陈化" && x.WipOrderNo == apply.WipOrderNo || x.ProductDesc == apply.ProductNo)
                    .ToList();

            case "1339":
            case "1406":
                return SqlSugarHelper.Db.Queryable<Dt_EquipmentProcess>()
                    .Where(x => x.EquipmentType == "静置" && x.WipOrderNo == apply.WipOrderNo || x.ProductDesc == apply.ProductNo)
                    .ToList();

            default:
@@ -386,64 +639,208 @@
        }
    }

    #endregion è¯·æ±‚任务
    #endregion è¯·æ±‚任务入库

    #region è¯·æ±‚空托盘
    #region è¯·æ±‚出库（实盘&空盘）

    public async Task<WebResponseContent> RequestTrayTaskAsync(string position)
    /// <summary>
    /// è¯·æ±‚托盘任务
    /// </summary>
    /// <param name="position">目标位置</param>
    /// <param name="tag">托盘类型（1：实盘，2：空盘）</param>
    /// <param name="areaCode">区域编码</param>
    /// <param name="roadways">巷道编码集合</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> RequestTrayOutTaskAsync(string position, int tag, string areaCode, List<string> roadways)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var area = _areaInfoRepository.QueryFirst(x => x.AreaCode == "CH");
            // æ ¹æ®æ‰˜ç›˜ç±»åž‹æŸ¥è¯¢åº“存信息
            DtStockInfo stockInfo = tag == (int)TaskOutboundTypeEnum.Outbound
                ? QueryStockInfoForRealTray(areaCode, roadways)
                : QueryStockInfoForEmptyTray(areaCode, roadways);

            var stockInfo = _stockInfoRepository.QueryData(x => x.Remark == area.AreaCode && x.StockInfoDetails.Any(z => z.MaterielCode == "空托盘")).OrderBy(x => x.CreateDate).FirstOrDefault();
            // åˆ›å»ºæ–°ä»»åŠ¡å®žä¾‹
            var task = new Dt_Task
            if (stockInfo == null)
            {
                CurrentAddress = stockInfo.LocationCode,
                Grade = 1,
                Roadway = stockInfo.LocationInfo.RoadwayNo,
                TargetAddress = position,
                Dispatchertime = DateTime.Now,
                MaterialNo = "",
                NextAddress = position,
                OrderNo = null,
                PalletCode = stockInfo.PalletCode,
                SourceAddress = stockInfo.LocationCode,
                TaskState = (int)TaskOutStatusEnum.OutNew,
                TaskType = (int)TaskOutboundTypeEnum.OutTray,
                TaskNum = await BaseDal.GetTaskNo(),
                Creater = "Systeam"
            };
                return content.Error("库存信息不存在");
            }

            // åˆ›å»ºæ–°ä»»åŠ¡å®žä¾‹
            var task = CreateTask(stockInfo, position, tag);
            var taskId = await BaseDal.AddDataAsync(task);
            bool isResult = taskId > 0;
            if (isResult)
            if (!isResult)
            {
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                return content.Error("任务创建失败");
            }

            // åˆ›å»ºä»»åŠ¡DTO
            WMSTaskDTO taskDTO = CreateTaskDTO(task);
            //if (tag == 1)
            {
                // æ›´æ–°åº“存位置状态为不可用
                stockInfo.LocationInfo.LocationStatus = (int)LocationEnum.InStockDisable;
                await _locationRepository.UpdateDataAsync(stockInfo.LocationInfo);
            }

            // è¿”回成功响应
            return content.OK(data: taskDTO);
        }
        catch (Exception ex)
        {
            // è®°å½•å¼‚常信息并抛出
            LogFactory.GetLog("请求托盘任务").Error(true, ex);
            return content.Error(ex.Message);
        }
    }

    /// <summary>
    /// æŸ¥è¯¢å®žç›˜åº“存信息
    /// </summary>
    private DtStockInfo QueryStockInfoForRealTray(string areaCode, List<string> roadways)
    {
        // TODO时间根据MOM系统配置的出库时间来获取,暂时不知道MOM返回的时间是什么所以这里测试时候在改
        return _stockInfoRepository.Db.Queryable<DtStockInfo>().Where(x => x.AreaCode == areaCode && Convert.ToDateTime(x.LinedProcessFeedbackTime) < DateTime.Now && x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && roadways.Contains(x.LocationInfo.RoadwayNo))
                                   .Includes(x => x.LocationInfo)
                                   .Includes(x => x.StockInfoDetails)
                                   .OrderBy(x => x.CreateDate)
                                   .First();
    }

    /// <summary>
    /// æŸ¥è¯¢ç©ºç›˜åº“存信息
    /// </summary>
    private DtStockInfo QueryStockInfoForEmptyTray(string areaCode, List<string> roadways)
    {
        return _stockInfoRepository.Db.Queryable<DtStockInfo>().Where(x => x.AreaCode == areaCode && x.StockInfoDetails.Any(z => z.MaterielCode == "空托盘") && roadways.Contains(x.LocationInfo.RoadwayNo))
                                   .Includes(x => x.LocationInfo)
                                   .Includes(x => x.StockInfoDetails)
                                   .OrderBy(x => x.CreateDate)
                                   .First();
    }

    /// <summary>
    /// åˆ›å»ºä»»åŠ¡å®žä¾‹
    /// </summary>
    private Dt_Task CreateTask(DtStockInfo stockInfo, string position, int tag)
    {
        return new Dt_Task
        {
            Grade = 1,
            Roadway = stockInfo.LocationInfo.RoadwayNo,
            TargetAddress = position,
            Dispatchertime = DateTime.Now,
            MaterialNo = "",
            NextAddress = position,
            OrderNo = null,
            PalletCode = stockInfo.PalletCode,
            SourceAddress = stockInfo.LocationCode,
            CurrentAddress = stockInfo.LocationCode,
            TaskState = (int)TaskOutStatusEnum.OutNew,
            TaskType = tag == (int)TaskOutboundTypeEnum.Outbound ? (int)TaskOutboundTypeEnum.Outbound : (int)TaskOutboundTypeEnum.OutTray,
            TaskNum = BaseDal.GetTaskNo().Result,
            Creater = "System" // ä¿®æ­£æ‹¼å†™é”™è¯¯
        };
    }

    /// <summary>
    /// åˆ›å»ºä»»åŠ¡DTO
    /// </summary>
    private WMSTaskDTO CreateTaskDTO(Dt_Task task)
    {
        return new WMSTaskDTO
        {
            TaskNum = task.TaskNum.Value,
            Grade = 1,
            PalletCode = task.PalletCode,
            RoadWay = task.Roadway,
            SourceAddress = task.SourceAddress,
            TargetAddress = task.TargetAddress,
            TaskState = task.TaskState.Value,
            Id = 0,
            TaskType = task.TaskType,
        };
    }

    #endregion è¯·æ±‚出库

    #region ä»»åŠ¡çŠ¶æ€æ›´æ”¹

    /// <summary>
    /// æ›´æ–°ä»»åŠ¡çŠ¶æ€&出库解盘
    /// </summary>
    /// <param name="taskNum"></param>
    /// <param name="taskState"></param>
    /// <returns></returns>
    public async Task<WebResponseContent> UpdateTaskStatus(int taskNum, int taskState)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var task = await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
            if (task == null)
                return content.Error("未找到任务");

            if (taskState == (int)TaskOutStatusEnum.Line_OutFinish)
            {
                var taskHty = CreateHistoricalTask(task);
                await _unitOfWorkManage.UseTranAsync(async () =>
                {
                    TaskNum = task.TaskNum.Value,
                    Grade = 1,
                    PalletCode = DateTime.Now.ToString("MMddHHmmss"),
                    RoadWay = task.Roadway,
                    SourceAddress = stockInfo.LocationCode,
                    TargetAddress = task.Roadway,
                    TaskState = (int)TaskOutStatusEnum.OutNew,
                    Id = 0,
                    TaskType = (int)TaskOutboundTypeEnum.OutTray
                };
                content.OK(data: taskDTO);
                    var asb = await BaseDal.DeleteDataByIdAsync(task.TaskId);
                    var asbHty = await _task_HtyRepository.AddDataAsync(taskHty) > 0;
                    if (asb && asbHty)
                        content.OK();
                    else
                        throw new Exception();
                });
                content.OK();
            }
            else
            {
                task.TaskState = taskState;
                var asb = await BaseDal.UpdateDataAsync(task);
                if (asb)
                    content.OK();
                else
                    content.Error();
            }
        }
        catch (Exception ex)
        {
            throw;
            content.Error(ex.Message);
        }
        return content;
    }

    #endregion è¯·æ±‚空托盘
    #endregion

    #region å‡ºåº“解盘

    /// <summary>
    /// å‡ºåº“解盘接口
    /// </summary>
    /// <param name="taskNum"></param>
    /// <returns></returns>
    public async Task<WebResponseContent> OutUnblockInterface(int taskNum)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var task = await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
            if (task == null)
                return content.Error("未找到任务");
            task.TaskState = (int)TaskOutStatusEnum.Line_OutFinish;
            var taskHty = CreateHistoricalTask(task);
        }
        catch (Exception ex)
        {
            content.Error(ex.Message);
        }
        return content;
    }

    #endregion

    #endregion å¤–部接口方法

@@ -693,6 +1090,8 @@
                isUpdateStock = await _stockInfoRepository.AddDataNavAsync(stock);
            }



            // æ·»åŠ åŽ†å²ä»»åŠ¡
            var isTaskHtyAdd = await _task_HtyRepository.AddDataAsync(taskHty) > 0;

@@ -745,15 +1144,6 @@
        DtLocationInfo location = new DtLocationInfo();
        int beforeStatus = 0;

        // æ ¹æ®ä»»åŠ¡ç±»åž‹åˆ¤æ–­æ˜¯å‡ºåº“任务还是入库任务
        //if (input.Type == (int)TaskTypeEnum.Outbound)
        //{
        //    // å¤„理出库任务
        //    toAddress = await GetRoadWayAsync(areaId, task.Roadway, input.Direction, input.Area, input.Type);
        //    taskState = (int)TaskOutStatusEnum.SC_OutFinish;
        //}
        //else
        //{
        // å¤„理入库任务
        location = await GetLocationDistributeAsync(task.Roadway);
        toAddress = location.LocationCode;
@@ -762,10 +1152,8 @@

        // æ›´æ–°è´§ä½ä¿¡æ¯
        location.LocationStatus = (int)LocationEnum.Lock;
        //}

        // æ›´æ–°ä»»åŠ¡ä¿¡æ¯
        //task.SourceAddress = input.Position;
        task.CurrentAddress = input.Position;
        task.TargetAddress = toAddress;
        task.NextAddress = toAddress;
@@ -818,12 +1206,12 @@
    /// <param name="areaId">区域ID</param>
    /// <param name="content">响应内容</param>
    /// <returns></returns>
    private async Task<WebResponseContent> CreateNewTask(List<Dt_EquipmentProcess> process, RequestTaskDto input)
    private async Task<WebResponseContent> CreateNewTask(RequestTaskDto input, List<string> process = null, int flag = 0)
    {
        WebResponseContent content = new WebResponseContent();
        List<string> strings = process.Select(x => x.EquipmentName).ToList();

        // èŽ·å–目标地址
        string ToAddress = await GetRoadWayAsync(strings);
        string ToAddress = await GetRoadWayAsync(process);

        // åˆ›å»ºæ–°ä»»åŠ¡å®žä¾‹
        var task = new Dt_Task
@@ -839,10 +1227,11 @@
            PalletCode = input.PalletCode,
            SourceAddress = input.Position,
            TaskState = (int)TaskInStatusEnum.InNew,
            TaskType = (int)TaskTypeEnum.Inbound,
            TaskType = flag == 0 ? (int)TaskInboundTypeEnum.Inbound : (int)TaskInboundTypeEnum.InTray,
            TaskNum = await BaseDal.GetTaskNo(),
            Creater = "Systeam"
        };

        // å°è¯•æ·»åŠ æ–°ä»»åŠ¡
        var taskId = await BaseDal.AddDataAsync(task);
        bool isResult = taskId > 0;
@@ -852,17 +1241,18 @@
            isResult = await _taskExecuteDetailRepository.AddDetailAsync(task, false, TaskDescription.GetTaskUpdateDescription(input.PalletCode, input.Position, ToAddress, TaskInStatusEnum.InNew.GetIntegralRuleTypeEnumDesc()));
            if (isResult)
            {
                // åˆ›å»ºWMS任务
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                {
                    TaskNum = 0,
                    TaskNum = task.TaskNum.Value,
                    Grade = 1,
                    PalletCode = DateTime.Now.ToString("MMddHHmmss"),
                    PalletCode = task.PalletCode,
                    RoadWay = task.Roadway,
                    SourceAddress = input.Position,
                    SourceAddress = task.SourceAddress,
                    TargetAddress = task.Roadway,
                    TaskState = (int)TaskInStatusEnum.InNew,
                    TaskState = task.TaskState.Value,
                    Id = 0,
                    TaskType = (int)TaskInboundTypeEnum.Inbound,
                    TaskType = task.TaskType,
                };
                content.OK(data: taskDTO);
            }
@@ -915,6 +1305,22 @@
    {
        var minGroup = _locationRepository.QueryData(x => process.Contains(x.RoadwayNo) && x.LocationStatus == (int)LocationEnum.Free)
            .GroupBy(x => x.RoadwayNo)
             .OrderByDescending(g => g.Count()) // æ ¹æ®æ¯ä¸ªç»„的元素数量排序
             .First(); // å–出数量最多的组

        string minRoadwayNo = minGroup.Key; // æ•°é‡æœ€å¤šçš„组的Key

        return minRoadwayNo;
    }

    /// <summary>
    /// èŽ·å–巷道或站台
    /// </summary>
    /// <returns></returns>
    public async Task<string> GetRoadWayAsync(int areaCode)
    {
        var minGroup = _locationRepository.QueryData(x => x.AreaId == areaCode && x.LocationStatus == (int)LocationEnum.Free)
            .GroupBy(x => x.RoadwayNo)
             .OrderBy(g => g.Count()) // æ ¹æ®æ¯ä¸ªç»„的元素数量排序
             .First(); // å–出数量最少的组


 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Basic/ProductionController.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@

namespace WIDESEA_WMSServer.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductionController : ApiBaseController<IProductionService, ProductionModel>
    {
        public ProductionController(IProductionService service) : base(service)
        {
        }

        public override ActionResult AddData([FromBody] ProductionModel options)
        {
            return base.AddData(options);
        }
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Integration/AgingInOrOutController.cs

@@ -19,7 +19,7 @@
    /// <returns></returns>
    // POST: api/AgingInOrOut/OCVInput
    [HttpPost("OCVInput")]
    public Task<dynamic> GetOCVInputAsync([FromBody] AgingInputDto input)
    public Task<WebResponseContent> GetOCVInputAsync([FromBody] AgingInputDto input)
    {
        return _agingInOrOutInputService.GetOCVInputAsync(input);
    }
@@ -31,7 +31,7 @@
    /// <returns></returns>
    // POST: api/AgingInOrOut/OCVOutput
    [HttpPost("OCVOutput")]
    public Task<dynamic> GetOCVOutputAsync([FromBody] AgingOutputDto input)
    public Task<WebResponseContent> GetOCVOutputAsync([FromBody] AgingOutputDto input)
    {
        return _agingInOrOutInputService.GetOCVOutputAsync(input);
    }

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/TaskController.cs

@@ -1,4 +1,5 @@
using WIDESEA_DTO;
using static WIDESEA_DTO.RequestTaskDto;

namespace WIDESEA_WMSServer.Controllers;

@@ -45,7 +46,7 @@
    }

    /// <summary>
    /// ä»»åŠ¡è¯·æ±‚
    /// è¯·æ±‚任务巷道
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
@@ -56,13 +57,47 @@
    }

    /// <summary>
    /// ç©ºæ‰˜ç›˜è¯·æ±‚
    /// è¯·æ±‚任务货位
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestTrayTaskAsync")]
    public async Task<WebResponseContent> RequestTrayTaskAsync([FromBody] string position)
    [HttpPost, AllowAnonymous, Route("RequestLocationTaskAsync")]
    public async Task<WebResponseContent> UpdateExistingTask([FromBody] RequestTaskDto input)
    {
        return await Service.RequestTrayTaskAsync(position);
        return await Service.UpdateExistingTask(input);
    }

    /// <summary>
    /// ç©ºæ‰˜ç›˜å…¥åº“请求
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestTrayInTaskAsync")]
    public async Task<WebResponseContent> RequestTrayInTaskAsync([FromBody] RequestTaskDto input)
    {
        return await Service.RequestTrayInTaskAsync(input);
    }

    /// <summary>
    /// ç©ºæ‰˜ç›˜&满盘出库请求
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestTrayOutTaskAsync")]
    public async Task<WebResponseContent> RequestTrayOutTaskAsync([FromBody] RequestOutTaskDto request)
    {
        return await Service.RequestTrayOutTaskAsync(request.Position, request.Tag, request.AreaCdoe, request.Roadways);
    }

    /// <summary>
    /// ä»»åŠ¡çŠ¶æ€ä¿®æ”¹
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("UpdateTaskStatus")]
    public async Task<WebResponseContent> UpdateTaskStatus([FromBody] UpdateStatusDto input)
    {
        return await Service.UpdateTaskStatus(input.TaskNum, input.TaskState);
    }

}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/GlobalUsing.cs

@@ -12,4 +12,5 @@
global using WIDESEA_Model.Models.System;
global using WIDESEA_Core.Authorization;
global using WIDESEA_Core.Utilities;
global using WIDESEA_Model;
global using WIDESEA_Model;
global using WIDESEA_StorageBasicServices;

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_WMSServer.csproj.user

@@ -1,8 +1,8 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Controller_SelectedScaffolderID>MvcControllerEmptyScaffolder</Controller_SelectedScaffolderID>
    <Controller_SelectedScaffolderCategoryPath>root/Common/MVC/Controller</Controller_SelectedScaffolderCategoryPath>
    <Controller_SelectedScaffolderID>ApiControllerEmptyScaffolder</Controller_SelectedScaffolderID>
    <Controller_SelectedScaffolderCategoryPath>root/Common/Api</Controller_SelectedScaffolderCategoryPath>
    <NameOfLastUsedPublishProfile>D:\Git\BaiBuLiKu\Code Management\WMS\WIDESEA_WMSServer\WIDESEA_WMSServer\Properties\PublishProfiles\FolderProfile.pubxml</NameOfLastUsedPublishProfile>
  </PropertyGroup>
</Project>