1

huanghongfeng

2025-11-05 279077bf41bc726b474ca5d76cd2b8393d41d867

1

 ÏîÄ¿´úÂë/DB/³õʼ»¯.txt

ÎļþÒÑɾ³ý

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/FileContentIndex/read.lock

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Common/Http/HttpHelperh.cs

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

using Newtonsoft.Json;
using System.Net;
using System.Text;
using WIDESEA_Common.Log;

namespace WIDESEA_Comm.Http
{
    public class HttpHelperh
    {
        private const int Timeout = 60 * 1000;

        /// <summary>
        /// post请求
        /// </summary>
        /// <param name="url"></param>
        /// <param name="parm">参数</param>
        /// <param name="rquestName">接口名称,用于日志分类</param>
        /// <returns></returns>
        public static string Post(string url, object parm, string rquestName = "")
        {
            HttpWebResponse response = null;
            StreamReader resultReader = null;
            string responseContent = string.Empty;
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                request.Timeout = Timeout;
                request.Method = "POST";
                request.ContentType = "application/json; charset=UTF-8";
                parm = parm ?? "";
                byte[] data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(parm));
                request.ContentLength = data.Length;
                using (Stream newStream = request.GetRequestStream())
                {
                    newStream.Write(data, 0, data.Length);
                };

                response = (HttpWebResponse)request.GetResponse();
                Stream webStream = response.GetResponseStream();
                if (webStream == null)
                {
                    throw new Exception("Network error");
                }

                int statsCode = (int)response.StatusCode;
                resultReader = new StreamReader(webStream, Encoding.UTF8);
                responseContent = resultReader.ReadToEnd();

                if (response != null)
                    response.Close();
                if (resultReader != null)
                    resultReader.Close();

                if (statsCode != 200)
                {
                    throw new Exception("异常，响应码：" + statsCode.ToString());
                }

                //WriteLog.Write_Log("System/API请求", rquestName, "请求成功", new { è¯·æ±‚报文 = parm, æŽ¥æ”¶æŠ¥æ–‡ = responseContent });
                return responseContent;
            }
            catch (Exception ex)
            {
                WriteLog.Write_Log("System/API请求", rquestName, "请求异常", new { è¯·æ±‚报文 = parm, æŽ¥æ”¶æŠ¥æ–‡ = responseContent, é”™è¯¯ = ex.Message });
                throw ex;
            }
        }

        /// <summary>
        /// post请求
        /// </summary>
        /// <param name="url"></param>
        /// <param name="parm">参数</param>
        /// <param name="rquestName">接口名称,用于日志分类</param>
        /// <returns></returns>
        public static T Post<T>(string url, object parm, string rquestName = "") where T : class
        {
            HttpWebResponse response = null;
            StreamReader resultReader = null;
            string responseContent = string.Empty;
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                request.Timeout = Timeout;
                request.Method = "POST";
                request.ContentType = "application/json; charset=UTF-8";
                parm = parm ?? "";
                byte[] data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(parm));
                request.ContentLength = data.Length;
                using (Stream newStream = request.GetRequestStream())
                {
                    newStream.Write(data, 0, data.Length);
                };

                response = (HttpWebResponse)request.GetResponse();
                Stream webStream = response.GetResponseStream();
                if (webStream == null)
                {
                    throw new Exception("Network error");
                }

                int statsCode = (int)response.StatusCode;
                resultReader = new StreamReader(webStream, Encoding.UTF8);
                responseContent = resultReader.ReadToEnd();

                if (response != null)
                    response.Close();
                if (resultReader != null)
                    resultReader.Close();

                if (statsCode != 200)
                {
                    throw new Exception("异常，响应码：" + statsCode.ToString());
                }

                //WriteLog.Write_Log("System/API请求", rquestName, "请求成功", new { è¯·æ±‚报文 = parm, æŽ¥æ”¶æŠ¥æ–‡ = responseContent });
                return JsonConvert.DeserializeObject<T>(responseContent);
            }
            catch (Exception ex)
            {
                WriteLog.Write_Log("System/API请求", rquestName, "请求异常", new { è¯·æ±‚报文 = parm, æŽ¥æ”¶æŠ¥æ–‡ = responseContent, é”™è¯¯ = ex.Message });
                throw ex;
            }
        }


        /// <summary>
        /// get请求
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="url"></param>
        /// <param name="parm">请求参数，添加在url</param>
        /// <param name="rquestName"></param>
        /// <returns></returns>
        public static T Get<T>(string url, object parm = null, string rquestName = "") where T : class
        {
            HttpWebResponse response = null;
            StreamReader resultReader = null;
            string responseContent = string.Empty;
            try
            {
                if (parm != null)
                {
                    var datas = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(parm));
                    var keyList = datas.Keys;
                    int index = 0;
                    foreach (var key in datas.Keys)
                    {
                        if (index == 0)
                        {
                            url += $"?{key}={datas[key]}";
                        }
                        else
                        {
                            url += $"&{key}={datas[key]}";
                        }
                        index++;
                    }
                }
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                request.Timeout = Timeout;
                request.Method = "GET";
                request.ContentType = "application/json; charset=UTF-8";

                response = (HttpWebResponse)request.GetResponse();
                Stream webStream = response.GetResponseStream();
                if (webStream == null)
                {
                    throw new Exception("Network error");
                }

                int statsCode = (int)response.StatusCode;
                resultReader = new StreamReader(webStream, Encoding.UTF8);
                responseContent = resultReader.ReadToEnd();

                if (response != null)
                    response.Close();
                if (resultReader != null)
                    resultReader.Close();

                if (statsCode != 200)
                {
                    throw new Exception("异常，响应码：" + statsCode.ToString());
                }

                WriteLog.Write_Log("System/API请求", rquestName, "请求成功", new { è¯·æ±‚报文 = parm, æŽ¥æ”¶æŠ¥æ–‡ = responseContent });
                return JsonConvert.DeserializeObject<T>(responseContent);
            }
            catch (Exception ex)
            {
                WriteLog.Write_Log("System/API请求", rquestName, "请求异常", new { è¯·æ±‚报文 = parm, æŽ¥æ”¶æŠ¥æ–‡ = responseContent, é”™è¯¯ = ex.Message });
                throw ex;
            }
        }

    }
}

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Common/TaskEnum/TaskStatusEnum.cs

@@ -138,12 +138,6 @@
    public enum TaskInStatusEnum
    {
        /// <summary>
        /// æ–°å»ºå…¥åº“任务
        /// </summary>
        [Description("新建入库任务")]
        InNew = 200,

        /// <summary>
        /// è¾“送线入库执行中
        /// </summary>
        [Description("输送线入库执行中")]
@@ -154,12 +148,6 @@
        /// </summary>
        [Description("输送线输送完成")]
        Line_InFinish = 220,

        /// <summary>
        /// å †åž›æœºå¾…执行
        /// </summary>
        [Description("堆垛机待执行")]
        SC_Execute = 225,

        /// <summary>
        /// å †åž›æœºå…¥åº“执行中
@@ -230,18 +218,7 @@
        [Description("输送线输送完成")]
        Line_OutFinish = 125,

        ///// <summary>
        ///// AGV出库执行中
        ///// </summary>
        //[Description("AGV出库执行中")]
        //AGV_OutExecuting = 130,

        ///// <summary>
        ///// AGV出库完成
        ///// </summary>
        //[Description("AGV搬运完成")]
        //AGV_OutFinish = 135,

        
        /// <summary>
        /// å‡ºåº“任务完成
        /// </summary>

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_DTO/TaskInfo/WMSTaskDTO.cs

@@ -8,10 +8,11 @@
{
    public class WMSTaskDTO
    {
        public int Id { get; set; }
        /// <summary>
        /// WMS任务主键
        /// </summary>
        public int Id { get; set; }
        public int TaskId { get; set; }

        /// <summary>
        /// ä»»åŠ¡å·
@@ -34,14 +35,6 @@
        public int TaskType { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public string CurrentAddress { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string NextAddress { get; set; }
        /// <summary>
        /// ä»»åŠ¡çŠ¶æ€
        /// </summary>
        public int TaskStatus { get; set; }
@@ -61,24 +54,53 @@
        /// </summary>
        public int Grade { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public int WarehouseId { get; set; }

        /// <summary>
        /// ä»»åŠ¡ç»„
        /// 
        /// </summary>
        public string GroupId { get; set; }

        /// <summary>
        /// ä»»åŠ¡ç‰©æ–™é•¿åº¦
        /// </summary>
        public int TaskLength { get; set; }

        public string AGVArea { get; set; }

        public int PalletType { get; set; }
        /// <summary>
        /// AGV任务号
        /// 
        /// </summary>
        public string AGVTaskNum { get; set; }
        public int PalletType { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public string CurrentAddress { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string NextAddress { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public int Depth { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string OrderNo { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public int SourceKey { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public DateTime Dispatchertime { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public int MaterialType { get; set; }

        public string MEStaskId { get; set; }
        public string MESbusinessId { get; set; }
        public string MESsubPalletCode { get; set; }

    }
}

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoService/ITaskService.cs

@@ -131,7 +131,7 @@
        /// <param name="deviceNo">设备编号</param>
        /// <param name="outStationCodes">当前地址</param>
        /// <returns>返回任务实体对象集合，可能为null</returns>
        List<Dt_Task> QueryStackerCraneOutTasks(string deviceNo, List<string> outStationCodes);
        List<Dt_Task> QueryStackerCraneOutTasks(string deviceNo);


        /// <summary>
@@ -217,5 +217,26 @@
        /// <param name="taskNum">任务号</param>
        /// <returns>返回处理结果</returns>
        WebResponseContent RollbackTaskStatusToLast(int taskNum);

        //查找2楼入库任务
        Dt_Task GetTaskIninfo(string Pallat);

        WebResponseContent UpdateTaskIninfo(string Pallat,int TaskNo);

        /// <summary>
        /// åˆ¤æ–­æµ…货位是否有任务
        /// </summary>
        /// <param name="deviceNo"></param>
        /// <param name="SourceAddress"></param>
        /// <returns></returns>
        Dt_Task QueryStationIsOccupiedOutTasks(string deviceNo, string LocaAddress);

        /// <summary>
        /// æ ¹æ®æ·±åº“位向wms申请判断浅库位是否有货，是否需要进行移库操作
        /// </summary>
        /// <param name="palletCode">托盘号</param>
        /// <param name="sourceAddress">起始地址</param>
        /// <returns></returns>
        Dt_Task RequestWMSTaskMovelibrary(Dt_Task _Task);
    }
}

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Model/Models/TaskInfo/Dt_Task.cs

@@ -160,5 +160,37 @@
        [ExporterHeader(DisplayName = "备注")]
        [SugarColumn(IsNullable = true, Length = 255, ColumnDescription = "备注")]
        public string Remark { get; set; }

        /// <summary>
        /// æ·±åº¦
        /// </summary>
        [ImporterHeader(Name = "深度")]
        [ExporterHeader(DisplayName = "深度")]
        [SugarColumn(IsNullable = false, ColumnDescription = "深度")]
        public int Depth { get; set; }

        /// <summary>
        /// MES任务id
        /// </summary>
        [ImporterHeader(Name = "MES任务id")]
        [ExporterHeader(DisplayName = "MES任务id")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "MES任务id")]
        public string MEStaskId { get; set; }

        /// <summary>
        /// MES业务流id
        /// </summary>
        [ImporterHeader(Name = "MES业务流id")]
        [ExporterHeader(DisplayName = "MES业务流id")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "MES业务流id")]
        public string MESbusinessId { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ç¼–号子托
        /// </summary>
        [ImporterHeader(Name = "托盘编号子托")]
        [ExporterHeader(DisplayName = "托盘编号子托")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "托盘编号子托")]
        public string MESsubPalletCode { get; set; }
    }
}

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Server/Program.cs

@@ -47,7 +47,7 @@
builder.Services.AddAllOptionRegister();//读取配置文件
builder.Services.AddMemoryCacheSetup();//缓存
builder.Services.AddSqlsugarSetup();//SqlSugar å¯åŠ¨æœåŠ¡
builder.Services.AddHostedService<SeedDataHostedService>();//初始化数据库
//builder.Services.AddHostedService<SeedDataHostedService>();//初始化数据库

builder.Services.AddDbSetup();//Db å¯åŠ¨æœåŠ¡


 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Server/appsettings.json

@@ -1,42 +1,46 @@
{
    "urls": "http://*:9291", //web服务端口，如果用IIS部署，把这个去掉
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
        }
    },
    "dics": "deviceType,devicePlcType,jobAssembly,jobClassName,deviceStatus,taskType,taskState,inOutType",
    "AllowedHosts": "*",
    "ConnectionStringsEncryption": false,
    "MainDB": "DB_WIDESEA", //当前项目的主库，所对应的连接字符串的Enabled必须为true 
    //1.MySql
    //2.SqlServer
    //3.Sqlite
    //4.Oracle
    //5.PostgreSQL
    "DBType": "SqlServer",
    //连接字符串
    "ConnectionString": "Data Source=.;Initial Catalog=WIDESEAWCS_SYLK;User ID=sa;Password=sa123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
    //跨域
    "Cors": {
        "PolicyName": "CorsIpAccess", //策略名称
        "EnableAllIPs": true, //当为true时，开放所有IP均可访问。
        // æ”¯æŒå¤šä¸ªåŸŸåç«¯å£ï¼Œæ³¨æ„ç«¯å£å·åŽä¸è¦å¸¦/斜杆：比如localhost:8000/，是错的
        // æ³¨æ„ï¼Œhttp://127.0.0.1:1818 å’Œ http://localhost:1818 æ˜¯ä¸ä¸€æ ·çš„
        "IPs": "http://127.0.0.1:8080,http://localhost:8080"
    },
    "ApiLogIgnore": "", //记录日志时，忽略的API名称，多个用逗号分隔，配置的不记录到数据库中
    "ApiName": "WIDESEAWCS",
    "ExpMinutes": 120,
    "QuartzJobAutoStart": false,
    "DBSeedEnable": false,
    "QuartzDBSeedEnable": false,
    "LogDeubgEnable": false, //是否记录调试日志
    "PrintSql": false, //打印SQL语句
    "LogAOPEnable": false, //是否记录AOP日志
    "WebSocketEnable": true, //是否开启WebSocket服务
    "WebSocketPort": 9296, //WebSocket服务端口
    "WMSApiAddress": "http://127.0.0.1:9290", //"http://127.0.0.1:9283",正式环境地址
    "FeedBackWMSTaskCompleted": "http://127.0.0.1:9290/api/Task/InboundTaskCompleted"
  "urls": "http://*:9291", //web服务端口，如果用IIS部署，把这个去掉
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "dics": "deviceType,devicePlcType,jobAssembly,jobClassName,deviceStatus,taskType,taskState,inOutType",

  "urlWMSMovelibraryTask": "http://10.50.11.65:8098/api/Task/IsRelocations", //请求移库接口
  "urlTaskCompleted": "http://10.50.11.65:8098/api/Task/TaskCompleted", //任务反馈

  "AllowedHosts": "*",
  "ConnectionStringsEncryption": false,
  "MainDB": "DB_WIDESEA", //当前项目的主库，所对应的连接字符串的Enabled必须为true 
  //1.MySql
  //2.SqlServer
  //3.Sqlite
  //4.Oracle
  //5.PostgreSQL
  "DBType": "SqlServer",
  //连接字符串
  "ConnectionString": "Data Source=.;Initial Catalog=SY_WIDESEAWCS_SYLK;User ID=sa;Password=123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  //跨域
  "Cors": {
    "PolicyName": "CorsIpAccess", //策略名称
    "EnableAllIPs": true, //当为true时，开放所有IP均可访问。
    // æ”¯æŒå¤šä¸ªåŸŸåç«¯å£ï¼Œæ³¨æ„ç«¯å£å·åŽä¸è¦å¸¦/斜杆：比如localhost:8000/，是错的
    // æ³¨æ„ï¼Œhttp://127.0.0.1:1818 å’Œ http://localhost:1818 æ˜¯ä¸ä¸€æ ·çš„
    "IPs": "http://127.0.0.1:8080,http://localhost:8080"
  },
  "ApiLogIgnore": "", //记录日志时，忽略的API名称，多个用逗号分隔，配置的不记录到数据库中
  "ApiName": "WIDESEAWCS",
  "ExpMinutes": 120,
  "QuartzJobAutoStart": false,
  "DBSeedEnable": false,
  "QuartzDBSeedEnable": false,
  "LogDeubgEnable": false, //是否记录调试日志
  "PrintSql": false, //打印SQL语句
  "LogAOPEnable": false, //是否记录AOP日志
  "WebSocketEnable": true, //是否开启WebSocket服务
  "WebSocketPort": 9296, //WebSocket服务端口
  "WMSApiAddress": "http://127.0.0.1:9290", //"http://127.0.0.1:9283",正式环境地址
  "FeedBackWMSTaskCompleted": "http://127.0.0.1:9290/api/Task/InboundTaskCompleted"
}

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/TaskService.cs

@@ -20,6 +20,8 @@
using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
using SqlSugar;
using System.Diagnostics.CodeAnalysis;
using System.Threading.Tasks;
using WIDESEA_Comm.Http;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
@@ -44,6 +46,7 @@
        private readonly IRepository<Dt_Router> _routerRepository;
        private readonly IRepository<Dt_StationManger> _stationMangerRepository;
        private readonly IMapper _mapper;
        

        private Dictionary<string, OrderByType> _taskOrderBy = new()
            {
@@ -56,6 +59,9 @@
        public List<int> TaskInboundTypes => typeof(TaskInboundTypeEnum).GetEnumIndexList();

        public List<int> TaskOutboundTypes => typeof(TaskOutboundTypeEnum).GetEnumIndexList();

        public string urlWMSMovelibraryTask = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSMovelibraryTask"];
        public string urlTaskCompleted = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlTaskCompleted"];

        /// <summary>
        /// ä»“储层(数据库访问)
@@ -96,33 +102,8 @@
                        continue;
                    }
                    Dt_Task task = _mapper.Map<Dt_Task>(item);
                    task.TaskState = item.TaskStatus;


                    Dt_Router? router;

                    TaskTypeGroup taskTypeGroup = item.TaskType.GetTaskTypeGroup();
                    Dt_StationManger? stationManger;
                    if (taskTypeGroup == TaskTypeGroup.InboundGroup)
                    {
                        task.Creater = "WMS";
                        task.TaskState = (int)TaskStatusEnum.New.ObjToInt();
                        stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.CurrentAddress || x.StationDeviceCode == item.SourceAddress);
                        task.DeviceCode = stationManger.StationDeviceCode;
                    }
                    else
                    {
                        stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.NextAddress || x.StationDeviceCode == item.NextAddress);
                        task.DeviceCode = stationManger.StationDeviceCode;
                        List<Dt_Router> routers = routersAll.Where(x => x.InOutType == RouterInOutType.Out && (item.NextAddress == x.StartPosi || item.RoadWay == x.StartPosi /*|| item.RoadWay == x.ChildPosiDeviceCode || item.RoadWay == x.ChildPosi*/)).ToList();
                        router = routers.FirstOrDefault();
                        if (router == null)
                        {
                            return WebResponseContent.Instance.Error($"未找到路由配置信息");
                        }
                        //task.NextAddress = stationManger.StackerCraneStationCode;
                        task.TargetAddress = router.NextPosi;
                        //出库
                    }
                    tasks.Add(task);
                }
                BaseDal.AddData(tasks);
@@ -215,7 +196,7 @@
        /// <returns></returns>
        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);
            return BaseDal.QueryFirst(x => (TaskInboundTypes.Contains(x.TaskType) &&  TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish) && x.CurrentAddress == currentAddress, TaskOrderBy);
        }

        /// <summary>
@@ -248,12 +229,10 @@
        /// <returns></returns>
        public Dt_Task? QuertStackerCraneTask(string deviceNo, TaskTypeGroup? taskTypeGroup = null)
        {
            if (taskTypeGroup == null)
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && x.TaskState == (int)TaskInStatusEnum.InNew, TaskOrderBy);
            if (taskTypeGroup.Value == TaskTypeGroup.InboundGroup)
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.SC_Execute, TaskOrderBy);
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskInboundTypes.Contains(x.TaskType), TaskOrderBy);
            if (taskTypeGroup.Value == TaskTypeGroup.OutbondGroup)
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.SC_Execute, TaskOrderBy);
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskOutboundTypes.Contains(x.TaskType) , TaskOrderBy);
            return null;
        }
        /// <summary>
@@ -313,10 +292,7 @@
        /// <returns>返回任务实体对象，可能为null</returns>
        public Dt_Task QueryStackerCraneInTask(string deviceNo, string currentAddress = "")
        {
            if (string.IsNullOrEmpty(currentAddress))
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && x.TaskState == (int)TaskStatusEnum.SC_Execute, TaskOrderBy);
            else
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskStatusEnum.SC_Execute && x.CurrentAddress == currentAddress, TaskOrderBy);
            return BaseDal.QueryFirst(x => x.Roadway == deviceNo && x.TaskType== (int)TaskInboundTypeEnum.Inbound && x.TaskState == (int)TaskInStatusEnum.Line_InFinish, TaskOrderBy);
        }

        /// <summary>
@@ -327,10 +303,7 @@
        /// <returns>返回任务实体对象，可能为null</returns>
        public Dt_Task QueryStackerCraneOutTask(string deviceNo, string currentAddress = "")
        {
            if (string.IsNullOrEmpty(currentAddress))
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew, TaskOrderBy);
            else
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew && x.CurrentAddress == currentAddress, TaskOrderBy);
            return BaseDal.QueryFirst(x => x.Roadway == deviceNo && x.TaskType==(int)TaskOutboundTypeEnum.Outbound && x.TaskState == (int)TaskOutStatusEnum.OutNew, TaskOrderBy);
        }

        /// <summary>
@@ -339,9 +312,9 @@
        /// <param name="deviceNo">设备编号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns>返回任务实体对象集合，可能为null</returns>
        public List<Dt_Task> QueryStackerCraneOutTasks(string deviceNo, List<string> outStationCodes)
        public List<Dt_Task> QueryStackerCraneOutTasks(string deviceNo)
        {
            return BaseDal.QueryData(x => x.Roadway == deviceNo && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew && outStationCodes.Contains(x.CurrentAddress), TaskOrderBy);
            return BaseDal.QueryData(x => x.Roadway == deviceNo && x.TaskType == (int)TaskOutboundTypeEnum.Outbound && x.TaskState == (int)TaskOutStatusEnum.OutNew, TaskOrderBy);
        }

        /// <summary>
@@ -528,51 +501,50 @@
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");

                if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup && task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound && task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                {
                    List<Dt_Router> routers = _routerService.QueryNextRoutes(task.NextAddress, task.TargetAddress);
                    if (!routers.Any()) return WebResponseContent.Instance.Error($"未找到设备路由信息");
                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskOutStatusEnum>();
                    task.TaskState = nextStatus;
                    task.CurrentAddress = task.NextAddress;
                    task.NextAddress = routers.FirstOrDefault().ChildPosi;
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    /*List<Dt_Router> routers = _routerService.QueryNextRoutes(task.NextAddress, task.TargetAddress);
                    if (!routers.Any()) return WebResponseContent.Instance.Error($"未找到设备路由信息");*/
                    task.TaskState = (int)TaskOutStatusEnum.OutFinish;
                    BaseDal.UpdateData(task);

                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机出库完成");

                    content = HttpHelperh.Get<WebResponseContent>($"{urlTaskCompleted}?TaskNum={task.TaskNum}&HowWorks=2");

                    task.ModifyDate = DateTime.Now;
                    BaseDal.DeleteData(task);
                    // _task_HtyService.AddTaskHty(task); éœ€è¦æ·»åŠ ç§»å…¥åŽ†å²
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"出库完成");
                    //todo åŒæ­¥åˆ°WMS
                    WMSTaskDTO WMStask = _mapper.Map<WMSTaskDTO>(task);
                    HttpHelper.PostAsync(WMSInterfaceAddress.UpdateTaskStatus, WMStask.ToJson(), headers: new Dictionary<string, string>());

                    //暂不考虑多个出库口
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup && task.TaskState == (int)TaskInStatusEnum.SC_InExecuting)
                else if (task.TaskType == (int)TaskInboundTypeEnum.Inbound && task.TaskState == (int)TaskInStatusEnum.SC_InExecuting)
                {
                    //todo 
                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskInStatusEnum>();
                    task.TaskState = nextStatus;
                    task.TaskState = (int)TaskInStatusEnum.InFinish;
                    BaseDal.UpdateData(task);

                    content = HttpHelperh.Get<WebResponseContent>($"{urlTaskCompleted}?TaskNum={task.TaskNum}&HowWorks=2");

                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.UpdateData(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机入库完成");
                    BaseDal.DeleteData(task);
                    // _task_HtyService.AddTaskHty(task); éœ€è¦æ·»åŠ ç§»å…¥åŽ†å²
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"入库完成");

                    WMSTaskDTO WMStask = _mapper.Map<WMSTaskDTO>(task);

                    HttpHelper.PostAsync(WMSInterfaceAddress.UpdateTaskStatus, WMStask.ToJson(), headers: new Dictionary<string, string>());
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup && task.TaskState == (int)TaskRelocationStatusEnum.SC_RelocationFinish)
                else if (task.TaskType == (int)TaskRelocationTypeEnum.Relocation)
                {
                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskRelocationStatusEnum>();
                    task.CurrentAddress = task.NextAddress;
                    task.NextAddress = string.Empty;
                    task.TaskState = nextStatus;
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    task.TaskState = (int)TaskRelocationStatusEnum.SC_RelocationFinish;
                    BaseDal.UpdateData(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机移库完成");
                    WMSTaskDTO WMStask = _mapper.Map<WMSTaskDTO>(task);
                    //todo è°ƒç”¨WMS移库完成
                    HttpHelper.PostAsync(WMSInterfaceAddress.UpdateTaskStatus, WMStask.ToJson(), headers: new Dictionary<string, string>());

                    content = HttpHelperh.Get<WebResponseContent>($"{urlTaskCompleted}?TaskNum={task.TaskNum}&HowWorks=2");

                  
                    task.ModifyDate = DateTime.Now;
                    BaseDal.DeleteData(task);
                   // _task_HtyService.AddTaskHty(task); éœ€è¦æ·»åŠ ç§»å…¥åŽ†å²
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"移库完成");
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OtherGroup)
                {
@@ -586,7 +558,7 @@
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error($"任务完成异常,任务号:【{taskNum}】");
                content = WebResponseContent.Instance.Error($"任务完成异常,任务号:【{taskNum}】，原因：{ex.Message}");
            }
            return content;
        }
@@ -618,10 +590,6 @@
                    if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                    {
                        task.TaskState = (int)TaskOutStatusEnum.OutNew;
                    }
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                    {
                        task.TaskState = (int)TaskInStatusEnum.InNew;
                    }
                    //todo
                }
@@ -681,5 +649,70 @@
            }
            return content;
        }

        public Dt_Task GetTaskIninfo(string Pallat)
        {
            return BaseDal.QueryFirst(x => x.PalletCode == Pallat);
        }

        public WebResponseContent UpdateTaskIninfo(string Pallat, int TaskNo)
        {
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == TaskNo && x.PalletCode == Pallat);
                if (task != null)
                {
                    task.TaskState = (int)TaskInStatusEnum.Line_InFinish;
                    BaseDal.UpdateData(task);
                    return WebResponseContent.Instance.OK();
                }

                return WebResponseContent.Instance.Error();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error();
                throw;
            }
        }


        public Dt_Task QueryStationIsOccupiedOutTasks(string deviceNo, string LocaAddress)
        {
            return BaseDal.QueryFirst(x => x.Roadway == deviceNo && (x.SourceAddress == LocaAddress || x.TargetAddress == LocaAddress), TaskOrderBy);
        }

        /// <summary>
        /// æ ¹æ®æ·±åº“位向wms申请判断浅库位是否有货，是否需要进行移库操作
        /// </summary>
        /// <param name="palletCode">托盘号</param>
        /// <param name="sourceAddress">起始地址</param>
        /// <returns></returns>
        public Dt_Task RequestWMSTaskMovelibrary(Dt_Task _Task)
        {
            WebResponseContent content = new WebResponseContent();

            content = HttpHelperh.Get<WebResponseContent>($"{urlWMSMovelibraryTask}?TaskNum={_Task.TaskNum}");
            Dt_Task task = new Dt_Task();
            if (content.Status)
            {
                if (content.Data != null)
                {
                    task = JsonConvert.DeserializeObject<Dt_Task>(content.Data.ToString());
                    if (task.TaskNum != _Task.TaskNum)
                    {
                        task.Grade = 3;
                        BaseDal.AddData(task);
                        return task;
                    }
                    else
                    {
                        return _Task;
                    }
                }
            }
            return null;

        }
    }
}

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ConveyorLineJob/CommonConveyorLineJob.cs

@@ -1,6 +1,7 @@
using Microsoft.AspNetCore.Routing;
using Quartz;
using SqlSugar;
using System.Threading.Tasks;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.Helper;
using WIDESEAWCS_Common.TaskEnum;
@@ -30,6 +31,7 @@
        private readonly IRouterService _routerService;
        private readonly IRepository<Dt_Task> _taskRepository;
        private readonly IRepository<Dt_StationManger> _stationMangerRepository;


        public CommonConveyorLineJob(ICacheService cacheService, ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRepository<Dt_StationManger> stationMangerRepository, IRepository<Dt_Task> taskRepository, IRouterRepository routerRepository, IRouterService routerService)
        {
@@ -94,25 +96,17 @@
                                }
                            }
                            //出入库站台
                            if (item.StationType == StationTypeEnum.StationType_InboundAndOutbound.ObjToInt())
                            else if (item.StationType == StationTypeEnum.StationType_InboundAndOutbound.ObjToInt())
                            {
                                //入库生成堆垛机入库任务
                                if (conveyorLineSignalRead.STB && conveyorLineStatus.Online && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && !ACK)
                                {
                                    if (conveyorLineInfoRead.TaskNo == 0 && !string.IsNullOrEmpty(conveyorLineInfoRead.Barcode))//采购入库
                                    if (conveyorLineInfoRead.TaskNo != 0 && !string.IsNullOrEmpty(conveyorLineInfoRead.Barcode))//采购入库
                                    {
                                        WebResponseContent content = _taskService.RequestWMSTaskSimple(conveyorLineInfoRead.Barcode, item.StationCode);
                                        if (content.Status)
                                        WebResponseContent contentweb = _taskService.UpdateTaskIninfo(conveyorLineInfoRead.Barcode, conveyorLineInfoRead.TaskNo);
                                        if (contentweb.Status)
                                        {
                                            Dt_Task task = _taskRepository.QueryFirst(x => x.PalletCode == conveyorLineInfoRead.Barcode && x.CurrentAddress == item.StationCode && x.DeviceCode == device.DeviceCode && x.TaskState == (int)TaskStatusEnum.New.ObjToInt());
                                            if (task != null)
                                            {
                                                _taskService.UpdateTask(task, TaskStatusEnum.SC_Execute, deviceCode: item.StackerCraneCode, sourceAddress: item.StackerCraneStationCode);
                                                device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);
                                                device.SetValue(W_ConveyorLineDB.TaskNo, 1111, item.StationCode);
                                                //_taskService.UpdateTask(task, TaskStatusEnum.RGV_NEW);
                                            }

                                            device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);
                                        }
                                    }

@@ -174,15 +168,19 @@

                            }
                            //入库站台
                            if (item.StationType == StationTypeEnum.StationType_OnlyInbound.ObjToInt())
                            else if (item.StationType == StationTypeEnum.StationType_OnlyInbound.ObjToInt())
                            {
                                if (conveyorLineSignalRead.STB && conveyorLineStatus.Online && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && !ACK)
                                {
                                    if (conveyorLineInfoRead.TaskNo == 0 && !string.IsNullOrEmpty(conveyorLineInfoRead.Barcode))//采购入库
                                    {
                                        device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.EndPos, 2020, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.TaskNo, 1111, item.StationCode);
                                        Dt_Task dt_Ta = _taskService.GetTaskIninfo(conveyorLineInfoRead.Barcode);
                                        if(dt_Ta != null)
                                        {
                                            device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);
                                            device.SetValue(W_ConveyorLineDB.EndPos, dt_Ta.SourceAddress, item.StationCode);
                                            device.SetValue(W_ConveyorLineDB.TaskNo, dt_Ta.TaskNum, item.StationCode);
                                        }
                                    }


@@ -198,7 +196,7 @@
                    }
        
                
                catch (Exception)
                catch (Exception ex)
                {
                }


 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/StackerCraneJob/CommonStackerCraneJob.cs

@@ -117,75 +117,13 @@
                {
                    var TaskNum = speStackerCrane.GetValue<StackerCraneDBName, Int32>(StackerCraneDBName.CurrentTaskNum);
                    WriteInfo("堆垛机任务完成", $"任务号:{TaskNum}");
                    StackerCraneTaskCompleted(e.TaskNum, speStackerCrane.DeviceCode);
                    _taskService.StackCraneTaskCompleted(e.TaskNum);
                    WriteInfo("堆垛机任务完成反馈任务号", $"任务信息,任务号:{e.TaskNum}");
                    speStackerCrane.SetValue(StackerCraneDBName.WorkType, 5);
                }
            }
        }
        public WebResponseContent StackerCraneTaskCompleted(int taskNum, string deviceCode)
        {
            try
            {
                Dt_Task task = _taskRepository.QueryFirst(x => x.TaskNum == taskNum);
                if (task != null)
                {
                    if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                    {
                        Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.StackerCraneStationCode == task.NextAddress && x.StackerCraneCode == deviceCode);
                        if (stationManger == null)
                        {
                            //_taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"输送线出库站点未配置,{task.NextAddress}");
                            _taskService.UpdateTaskExceptionMessage(taskNum, $"输送线出库站点未配置,{task.NextAddress}");
                            WriteError(deviceCode, $"输送线出库站点未配置,{task.NextAddress}");
                            return WebResponseContent.Instance.Error($"输送线出库站点未配置,{task.NextAddress}");
                        }
                        Dt_Router router = _routerRepository.QueryFirst(x => x.InOutType == task.TaskType && x.StartPosi == stationManger.StationCode);
                        if (router == null)
                        {
                            router = _routerRepository.QueryFirst(x => x.ChildPosi == deviceCode && x.ChildPosiDeviceCode == stationManger.StationDeviceCode && x.NextPosi == stationManger.StationCode && x.InOutType == task.TaskType && x.IsEnd);
                            if (router != null && router.IsEnd)
                            {
                                _taskService.TaskCompleted(taskNum);
                            }
                            else
                            {
                                _taskService.UpdateTaskExceptionMessage(taskNum, $"未找到路由信息,{task.NextAddress}");
                                WriteError(deviceCode, $"未找到路由信息,{task.NextAddress}");
                                return WebResponseContent.Instance.Error($"未找到路由信息,{task.NextAddress}");
                            }
                        }
                        if (task.TargetAddress.Contains("1030") || task.TargetAddress.Contains("1026")) //自动一线
                        {
                            _taskService.UpdateTask(task, TaskStatusEnum.Line_Execute, deviceCode: stationManger.StationDeviceCode, currentAddress: router.NextPosi);
                        }

                    }
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup || task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
                    {
                        _taskService.TaskCompleted(taskNum);
                    }
                    else
                    {
                        WriteError(deviceCode, $"未找到该任务类型回调WMS任务完成接口,{task.TaskType}");
                        _taskService.UpdateTaskExceptionMessage(taskNum, $"未找到该任务类型回调WMS任务完成接口,{task.TaskType}");
                    }

                }
                else
                {
                    WriteError(deviceCode, $"未找到任务信息,任务号:{taskNum}");
                    return WebResponseContent.Instance.Error($"未找到任务信息,任务号:{taskNum}");
                }

                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                WriteError(deviceCode, $"任务完成错误", ex);
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        
        /// <summary>
        /// èŽ·å–任务
        /// </summary>
@@ -195,51 +133,69 @@
        {
            Dt_Task? task;

            //堆垛机执行中
            if (_taskRepository.QueryFirst(x => x.DeviceCode == commonStackerCrane.DeviceCode && x.TaskState == TaskStatusEnum.SC_Executing.ObjToInt()) != null)
            {
                return null;
            }
            if (commonStackerCrane.LastTaskType.GetValueOrDefault().GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)

            task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);         //获取入库任务
            if(task != null)
            {
                task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);
                if (task == null)
                {
                    task = _taskService.QueryStackerCraneOutTask(commonStackerCrane.DeviceCode);
                }
                return task;    //如果有任务则直接下发给堆垛机
            }
            else
            {
                task = _taskService.QueryStackerCraneOutTask(commonStackerCrane.DeviceCode);
                if (task == null)
                //进行获取堆垛机出库任务
                List<Dt_Task> tasks = _taskService.QueryStackerCraneOutTasks(commonStackerCrane.DeviceCode);
                foreach (var item in tasks)
                {
                    task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);
                }
            }


            if (task != null && task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
            {
                if (OutTaskStationIsOccupied(task) != null || true)
                {
                    return task;
                }
                else
                {
                    List<string> otherOutStaionCodes = _routerService.QueryNextRoutes(commonStackerCrane.DeviceCode, task.NextAddress).Select(x => x.ChildPosi).ToList();
                    List<Dt_Task> tasks = _taskService.QueryStackerCraneOutTasks(commonStackerCrane.DeviceCode, otherOutStaionCodes);
                    foreach (var item in tasks)
                    if (OutTaskStationIsOccupied(item) != null)
                    {
                        if (OutTaskStationIsOccupied(task) != null)
                        if(item.Roadway== "SC01")
                        {
                            return task;
                            if (item.Depth == 1) return item;
                            //调取WMS接口进行判断是否需要进行移库
                            Dt_Task dt_Task= OutTaskMovelibrary(item);
                            if (dt_Task != null) return dt_Task;

                        }
                        else
                        {
                            return item;
                        }
                    }
                    task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);
                }
            }

            return task;
        }

        private Dt_Task? OutTaskMovelibrary([NotNull] Dt_Task task)
        {
            string[] targetCodes = task.SourceAddress.Split("-");
            if (targetCodes[1] == "001")
            {
                targetCodes[1] = "002";

            }
            else if (targetCodes[1] == "004")
            {
                targetCodes[1] = "003";
            }
            targetCodes[4] = "01";
            string SourceAddress = string.Join("-", targetCodes); //组装浅库位地址
            Dt_Task? tasks = _taskService.QueryStationIsOccupiedOutTasks(task.Roadway, SourceAddress); //找浅库位是否有任务
            if (tasks != null) return tasks;
        //向wms申请判断浅库位是否有货，是否需要进行移库
            Dt_Task? taskst = _taskService.RequestWMSTaskMovelibrary(task);
            if (taskst != null) return taskst;
            return null;
        }




        /// <summary>
        /// å‡ºåº“任务判断出库站台是否被占用
        /// </summary>
@@ -285,10 +241,13 @@
            stackerCraneTaskCommand.TaskNum = task.TaskNum;
            stackerCraneTaskCommand.WorkType = 1;
            stackerCraneTaskCommand.TrayType = 1;
            if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)//判断是否是入库任务
            if (task.TaskType==(int)TaskInboundTypeEnum.Inbound)//判断是否是入库任务
            {

                string[] startCodes = task.SourceAddress.Split("-");
                Dt_StationManger dt_StationManger=_stationMangerRepository.QueryFirst(x=>x.StationCode==task.SourceAddress);


                string[] startCodes = dt_StationManger.StackerCraneStationCode.Split("-");
                if (startCodes.Length == 3)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(startCodes[0]);
@@ -312,21 +271,22 @@
                }

            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
            else if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
            {
                Dt_StationManger dt_StationManger = _stationMangerRepository.QueryFirst(x => x.StationCode == task.TargetAddress);

                string[] targetCodes = task.TargetAddress.Split("-");
                string[] targetCodes = dt_StationManger.StackerCraneStationCode.Split("-");

                stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
                stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
                stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);

                string[] sourceCodes = task.SourceAddress.Split("-");
                if (sourceCodes.Length == 3)
                if (sourceCodes.Length == 5)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
                }
                else
                {
@@ -336,14 +296,14 @@
                }

            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
            else if (task.TaskType == (int)TaskRelocationTypeEnum.Relocation)   //判断移库任务
            {
                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 3)
                if (targetCodes.Length == 5)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[3]);
                }
                else
                {
@@ -352,11 +312,11 @@
                    return null;
                }
                string[] sourceCodes = task.CurrentAddress.Split("-");
                if (sourceCodes.Length == 3)
                if (sourceCodes.Length == 5)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
                }
                else
                {

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSClient/config/buttons.js

@@ -101,45 +101,10 @@
    }
},
{
    name: "成 å“(空托) å‡º åº“",
    name: "手 åŠ¨ å‡º åº“",
    icon: 'el-icon-plus',
    value: 'HandOutbound',
    type: 'warning',
    onClick: function () {

    }
},
{
    name: "原 æ æ–™ å‡º åº“",
    icon: 'el-icon-plus',
    value: 'HandOutboundycl',
    type: 'success',
    onClick: function () {

    }
},
{
    name: "物料状态更改",
    icon: 'el-icon-plus',
    value: 'Materialstaticupdate',
    type: 'success',
    onClick: function () {

    }
},{
    name: "生产时间更改",
    icon: 'el-icon-plus',
    value: 'HanGeneratetime',
    type: 'success',
    onClick: function () {

    }
},
{
    name: "人 å·¥ æ‰‹ åŠ¨ å‡º åº“",
    icon: 'el-icon-plus',
    value: 'HandOutboundt',
    type: 'danger',
    onClick: function () {

    }

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSClient/src/extension/stock/stockInfo.js

@@ -1,14 +1,12 @@

//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码
import gridBody from "./extend/HandOutbound.vue"
import modelBody from "./extend/HandMaterials.vue"
import griForter from "./extend/HandGenerateti.vue"
let extension = {
  components: {
    //查询界面扩展组件
    gridHeader: modelBody,
    gridHeader: '',
    gridBody: gridBody,
    gridFooter: griForter,
    gridFooter: '',
    //新建、编辑弹出框扩展组件
    modelHeader: '',
    modelBody: '',
@@ -26,161 +24,17 @@
          if (rows.length == 0) {
            return this.$error("请选择数据!");
          } else {
            var ids = rows.map(x => {
              return  x.palletCode
            })
            var param = {
              DelKeys: ids, //taskNo
              Extra: true
            }
            this.http
            .post("api/Task/ManualOutbound", param, "数据处理中...")
            .then((x) => {
              if (x.status) {
                this.$Message.success('成功.');
                this.refresh();
              } else {
                return this.$error(x.message);
            var data = rows.map(x => {
              return {
                palletCode: x.palletCode,
                otherField: x.otherField // æ›¿æ¢ä¸ºæ‚¨éœ€è¦çš„另一个字段
              }
            });
          }
        }
      }

      var btnHandOutboundycl = this.buttons.find(x => x.value == "HandOutboundycl");
      if (btnHandOutboundycl != null) {
        btnHandOutboundycl.onClick = () => {
          let rows = this.$refs.table.getSelected();
          if (rows.length == 0) {
            return this.$error("请选择数据!");
          } else {
            var ids = rows.map(x => {
              return  x.palletCode
            })
            this.$refs.gridBody.open(ids);
            this.$refs.gridBody.open(data);
            this.refresh();
          }
        }
      }

      var btnMaterialstaticupdate = this.buttons.find(x => x.value == "Materialstaticupdate");
      if (btnMaterialstaticupdate != null) {
        btnMaterialstaticupdate.onClick = () => {
          let rows = this.$refs.table.getSelected();
          if (rows.length == 0) {
            return this.$error("请选择数据!");
          } else {
            var ids = rows.map(x => {
              return  x.id
            })
            this.$refs.gridHeader.open(ids);
            this.refresh();
          }
        }
      }

      var btnHanGeneratetime = this.buttons.find(x => x.value == "HanGeneratetime");
      if (btnHanGeneratetime != null) {
        btnHanGeneratetime.onClick = () => {
          let rows = this.$refs.table.getSelected();
          if (rows.length == 0) {
            return this.$error("请选择数据!");
          } else {
            var ids = rows.map(x => {
              return  x.id
            })
            this.$refs.gridFooter.open(ids);
            this.refresh();
          }
        }
      }


      var btnHandOutbound2 = this.buttons.find(x => x.value == "HandOutboundt");
      if (btnHandOutbound2 != null) {
        btnHandOutbound2.onClick = () => {
          let rows = this.$refs.table.getSelected();
          if (rows.length == 0) {
            return this.$error("请选择数据!");
          } else {
            var ids = rows.map(x => {
              return  x.palletCode
            })
            var param = {
              DelKeys: ids, //taskNo
              Extra: true
            }
            this.http
              .post("api/Task/ManualOutboundDeleteinventory", param, "数据处理中...")
              .then((x) => {
                if (x.status) {
                  this.$Message.success('成功.');
                  this.refresh();
                } else {
                  return this.$error(x.message);
                }
              });
          }
        }
      }


      this.columns.forEach(x => {
        if (x.field == "wlstatus") {
          //根据不同的值，定义不同的样式(如：文字颜色)
          x.render = (h, { row, column, index }) => {
            if(row.wlstatus=='1'){
              return (
                <span style="display:block;background-color:#67c23a;width:65px;text-align:center;color:white;border:1px solid #67c23a;border-radius:5px;">
                  åˆæ ¼
                </span>
              );
            }else if(row.wlstatus=='0'){
              return (
                <tr style="display:block;background-color:#f4b400;width:65px;text-align:center;color:white;border:1px solid #f4b400;border-radius:5px;">
                  å¾…检
                </tr>
              );
            }else if(row.wlstatus=='2'){
              return (
                <tr style="display:block;background-color:#f56c6c;width:65px;text-align:center;color:white;border:1px solid #f56c6c;border-radius:5px;">
                  ä¸åˆæ ¼
                </tr>
              );
            }else if(row.wlstatus=='3'){
              return (
                <tr style="display:block;background-color:#909399;width:65px;text-align:center;color:white;border:1px solid #909399;border-radius:5px;">
                  ç©ºæ‰˜
                </tr>
              );
            }else if(row.wlstatus=='4'){
              return (
                <tr style="display:block;background-color:#f87eb9;width:65px;text-align:center;color:white;border:1px solid #f87eb9;border-radius:5px;">
                  é€€è´§
                </tr>
              );
            }else if(row.wlstatus=='5'){
              return (
                <tr style="display:block;background-color:#409eff;width:65px;text-align:center;color:white;border:1px solid #409eff;border-radius:5px;">
                  è¿”å·¥
                </tr>
              );
            }else if(row.wlstatus=='6'){
              return (
                <tr style="display:block;background-color:#9b59b6;width:65px;text-align:center;color:white;border:1px solid #9b59b6;border-radius:5px;">
                  ç‰¹é‡‡
                </tr>
              );
            }else{
              return (
                <span style="display:block;background-color:#909399;width:55px;text-align:center;color:white;border:1px solid #e9e9eb;border-radius:5px;">
                  æœªçŸ¥
                </span>
              );
            }
          }
        }
      });
    },
    onInited() {
      //框架初始化配置后

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSClient/src/views/basic/locationInfo.vue

@@ -41,7 +41,7 @@
    const searchFormOptions = ref([
      [
        { title: "货位编号", field: "locationCode" ,type: "like",},
        { title: "巷道编号", field: "roadwayNo" },
        { title: "巷道编号", field: "roadwayNo" ,type: "like",},
        { title: "货位类型", field: "locationType",type: "select",dataKey: "locationTypeEnum",data: []},
        { title: "禁用状态", field: "enableStatus" ,type: "select",dataKey: "enableStatusEnum",data: []},
      ],

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/read.lock

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/v17/HierarchyCache.v1.txt

Binary files differ

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_BasicService/Dt_ApiInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,30 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Emit;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class Dt_ApiInfoService : ServiceBase<Dt_ApiInfo, IRepository<Dt_ApiInfo>>, IDt_ApiInfoService
    {

        public Dt_ApiInfoService(IRepository<Dt_ApiInfo> BaseDal) : base(BaseDal)
        {
        }

        public IRepository<Dt_ApiInfo> Repository => BaseDal;


        public Dt_ApiInfo GetConfigsByAPIInfo(string ApiCode, string ApiInterfaceAddress)
        {
            return BaseDal.QueryFirst(x => x.ApiCode == ApiCode && x.ApiInterfaceAddress== ApiInterfaceAddress);
        }
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_BasicService/StationMangerService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEAWCS_BasicInfoService
{
    public class StationMangerService : ServiceBase<Dt_StationManger, IRepository<Dt_StationManger>>, IStationMangerService
    {
        public StationMangerService(IRepository<Dt_StationManger> BaseDal) : base(BaseDal)
        {
        }

        public Dt_StationManger QueryPlatform(string StationCode)
        {
            return BaseDal.QueryFirst(x=>x.StationCode == StationCode);
        }
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_Common/StockEnum/StockStatusEmun.cs

@@ -29,6 +29,9 @@
        [Description("入库完成")]
        å…¥åº“完成 = 6,

        [Description("已入库")]
        å·²å…¥åº“ = 6,

        [Description("出库锁定")]
        å‡ºåº“锁定 = 7,


 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_Common/TaskEnum/TaskStatusEnum.cs

@@ -8,108 +8,141 @@
namespace WIDESEA_Common.TaskEnum
{
    /// <summary>
    /// ä»»åŠ¡çŠ¶æ€
    /// å‡ºåº“任务状态
    /// </summary>
    public enum TaskStatusEnum
    public enum TaskOutStatusEnum
    {
        /// <summary>
        /// æ–°å»ºä»»åŠ¡
        /// æ–°å»ºå‡ºåº“任务
        /// </summary>
        [Description("新建")]
        New = 100,
        [Description("新建出库任务")]
        OutNew = 100,

        /// <summary>
        /// å †åž›æœºå¾…执行
        /// å †åž›æœºå‡ºåº“执行中
        /// </summary>
        [Description("堆垛机待执行")]
        SC_Execute = 200,
        [Description("堆垛机出库执行中")]
        SC_OutExecuting = 110,

        /// <summary>
        /// å †åž›æœºæ‰§è¡Œä¸­
        /// å †åž›æœºå‡ºåº“完成
        /// </summary>
        [Description("堆垛机执行中")]
        SC_Executing = 210,
        [Description("堆垛机出库完成")]
        SC_OutFinish = 115,

        /// <summary>
        /// å †åž›æœºå®Œæˆ
        /// è¾“送线出库执行中
        /// </summary>
        [Description("堆垛机完成")]
        SC_Finish = 220,
        [Description("输送线出库执行中")]
        Line_OutExecuting = 120,

        /// <summary>
        /// è¾“送线待执行
        /// è¾“送线出库完成
        /// </summary>
        [Description("输送线待执行")]
        Line_Execute = 400,
        [Description("输送线输送完成")]
        Line_OutFinish = 125,


        /// <summary>
        /// è¾“送线执行中
        /// å‡ºåº“任务完成
        /// </summary>
        [Description("输送线执行中")]
        Line_Executing = 410,
        [Description("出库任务完成")]
        OutFinish = 190,

        /// <summary>
        /// è¾“送线完成
        /// å‡ºåº“任务挂起
        /// </summary>
        [Description("输送线完成")]
        Line_Finish = 420,
        [Description("出库任务挂起")]
        OutPending = 197,

        /// <summary>
        /// AGV待执行
        /// å‡ºåº“任务取消
        /// </summary>
        [Description("AGV待执行")]
        AGV_Execute = 300,
        [Description("出库任务取消")]
        OutCancel = 198,

        /// <summary>
        /// AGV执行中
        /// å‡ºåº“任务异常
        /// </summary>
        [Description("AGV执行中")]
        AGV_Executing = 310,
        [Description("出库任务异常")]
        OutException = 199,
    }

    public enum TaskInStatusEnum
    {
        /// <summary>
        /// è¾“送线入库执行中
        /// </summary>
        [Description("输送线入库执行中")]
        Line_InExecuting = 215,

        /// <summary>
        /// AGV待继续执行
        /// è¾“送线入库完成
        /// </summary>
        [Description("AGV待继续执行")]
        AGV_WaitToExecute = 320,
        /// <summary>
        /// AGV放货中
        /// </summary>
        [Description("AGV放货中")]
        AGV_Puting = 325,
        [Description("输送线输送完成")]
        Line_InFinish = 220,

        /// <summary>
        /// AGV完成
        /// å †åž›æœºå…¥åº“执行中
        /// </summary>
        [Description("AGV完成")]
        AGV_Finish = 330,
        [Description("堆垛机入库执行中")]
        SC_InExecuting = 230,

        /// <summary>
        /// ä»»åŠ¡å®Œæˆ
        /// å †åž›æœºå…¥åº“完成
        /// </summary>
        [Description("任务完成")]
        Finish = 900,
        [Description("堆垛机入库完成")]
        SC_InFinish = 235,

        /// <summary>
        /// ä»»åŠ¡æŒ‚èµ·
        /// å…¥åº“任务完成
        /// </summary>
        [Description("任务挂起")]
        Pending = 970,
        [Description("入库任务完成")]
        InFinish = 290,

        /// <summary>
        /// ä»»åŠ¡å–消
        /// å…¥åº“任务挂起
        /// </summary>
        [Description("任务取消")]
        Cancel = 980,
        [Description("入库任务挂起")]
        InPending = 297,

        /// <summary>
        /// ä»»åŠ¡å¼‚常
        /// å…¥åº“任务取消
        /// </summary>
        [Description("任务异常")]
        Exception = 990,
        [Description("入库任务取消")]
        InCancel = 298,

        /// <summary>
        /// æå‡æœºæ‰§è¡Œä¸­
        /// å…¥åº“任务异常
        /// </summary>
        [Description("提升机执行中")]
        HT_Executing = 110,
        [Description("入库任务异常")]
        InException = 299,
    }

    public enum TaskRelocationStatusEnum
    {
        /// <summary>
        /// æ–°å»ºç§»åº“任务
        /// </summary>
        [Description("新建移库任务")]
        RelocationNew = 400,

        /// <summary>
        /// å †åž›æœºç§»åº“执行中
        /// </summary>
        [Description("堆垛机移库执行中")]
        SC_RelocationExecuting = 410,

        /// <summary>
        /// å †åž›æœºç§»åº“完成
        /// </summary>
        [Description("堆垛机移库完成")]
        SC_RelocationFinish = 420,

        /// <summary>
        /// ç§»åº“完成
        /// </summary>
        [Description("移库完成")]
        RelocationFinish = 430,
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_Common/TaskEnum/TaskTypeEnum.cs

@@ -7,100 +7,6 @@

namespace WIDESEA_Common.TaskEnum
{
    public enum TaskTypeEnum
    {
        /// <summary>
        /// é¢†æ–™å‡ºåº“
        /// </summary>
        [Description("领料出库")]
        Outbound = 100,
        /// <summary>
        /// ç›˜ç‚¹å‡ºåº“
        /// </summary>
        [Description("盘点出库")]
        OutInventory = 110,
        /// <summary>
        /// åˆ†æ‹£å‡ºåº“
        /// </summary>
        [Description("分拣出库")]
        OutPick = 120,
        /// <summary>
        /// è´¨æ£€å‡ºåº“
        /// </summary>
        [Description("质检出库")]
        OutQuality = 130,

        /// <summary>
        /// ç©ºç®±å‡ºåº“
        /// </summary>
        [Description("空箱出库")]
        OutEmpty = 140,

        /// <summary>
        /// MES出库
        /// </summary>
        [Description("MES出库")]
        MesOutbound = 200,

        /// <summary>
        /// MES手动出库
        /// </summary>
        [Description("MES手动出库")]
        MesHandOutbound = 210,

        /// <summary>
        /// MES手动拣选出库
        /// </summary>
        [Description("MES手动拣选出库")]
        MesHandPickOutbound = 220,

        /// <summary>
        /// é‡‡è´­å…¥åº“
        /// </summary>
        [Description("采购入库")]
        Inbound = 510,
        /// <summary>
        /// ç›˜ç‚¹å…¥åº“
        /// </summary>
        [Description("盘点入库")]
        InInventory = 520,
        /// <summary>
        /// åˆ†æ‹£å…¥åº“
        /// </summary>
        [Description("分拣入库")]
        InPick = 530,
        /// <summary>
        /// è´¨æ£€å…¥åº“
        /// </summary>
        [Description("质检入库")]
        InQuality = 540,

        /// <summary>
        /// ç”Ÿäº§é€€æ–™
        /// </summary>
        [Description("生产退料")]
        ProductionReturn = 550,

        /// <summary>
        /// MES退料
        /// </summary>
        [Description("MES退料")]
        MesMatReturn = 560,

        /// <summary>
        /// ç©ºç®±å…¥åº“
        /// </summary>
        [Description("空箱入库")]
        InEmpty = 600,

        /// <summary>
        /// å··é“内移库
        /// </summary>
        [Description("巷道内移库")]
        Relocation = 900
        
    }

    public enum TaskTypeGroup
    {
        /// <summary>
@@ -123,4 +29,65 @@
        /// </summary>
        OtherGroup
    }




    public enum TaskInboundTypeEnum
    {
        /// <summary>
        /// å…¥åº“
        /// </summary>
        [Description("入库")]
        Inbound = 200,
        /// <summary>
        /// ç›˜ç‚¹å…¥åº“
        /// </summary>
        [Description("盘点入库")]
        InInventory = 201,
        /// <summary>
        /// åˆ†æ‹£å…¥åº“
        /// </summary>
        [Description("分拣入库")]
        InPick = 202,
        /// <summary>
        /// è´¨æ£€å…¥åº“
        /// </summary>
        [Description("质检入库")]
        InQuality = 203
    }

    public enum TaskOutboundTypeEnum
    {
        /// <summary>
        /// å‡ºåº“
        /// </summary>
        [Description("出库")]
        Outbound = 100,
        /// <summary>
        /// ç›˜ç‚¹å‡ºåº“
        /// </summary>
        [Description("盘点出库")]
        OutInventory = 101,
        /// <summary>
        /// åˆ†æ‹£å‡ºåº“
        /// </summary>
        [Description("分拣出库")]
        OutPick = 102,
        /// <summary>
        /// è´¨æ£€å‡ºåº“
        /// </summary>
        [Description("质检出库")]
        OutQuality = 103,
    }

    public enum TaskRelocationTypeEnum
    {
        /// <summary>
        /// åº“内移库
        /// </summary>
        [Description("库内移库")]
        Relocation = 300,
    }

}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_Core/Const/ConfigConst.cs

@@ -12,14 +12,11 @@
    public class CateGoryConst
    {
        /// <summary>
        /// é‚®ç®±åŸºç¡€
        /// IP接口地址
        /// </summary>
        public const string CONFIG_SYS_BaseExmail = "Sys_BaseExmail";
        public const string CONFIG_WCS_IPAddress = "WCS_IPAddress";

        /// <summary>
        /// é‚®ç®±é…ç½®
        /// </summary>
        public const string CONFIG_SYS_RegExmail = "Sys_RegExmail";
        public const string CONFIG_MES_IPAddress = "MES_IPAddress";
    }

    /// <summary>
@@ -28,37 +25,15 @@
    public class SysConfigConst
    {
        /// <summary>
        ///  é‚®ç®±SMTP地址
        /// ä¸‹å‘WCS任务
        /// </summary>
        public const string SMTP_Server = "smtpServer";
        public const string WCSReceiveTask = "ReceiveTask";

        /// <summary>
        ///  é‚®ç®±SMTP端口
        /// ç§»åº“任务完成
        /// </summary>
        public const string SMTP_Port = "smtpPort";
        public const string MESTransferCompletionFeedback = "MESTransferCompletionFeedback";
        public const string MESTaskFeedback = "MESTaskFeedback";

        /// <summary>
        ///  é‚®ç®±SMTP账号
        /// </summary>
        public const string SMTP_User = "smtpUser";

        /// <summary>
        ///  é‚®ç®±SMTP密码
        /// </summary>
        public const string SMTP_Pass = "smtpPass";

        /// <summary>
        ///  é‚®ç®±æ ‡é¢˜
        /// </summary>
        public const string SMTP_Title = "smtpTitle";

        /// <summary>
        ///  é‚®ç®±å†…容标题
        /// </summary>
        public const string SMTP_ContentTitle = "smtpContentTitle";
        /// <summary>
        ///  é‚®ç®±å†…容标题
        /// </summary>
        public const string SMTP_RegUser = "smtpRegUser";
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_DTO/Task/WMSTaskDTO.cs

@@ -100,5 +100,9 @@
        /// </summary>
        public int MaterialType { get; set; }

        public string MEStaskId { get; set; }
        public string MESbusinessId { get; set; }
        public string MESsubPalletCode { get; set; }

    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_DTO/ToMes/RelocationTaskMes.cs

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

namespace WIDESEA_DTO.ToMes
{
    /// <summary>
    /// ç§»åº“类上传MES通知
    /// </summary>
    public class TransferRequest
    {
        /// <summary>
        /// ä¸šåŠ¡ID
        /// </summary>
        public string businessId { get; set; }

        /// <summary>
        /// ä»»åŠ¡ID
        /// </summary>
        public string TaskId { get; set; }

        /// <summary>
        /// åŽŸè´§ä½
        /// </summary>
        public string SourceLocationCode { get; set; }

        /// <summary>
        /// ç›®æ ‡è´§ä½ç¼–码
        /// </summary>
        public string LocationCode { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ç¼–码
        /// </summary>
        public string PalletCode { get; set; }

        /// <summary>
        /// çŠ¶æ€: FINISH-已完成, TRANSFER-转移中
        /// </summary>
        public string Status { get; set; }

        /// <summary>
        /// å¼‚常状态: NORMAL-正常，ERROR-异常
        /// </summary>
        public string ErrorStatus { get; set; }

        /// <summary>
        /// å¼‚常信息
        /// </summary>
        public string ErrorInfo { get; set; }
    }

    /// <summary>
    /// æŽ¥æ”¶åé¦ˆå‚数通知
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ApiResponse<T>
    {
        /// <summary>
        /// çŠ¶æ€ç : 1-成功, å…¶ä»–-失败
        /// </summary>
        public int Code { get; set; }

        /// <summary>
        /// æ¶ˆæ¯
        /// </summary>
        public string Message { get; set; }

        /// <summary>
        /// æ•°æ®
        /// </summary>
        public T Data { get; set; }

        /// <summary>
        /// æ˜¯å¦æˆåŠŸ
        /// </summary>
        public bool Success { get; set; }

        /// <summary>
        /// æˆåŠŸå“åº”
        /// </summary>
        public static ApiResponse<T> SuccessResponse(string message = "操作成功！", T data = default)
        {
            return new ApiResponse<T>
            {
                Code = 1,
                Message = message,
                Data = data,
                Success = true
            };
        }

        /// <summary>
        /// å¤±è´¥å“åº”
        /// </summary>
        public static ApiResponse<T> ErrorResponse(string message = "操作失败！", int code = 0)
        {
            return new ApiResponse<T>
            {
                Code = code,
                Message = message,
                Data = default,
                Success = false
            };
        }
    }

    
    public class TaskNotification
    {
        /// <summary>
        /// ä»»åŠ¡ID
        /// </summary>
        public string TaskId { get; set; }

        /// <summary>
        /// ä¸šåŠ¡ID
        /// </summary>
        public string BusinessId { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ç¼–码
        /// </summary>
        public string PalletCode { get; set; }

        /// <summary>
        /// å­æ‰˜ç›˜ç¼–码
        /// </summary>
        public string SubPalletCode { get; set; }

        /// <summary>
        /// è´§ä½ç¼–码
        /// </summary>
        public string LocationCode { get; set; }

        /// <summary>
        /// å¼‚常状态：NORMAL-正常，ERROR-异常
        /// </summary>
        public string ErrorStatus { get; set; }

        /// <summary>
        /// å¼‚常信息
        /// </summary>
        public string ErrorInfo { get; set; }
    }

    
    public class InOutboundTaskReceived
    {
        /// <summary>
        /// è¯·æ±‚时间
        /// </summary>
        public string ReqTime { get; set; }

        /// <summary>
        /// ä»»åŠ¡ID
        /// </summary>
        public string TaskId { get; set; }

        /// <summary>
        /// ä¸šåŠ¡ID
        /// </summary>
        public string BusinessId { get; set; }

        /// <summary>
        /// èŠ‚点编码
        /// </summary>
        public string NodeCode { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ç¼–码列表
        /// </summary>
        public List<string> PalletCodeList { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ä¿¡æ¯åˆ—表
        /// </summary>
        public List<PalletInfo> palletInfoList { get; set; }
    }

    /// <summary>
    /// æ‰˜ç›˜ä¿¡æ¯
    /// </summary>
    public class PalletInfo
    {
        /// <summary>
        /// è´§ä½ç¼–码
        /// </summary>
        public string locationCode { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ç¼–码
        /// </summary>
        public string palletCode { get; set; }

        /// <summary>
        /// å­æ‰˜ç›˜ç¼–码
        /// </summary>
        public string subPalletCode { get; set; }
    }

    public class LocationInfoDto
    {
        /// <summary>
        /// åŒºåŸŸç¼–码
        /// </summary>
        public string areaCode { get; set; }

        /// <summary>
        /// è´§ä½ç¼–码
        /// </summary>
        public string locationCode { get; set; }

        /// <summary>
        /// è´§ä½åç§°
        /// </summary>
        public string locationName { get; set; }

        /// <summary>
        /// å··é“编号
        /// </summary>
        public string roadwayNo { get; set; }

        /// <summary>
        /// è¡Œ
        /// </summary>
        public int row { get; set; }

        /// <summary>
        /// åˆ—
        /// </summary>
        public int column { get; set; }

        /// <summary>
        /// å±‚
        /// </summary>
        public int layer { get; set; }

        /// <summary>
        /// æ·±åº¦
        /// </summary>
        public double depth { get; set; }

        /// <summary>
        /// è´§ä½ç±»åž‹
        /// </summary>
        public int locationType { get; set; }

        /// <summary>
        /// è´§ä½çŠ¶æ€
        /// </summary>
        public int locationStatus { get; set; }

        /// <summary>
        /// å¯ç”¨çŠ¶æ€
        /// </summary>
        public bool enableStatus { get; set; }

        /// <summary>
        /// å¤‡æ³¨
        /// </summary>
        public string remark { get; set; }
    }

}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_IBasicService/IDt_ApiInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,23 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_DTO.Basic;
using WIDESEA_Model.Models;

namespace WIDESEA_IBasicService
{
    public interface IDt_ApiInfoService : IService<Dt_ApiInfo>
    {
        /// <summary>
        /// æ ¹æ®ç±»åˆ«,api键获取到对应的接口数据
        /// </summary>
        /// <param name="category">类别</param>
        /// <returns></returns>
        Dt_ApiInfo GetConfigsByAPIInfo(string ApiCode, string ApiInterfaceAddress);
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_IBasicService/IStationMangerService.cs

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

namespace WIDESEA_IBasicService
{
    public interface IStationMangerService : IService<Dt_StationManger>
    {
        Dt_StationManger QueryPlatform(string StationCode);
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_IRecordService/ILocationStatusChangeRecordService.cs

@@ -14,5 +14,7 @@
    public interface ILocationStatusChangeRecordService : IService<Dt_LocationStatusChangeRecord>
    {
        IRepository<Dt_LocationStatusChangeRecord> Repository { get; }

        void AddLocationStatusChangeRecord(Dt_LocationInfo locationInfo, int lastStatus, int changeType, string orderNo, int? taskNum);
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_ISystemService/ISys_LogService.cs

@@ -10,5 +10,6 @@
{
    public interface ISys_LogService : IService<Sys_Log>
    {

    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_ITaskInfoService/ITaskService.cs

@@ -30,16 +30,66 @@
using WIDESEA_DTO;
using WIDESEA_DTO.Stock;
using WIDESEA_DTO.Task;
using WIDESEA_DTO.ToMes;
using WIDESEA_Model.Models;

namespace WIDESEA_ITaskInfoService
{
    public interface ITaskService : IService<Dt_Task>
    {
        int GetTaskNum(string sequenceName);

        IRepository<Dt_Task> Repository { get; }

        WebResponseContent DeviceRequestInboundTaskSimple(string stationCode, string palletCode);

        WebResponseContent InboundTaskCompleted(int taskNum);
        /// <summary>
        /// å‡ºåº“
        /// </summary>
        /// <param name="outbound"></param>
        /// <returns></returns>
        ApiResponse<object> sendExTask(InOutboundTaskReceived outbound);

        /// <summary>
        /// å…¥åº“
        /// </summary>
        /// <param name="outbound"></param>
        /// <returns></returns>
        ApiResponse<object> sendEnTask(InOutboundTaskReceived outbound);


        /// <summary>
        /// ä»»åŠ¡å®ŒæˆæŽ¥å£
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        WebResponseContent TaskCompleted(int taskNum);

        /// <summary>
        /// ç§»åº“申请判断接口
        /// </summary>
        /// <param name="TaskNum"></param>
        /// <returns></returns>
        WebResponseContent IsRelocations(int TaskNum);




        /// <summary>
        /// åˆ›å»ºè´§ä½
        /// </summary>
        /// <param name="locationInfo"></param>
        /// <returns></returns>
        ApiResponse<object> createLocation(List<LocationInfoDto> locationInfo);
        /// <summary>
        /// åˆ é™¤è´§ä½
        /// </summary>
        ApiResponse<object> deleteLocation(List<string> locationCode);
        /// <summary>
        /// ä¿®æ”¹è´§ä½
        /// </summary>
        /// <param name="locationInfo"></param>
        /// <returns></returns>
        ApiResponse<object> updateLocation(LocationInfoDto locationInfo);
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_Model/Models/Basic/Dt_ApiInfo.cs

@@ -20,7 +20,7 @@
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true, ColumnDescription = "主键")]
        public int Id { get; set; }
        /// <summary>
        /// æŽ¥å£ç¼–号
        /// æŽ¥å£ç±»åž‹
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "接口编号")]
        public string ApiCode { get; set; }
@@ -29,6 +29,12 @@
        /// </summary>
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "接口名称")]
        public string ApiName { get; set; }

        /// <summary>
        /// æŽ¥å£é”®
        /// </summary>
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "接口键")]
        public string ApiInterfaceAddress { get; set; }
        /// <summary>
        /// æŽ¥å£åœ°å€
        /// </summary>

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_Model/Models/Basic/Dt_StationManger.cs

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

namespace WIDESEA_Model.Models
{
    [SugarTable(nameof(Dt_StationManger), "站台表")]
    public class Dt_StationManger : BaseEntity
    {
        /// <summary>
        /// ä¸»é”®
        /// </summary>
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true, ColumnDescription = "主键")]
        public int Id { get; set; }

        /// <summary>
        /// ç«™å°ç¼–号
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "站台编号")]
        public string StationCode { get; set; }

        /// <summary>
        /// ç«™å°åç§°
        /// </summary>
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "站台名称")]
        public string StationName { get; set; }

        /// <summary>
        /// ç«™å°ç±»åž‹ <br/>
        /// 1：只入 <br/>
        /// 2：只出 <br/>
        /// 3：可入可出
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "站台类型")]
        public int StationType {  get; set; }

        /// <summary>
        /// å¯¹åº”堆垛机排-列-层
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "对应堆垛机排-列-层")]
        public string StackerCraneStationCode { get; set; }

        /// <summary>
        /// ç«™å°è®¾å¤‡ç¼–号
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "站台设备编号")]
        public string StationDeviceCode { get; set; }

        /// <summary>
        /// å †åž›æœºç¼–号
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "堆垛机编号")]
        public string StackerCraneCode { get; set; }

        /// <summary>
        /// AGV站台编号
        /// </summary>
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "AGV站台编号")]
        public string? AGVStationCode { get; set; }
        /// <summary>
        /// ç«™å°æ˜¯å¦å¯ç”¨ <br/>
        /// 0：可用 <br/>
        /// 1：占用 <br/>
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "站台是否可用")]
        public int IsOccupied { get; set; }
        /// <summary>
        /// å¤‡æ³¨
        /// </summary>
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "备注")]
        public string Remark { get; set; }
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_Model/Models/Stock/Dt_StockInfo.cs

@@ -1,9 +1,11 @@
using SqlSugar;
using Magicodes.ExporterAndImporter.Core;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using WIDESEA_Core.DB.Models;

namespace WIDESEA_Model.Models
@@ -57,6 +59,14 @@
        public string Remark { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ç¼–号子托
        /// </summary>
        [ImporterHeader(Name = "托盘编号子托")]
        [ExporterHeader(DisplayName = "托盘编号子托")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "托盘编号子托")]
        public string MESsubPalletCode { get; set; }

        /// <summary>
        /// åº“存明细
        /// </summary>
        [Navigate(NavigateType.OneToMany, nameof(Dt_StockInfoDetail.StockId), nameof(Id))]

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_Model/Models/TaskInfo/Dt_Task.cs

@@ -142,5 +142,39 @@
        [ExporterHeader(DisplayName = "备注")]
        [SugarColumn(IsNullable = true, Length = 255, ColumnDescription = "备注")]
        public string Remark { get; set; }

        /// <summary>
        /// æ·±åº¦
        /// </summary>
        [ImporterHeader(Name = "深度")]
        [ExporterHeader(DisplayName = "深度")]
        [SugarColumn(IsNullable = false, ColumnDescription = "深度")]
        public int Depth { get; set; }



        /// <summary>
        /// MES任务id
        /// </summary>
        [ImporterHeader(Name = "MES任务id")]
        [ExporterHeader(DisplayName = "MES任务id")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "MES任务id")]
        public string MEStaskId { get; set; }

        /// <summary>
        /// MES业务流id
        /// </summary>
        [ImporterHeader(Name = "MES业务流id")]
        [ExporterHeader(DisplayName = "MES业务流id")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "MES业务流id")]
        public string MESbusinessId { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ç¼–号子托
        /// </summary>
        [ImporterHeader(Name = "托盘编号子托")]
        [ExporterHeader(DisplayName = "托盘编号子托")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "托盘编号子托")]
        public string MESsubPalletCode { get; set; }
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_RecordService/LocationStatusChangeRecordService.cs

@@ -12,5 +12,22 @@
        }

        public IRepository<Dt_LocationStatusChangeRecord> Repository => BaseDal;

        public void AddLocationStatusChangeRecord(Dt_LocationInfo locationInfo, int lastStatus, int changeType, string? orderNo, int? taskNum)
        {
            Dt_LocationStatusChangeRecord locationStatusChangeRecord = new Dt_LocationStatusChangeRecord()
            {
                AfterStatus = locationInfo.LocationStatus,
                BeforeStatus = lastStatus,
                ChangeType = changeType,
                LocationCode = locationInfo.LocationCode,
                LocationId = locationInfo.Id,
                TaskNum = taskNum,
                Creater = "WMS",
                OrderNo = orderNo ?? ""
            };

            BaseDal.AddData(locationStatusChangeRecord);
        }
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_TaskInfoService/PartialTaskService_Inbound.cs

@@ -18,6 +18,11 @@
using WIDESEA_Common.TaskEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.CommonEnum;
using WIDESEA_DTO.ToMes;
using System.Diagnostics;
using WIDESEA_Common.OtherEnum;
using WIDESEA_Core.Const;

namespace WIDESEA_TaskInfoService
{
@@ -40,10 +45,12 @@
                    PushTasksToWCS(new List<Dt_Task> { task });
                    return WebResponseContent.Instance.OK($"该托盘已生成任务", _mapper.Map<WMSTaskDTO>(task));
                }
                if (Repository.QueryFirst(x => x.SourceAddress == stationCode && x.TaskStatus == TaskStatusEnum.New.ObjToInt()) != null)
               /* if (Repository.QueryFirst(x => x.SourceAddress == stationCode && x.TaskStatus == OutTaskStatusEnum.New.ObjToInt()) != null)
                {
                    return WebResponseContent.Instance.Error($"该站点已有未执行的任务");
                }
                }*/


                //Dt_StockInfo stockInfo = _stockRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();

                //if (stockInfo == null)
@@ -63,7 +70,7 @@
                Dt_Warehouse warehouse = _warehouseRepository.QueryFirst(x => x.WarehouseCode == roadwayInfo.RoadwayNo);
                if (warehouse == null)
                {
                    return WebResponseContent.Instance.Error("未找到改仓库");
                    return WebResponseContent.Instance.Error("未找到该仓库");
                }
                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayInfo.RoadwayNo, warehouse.WarehouseId, "");//
                if (locationInfo == null)
@@ -90,8 +97,8 @@
                    Roadway = "1",
                    SourceAddress = "",
                    TargetAddress = locationInfo.LocationCode,
                    TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
                    TaskType = TaskInboundTypeEnum.Inbound.ObjToInt(),
                    TaskStatus = TaskInStatusEnum.Line_InExecuting.ObjToInt(),
                    WarehouseId = warehouse.WarehouseId,
                    //PalletType = GetPalletType(warehouse, palletCode),//GetPalletType(warehouse, palletCode)
                    Creater = "WCS",
@@ -118,5 +125,123 @@
            }
        }


        /// <summary>
        /// åˆ›å»ºå…¥åº“任务
        /// </summary>
        /// <param name="inboundTask"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public ApiResponse<object> sendEnTask(InOutboundTaskReceived inboundTask)
        {
            WebResponseContent webResponseContent = new WebResponseContent();

            try
            {
                List<Dt_Task> AddtaskList = new List<Dt_Task>();
                List<Dt_LocationInfo> Adddt_Locations = new List<Dt_LocationInfo>();
                List<Dt_StockInfo> Adddtstockt = new List<Dt_StockInfo>();

                if (inboundTask.palletInfoList.Count > 0)
                {
                    List<Dt_Task> taskData = BaseDal.QueryData();

                    Dt_StationManger dt_Station = _stationMangerService.QueryPlatform(inboundTask.NodeCode);
                    if (dt_Station == null) return MESresponse($"未找到站台信息,站台编号：{inboundTask.NodeCode}", false);

                    foreach (PalletInfo palletInfo in inboundTask.palletInfoList)
                    {
                        Dt_LocationInfo location = null;
                        if (palletInfo.locationCode == null || palletInfo.locationCode == "")
                        {
                            Dt_Warehouse warehouse = _warehouseRepository.QueryFirst(x => x.WarehouseCode == dt_Station.StackerCraneCode);

                            location = _basicService.LocationInfoService.AssignLocation(dt_Station.StackerCraneCode, warehouse.WarehouseId, "");//获取到新库位
                        }
                        else
                        {
                            location = _locationInfoRepository.QueryFirst(x => x.LocationCode == palletInfo.locationCode);
                        }
                        if (location == null) return MESresponse($"未找到货位信息,条码：{palletInfo.palletCode}", false);
                        if (location.LocationStatus != (int)LocationStatusEnum.Free) return MESresponse($"托盘条码：{palletInfo.palletCode}，查找到的货位：{location.LocationCode},不为空货位！", false);


                        //创建组盘信息
                        var dt_Stock = new Dt_StockInfo
                        {
                            PalletCode = palletInfo.palletCode,
                            PalletType = 1,
                            LocationCode = location.LocationCode,
                            StockStatus = (int)StockStatusEmun.组盘暂存,
                            Creater = "WMS",
                            CreateDate = DateTime.Now,
                            MESsubPalletCode = palletInfo.palletCode,
                        };
                        location.LocationStatus = (int)LocationStatusEnum.InStockLock;

                        //生成移动任务
                        Dt_Task dt_Task = new()
                        {
                            PalletCode = palletInfo.palletCode,
                            TaskNum = GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                            Roadway = location.RoadwayNo,
                            TaskType = TaskInboundTypeEnum.Inbound.ObjToInt(),
                            TaskStatus = TaskInStatusEnum.Line_InExecuting.ObjToInt(),
                            SourceAddress = dt_Station.StationCode,
                            TargetAddress = location.LocationCode,
                            CurrentAddress = dt_Station.StationCode,
                            NextAddress = location.LocationCode,
                            Grade = 1,
                            Creater = "MES",
                            Depth = location.Depth,
                            CreateDate = DateTime.Now,
                            MEStaskId = inboundTask.TaskId,
                            MESbusinessId = inboundTask.BusinessId,
                            MESsubPalletCode = palletInfo.subPalletCode
                        };
                        Adddtstockt.Add(dt_Stock);
                        Adddt_Locations.Add(location);
                        AddtaskList.Add(dt_Task);
                    }
                    if (Adddtstockt.Count > 0 && Adddt_Locations.Count > 0 && AddtaskList.Count > 0)
                    {
                        _unitOfWorkManage.BeginTran();


                        _stockRepository.AddData(Adddtstockt);
                        _locationInfoRepository.UpdateData(Adddt_Locations);
                        BaseDal.AddData(AddtaskList);

                        var respon = PushTasksToWCS(AddtaskList, "");
                        if (respon.Status)
                        {
                            _unitOfWorkManage.CommitTran();  //提交事务
                            return MESresponse("", true);
                        }
                        else
                        {
                            _unitOfWorkManage.RollbackTran();  //回滚事务
                            return MESresponse($"下发出库失败，原因：{respon.Message}！", false);
                        }

                    }
                    else
                    {
                        return MESresponse("任务生成失败！", false);
                    }

                }
                else
                {
                    return MESresponse("接收到MES托盘编码列表无数据！", false);
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();  //回滚事务
                return MESresponse($"下发出库失败，原因：{ex.Message}！", false);
                throw;
            }
        }
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_TaskInfoService/PartialTaskService_Outbound.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,135 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.Enums;
using WIDESEA_Core;
using WIDESEA_Model.Models;
using WIDESEA_Core.Helper;
using Microsoft.Extensions.Logging;
using MailKit.Search;
using System.Reflection.Metadata;
using static WIDESEA_ITaskInfoService.ITaskService;
using WIDESEA_Common;
using WIDESEA_Core.LogHelper;
using WIDESEA_DTO.Task;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.LocationEnum;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using WIDESEA_Common.OtherEnum;
using WIDESEA_Core.Const;
using WIDESEA_DTO.ToMes;
using System.DirectoryServices.Protocols;
using System.Net;

namespace WIDESEA_TaskInfoService
{
    public partial class TaskService
    {
        
        /// <summary>
        /// ä¸‹å‘出库接口
        /// </summary>
        /// <param name="outbound"></param>
        /// <returns></returns>
        public ApiResponse<object> sendExTask(InOutboundTaskReceived outbound)
        {

            List<Dt_StockInfo> Adddtstockt = new List<Dt_StockInfo>();
            List<Dt_LocationInfo> Addlocations = new List<Dt_LocationInfo>();
            List<Dt_Task> Addtaskdt = new List<Dt_Task>();

            if ( outbound != null )
            {
                if (outbound.PalletCodeList.Count > 0)
                {
                    List<Dt_StockInfo> StockData = _stockRepository.QueryData();
                    List<Dt_LocationInfo> LocationData=_locationInfoRepository.QueryData(x=>x.LocationStatus== (int)LocationStatusEnum.InStock);
                    List<Dt_Task> taskData = BaseDal.QueryData();

                    foreach (string Pallet in outbound.PalletCodeList)
                    {
                        //查找库存信息
                        Dt_StockInfo dt_StockInfo = StockData.Find(x => x.PalletCode == Pallet);
                        if(dt_StockInfo==null) return MESresponse($"接收到的托盘条码：{Pallet},未在系统中找到库存信息！", false);
                        //查找库位信息
                        Dt_LocationInfo locationInfo = LocationData.Find(x => x.LocationCode == dt_StockInfo.LocationCode);
                        if (locationInfo == null) return MESresponse($"接收到的托盘条码：{Pallet},未在系统中找到库位信息！", false);

                        //判断当前货位是否有任务
                        Dt_Task _Task = taskData.Find(x => x.SourceAddress == locationInfo.LocationCode || x.TargetAddress == locationInfo.LocationCode);
                        if (_Task != null) return MESresponse($"接收到的托盘条码：{Pallet},当前托盘对应的库位信息已有任务，不可出库！", false);

                        dt_StockInfo.StockStatus = (int)StockStatusEmun.出库锁定;
                        locationInfo.LocationStatus = (int)LocationStatusEnum.InStockLock;

                        //生成移动任务
                        Dt_Task dt_Task = new()
                        {
                            PalletCode = dt_StockInfo.PalletCode,
                            TaskNum = GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                            Roadway = locationInfo.RoadwayNo,
                            TaskType = TaskOutboundTypeEnum.Outbound.ObjToInt(),
                            TaskStatus = TaskOutStatusEnum.OutNew.ObjToInt(),
                            SourceAddress = locationInfo.LocationCode,
                            TargetAddress = outbound.NodeCode,
                            CurrentAddress = locationInfo.LocationCode,
                            NextAddress = outbound.NodeCode,
                            Grade = 1,
                            Creater = "MES",
                            Depth = locationInfo.Depth,
                            CreateDate = DateTime.Now,
                            MEStaskId= outbound.TaskId,
                            MESbusinessId= outbound.BusinessId,
                            MESsubPalletCode= dt_StockInfo.MESsubPalletCode
                        };
                        Adddtstockt.Add(dt_StockInfo);
                        Addlocations.Add(locationInfo);
                        Addtaskdt.Add(dt_Task);
                    }
                    if (Adddtstockt.Count > 0 && Addlocations.Count > 0 && Addtaskdt.Count > 0)
                    {
                        _unitOfWorkManage.BeginTran();


                        _stockRepository.AddData(Adddtstockt);
                        _locationInfoRepository.AddData(Addlocations);
                        BaseDal.AddData(Addtaskdt);

                        var respon = PushTasksToWCS(Addtaskdt,"");
                        if (respon.Status)
                        {
                            _unitOfWorkManage.CommitTran();  //提交事务
                            return MESresponse("", true);
                        }
                        else
                        {
                            _unitOfWorkManage.RollbackTran();  //回滚事务
                            return MESresponse($"下发出库失败，原因：{respon.Message}！", false);
                        }

                    }
                    else
                    {
                        return MESresponse("任务生成失败！", false);
                    }

                }
                else
                {
                    return MESresponse("接收到MES托盘编码列表无数据！", false);
                }
            }
            else
            {
                return MESresponse("接收到MES下发的任务为空！", false);
            }
        }

        
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -21,15 +21,22 @@
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using System.DirectoryServices.Protocols;
using System.Net;
using System.Reflection.Emit;
using System.Threading.Tasks;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.OtherEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Const;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Task;
using WIDESEA_DTO.ToMes;
using WIDESEA_IBasicService;
using WIDESEA_IInboundService;
using WIDESEA_IOutboundService;
@@ -49,6 +56,9 @@
        private readonly IRepository<Dt_LocationInfo> _locationInfoRepository;
        private readonly IRepository<Dt_RoadwayInfo> _roadwayInforepository;
        private readonly IBasicService _basicService;
        private readonly IDt_ApiInfoService _dt_ApiInfoService;
        private readonly ILocationStatusChangeRecordService _locationStatusChangeRecordService;
        private readonly IStationMangerService _stationMangerService;

        public IRepository<Dt_Task> Repository => BaseDal;

@@ -58,11 +68,7 @@
                {nameof(Dt_Task.CreateDate),OrderByType.Asc},
            };

        public List<int> TaskTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public List<int> TaskOutboundTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public TaskService(IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_StockInfo> stockRepository, IBasicService basicService, IRepository<Dt_Warehouse> warehouseRepository, IRepository<Dt_LocationInfo> locationInfoRepository, IRepository<Dt_RoadwayInfo> roadwayInforepository) : base(BaseDal)
        public TaskService(IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_StockInfo> stockRepository, IBasicService basicService, IRepository<Dt_Warehouse> warehouseRepository, IRepository<Dt_LocationInfo> locationInfoRepository, IRepository<Dt_RoadwayInfo> roadwayInforepository, IDt_ApiInfoService dt_ApiInfoService, ILocationStatusChangeRecordService locationStatusChangeRecordService, IStationMangerService stationMangerService) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
@@ -71,7 +77,15 @@
            _warehouseRepository = warehouseRepository;
            _locationInfoRepository = locationInfoRepository;
            _roadwayInforepository = roadwayInforepository;
            _dt_ApiInfoService = dt_ApiInfoService;
            _locationStatusChangeRecordService = locationStatusChangeRecordService;
            _stationMangerService=stationMangerService;
        }
        public int GetTaskNum(string sequenceName)
        {
            return Db.Ado.GetScalar($"SELECT NEXT VALUE FOR {sequenceName}").ObjToInt();
        }

        /// <summary>
        /// ä»»åŠ¡ä¿¡æ¯æŽ¨é€è‡³WCS
        /// </summary>
@@ -85,34 +99,204 @@
                {
                    x.AGVArea = agvDescription;
                });
                string url = AppSettings.Get("WCSApiAddress");
                if (string.IsNullOrEmpty(url))
                {
                    return WebResponseContent.Instance.Error($"未找到WCSApi地址,请检查配置文件");
                }
                string response = HttpHelper.Post($"{url}/api/Task/ReceiveTask", taskDTOs.Serialize());

                return JsonConvert.DeserializeObject<WebResponseContent>(response) ?? WebResponseContent.Instance.Error("返回错误");
                var ConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_WCS_IPAddress, SysConfigConst.WCSReceiveTask);      //获取到wcs全部类型的接口
                string WCSReceiveTaskAPI = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;

                var respon = HttpHelper.Post(WCSReceiveTaskAPI, JsonConvert.SerializeObject(taskDTOs));
                if (respon != null)
                {
                    WebResponseContent respone = JsonConvert.DeserializeObject<WebResponseContent>(respon.ToString());
                    if (respone.Status)
                    {
                        return WebResponseContent.Instance.OK();
                    }
                    else
                    {
                        return WebResponseContent.Instance.Error($"下发出库失败，原因：{respone.Message}！");
                    }
                }
                else
                {
                    return WebResponseContent.Instance.Error("任务下发失败！");
                }
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        


        /// <summary>
        /// åˆ¤æ–­å··é“内移库
        /// </summary>
        /// <param name="TaskNum"></param>
        /// <param name="SourceAddress"></param>
        /// <returns></returns>
        public WebResponseContent IsRelocations(int TaskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                List<Dt_LocationInfo> loca = new List<Dt_LocationInfo>();

                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == TaskNum);
                if (task == null) return content.Error($"未找到该任务信息，任务号：{TaskNum}");
                string Locatask = task.SourceAddress;

                //获取到深库位编号
                Dt_LocationInfo DeepLocation = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == Locatask);
                if(DeepLocation == null) return content.Error($"未找到该货位信息,货位编号:{Locatask}");

                //进行获取浅库位编号
                int locrow = DeepLocation.Row == 1 ? 2 : 3;
                Dt_LocationInfo ShallowLocation = _basicService.LocationInfoService.Repository.QueryFirst(x =>x.Row== locrow && x.Layer== DeepLocation.Layer && x.Column== DeepLocation.Column && x.RoadwayNo== DeepLocation.RoadwayNo);
                if (ShallowLocation == null) return content.Error($"未找到货位编号:{Locatask}的浅货位");

                if (ShallowLocation.LocationStatus == (int)LocationStatusEnum.Free)
                {
                    return content.OK(data: task);  //直接返回当前查询的任务
                }


                //如果有货，则生成移库任务
                if (ShallowLocation.LocationStatus == (int)LocationStatusEnum.InStock)
                {
                    Dt_StockInfo dt_Stock = _stockRepository.QueryFirst(x => x.LocationCode == ShallowLocation.LocationCode);
                    if (dt_Stock == null) return content.Error($"货位编号:{Locatask}的浅货位库存异常，请检查！！！");

                    Dt_Task _Task = BaseDal.QueryFirst(x => x.SourceAddress == ShallowLocation.LocationCode || x.TargetAddress == ShallowLocation.LocationCode);
                    if (_Task != null) return content.Error($"货位编号:{Locatask}的浅货位库已有任务，不可进行移库");

                    //进行获取新的库位
                    Dt_LocationInfo? Nextlocation = _basicService.LocationInfoService.AssignLocation(DeepLocation.RoadwayNo, 0, "");//获取到新库位
                    if (Nextlocation == null)
                    {
                        return content.Error($"货位分配失败,未找到可分配货位");
                    }
                    ShallowLocation.LocationStatus = (int)LocationStatusEnum.Lock;
                    Nextlocation.LocationStatus = (int)LocationStatusEnum.Lock;
                    loca.Add(ShallowLocation);
                    loca.Add(Nextlocation);

                    _unitOfWorkManage.BeginTran();
                    //生成移动任务
                    Dt_Task dt_Task = new()
                    {
                        PalletCode = dt_Stock.PalletCode,
                        TaskNum = GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                        Roadway = Nextlocation.RoadwayNo,
                        TaskType = TaskRelocationTypeEnum.Relocation.ObjToInt(),
                        TaskStatus = TaskRelocationStatusEnum.RelocationNew.ObjToInt(),
                        SourceAddress = ShallowLocation.LocationCode,
                        TargetAddress = Nextlocation.LocationCode,
                        CurrentAddress = ShallowLocation.LocationCode,
                        NextAddress = Nextlocation.LocationCode,
                        Grade = 1,
                        Creater = "WMS",
                        Depth = ShallowLocation.Depth,
                        CreateDate = DateTime.Now,
                    };

                    _locationInfoRepository.AddData(loca);
                    BaseDal.AddData(dt_Task);   //新增任务
                    _unitOfWorkManage.CommitTran();

                    return content.OK(data: dt_Task);
                }
                else
                {
                    return content.Error($"货位编号:{Locatask}的浅货位状态异常，浅货位编号：{ShallowLocation.LocationCode}");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                throw;
            }
        }

        /// <summary>
        /// ä»»åŠ¡å®Œæˆ
        /// </summary>
        /// <param name="taskNum">任务编号</param>
        /// <param name="HowWorks">模式（1：自动，2：手动）</param>
        /// <returns></returns>
        public WebResponseContent TaskCompleted(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();

            Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
            if (task == null) return WebResponseContent.Instance.Error("未找到任务信息");
            switch (task.TaskType)
            {
                case (int)TaskRelocationTypeEnum.Relocation:
                    return RelocationInTaskCompleted(task);
                case (int)TaskInboundTypeEnum.Inbound:
                    return InboundTaskCompleted(task);
                case (int)TaskOutboundTypeEnum.Outbound:
                    return OutboundTaskCompleted(task);
                default: return content.Error($"任务类型错误，任务号：{task.TaskNum}");
            }
        }

        /// <summary>
        /// ç§»åº“完成方法
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public WebResponseContent RelocationInTaskCompleted(Dt_Task task)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                Dt_StockInfo stockInfo = _stockRepository.QueryFirst(x => x.PalletCode == task.PalletCode);
                Dt_LocationInfo locationpoint = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.SourceAddress);
                Dt_LocationInfo locationEnd = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.TargetAddress);
                List<Dt_LocationInfo> loca = new List<Dt_LocationInfo>();
                stockInfo.LocationCode = locationEnd.LocationCode;
                stockInfo.StockStatus = StockStatusEmun.已入库.ObjToInt();
                locationpoint.LocationStatus = LocationStatusEnum.Free.ObjToInt();
                locationEnd.LocationStatus = LocationStatusEnum.InStock.ObjToInt();
                loca.Add(locationpoint);
                loca.Add(locationEnd);

                _unitOfWorkManage.BeginTran();
                _stockRepository.UpdateData(stockInfo);
                _basicService.LocationInfoService.Repository.UpdateData(loca);
                BaseDal.DeleteData(task);
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);

                WebResponseContent content=MES_TransferCompletionFeedback(task);
                if (!content.Status)
                {
                    _unitOfWorkManage.RollbackTran();
                    return content;
                }
                    
                _unitOfWorkManage.CommitTran();
                return webResponse.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return webResponse.Error($"移库任务完成失败，任务id：{task.TaskNum}");
                throw;
            }
            
        }

        /// <summary>
        /// å…¥åº“任务完成
        /// </summary>
        /// <param name="tasknum"></param>
        /// <returns></returns>
        public WebResponseContent InboundTaskCompleted(int taskNum)
        public WebResponseContent InboundTaskCompleted(Dt_Task task)
        {
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null)
                {
                    return WebResponseContent.Instance.Error($"未找到该任务信息");
                }
                Dt_Warehouse warehouse = _warehouseRepository.QueryFirst(x => x.WarehouseId == task.WarehouseId);
                Dt_StockInfo stockInfo = _stockRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == task.PalletCode && x.WarehouseId == task.WarehouseId).First();
                if (stockInfo == null)
@@ -130,6 +314,7 @@
                }
                dt_LocationInfo.LocationStatus = LocationStatusEnum.InStock.ObjToInt();
                stockInfo.StockStatus = StockStatusEmun.入库完成.ObjToInt();

                _unitOfWorkManage.BeginTran();
                //修改货位状态为有货
                _locationInfoRepository.UpdateData(dt_LocationInfo);
@@ -137,6 +322,14 @@
                _stockRepository.UpdateData(stockInfo);
                //删除任务添加历史
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId > 0 ? OperateTypeEnum.人工完成 : OperateTypeEnum.自动完成);

                WebResponseContent content = TaskCompletionFeedback(task);
                if (!content.Status)
                {
                    _unitOfWorkManage.RollbackTran();
                    return content;
                }

                _unitOfWorkManage.CommitTran();
            }
            catch (Exception)
@@ -146,5 +339,269 @@
            }
            return WebResponseContent.Instance.OK();
        }

        /// <summary>
        /// å‡ºåº“任务完成
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public WebResponseContent OutboundTaskCompleted(Dt_Task task)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                Dt_StockInfo stockInfo = _stockRepository.QueryFirst(x => x.PalletCode == task.PalletCode);
                if (stockInfo == null) return webResponse.Error($"任务编号：{task.TaskNum},未找到托盘：{stockInfo.PalletCode}的库存信息");
                Dt_LocationInfo locationInfo = _locationInfoRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
                if (locationInfo == null) return webResponse.Error($"任务编号：{task.TaskNum},未找到托盘：{stockInfo.PalletCode}的货位信息");


                stockInfo.StockStatus = StockStatusEmun.出库完成.ObjToInt();
                
                int beforeStatus = locationInfo.LocationStatus;
                locationInfo.LocationStatus = LocationStatusEnum.Free.ObjToInt();
                task.TaskStatus = TaskOutStatusEnum.OutFinish.ObjToInt();

                _unitOfWorkManage.BeginTran();
                _stockRepository.DeleteData(stockInfo);
                _locationInfoRepository.UpdateData(locationInfo);   //修改成空货位
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                _locationStatusChangeRecordService.AddLocationStatusChangeRecord(locationInfo, beforeStatus, StockStatusEmun.出库完成.ObjToInt(), stockInfo.Details.FirstOrDefault()?.OrderNo ?? "", task.TaskNum);
                WebResponseContent content = TaskCompletionFeedback(task);
                if (!content.Status)
                {
                    _unitOfWorkManage.RollbackTran();
                    return content;
                }

                _unitOfWorkManage.CommitTran();
                return webResponse.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return webResponse.Error($"移库任务完成失败，任务id：{task.TaskNum},错误原因：{ex.Message}");
                throw;
            }
            
        }







        //==============================================移库完成反馈接口====================================================
        /// <summary>
        /// ä¸Šä¼ ç§»åº“任务完成给MES
        /// </summary>
        /// <param name="dt_Task"></param>
        /// <returns></returns>
        public WebResponseContent MES_TransferCompletionFeedback(Dt_Task dt_Task)
        {
            WebResponseContent webResponse = new WebResponseContent();

            try
            {
                TransferRequest transferRequest = new TransferRequest()
                {
                    //业务id，任务id后续进行更改
                    businessId = "1",
                    TaskId = "1",
                    SourceLocationCode = dt_Task.SourceAddress,
                    LocationCode = dt_Task.TargetAddress,
                    PalletCode = dt_Task.PalletCode,
                    Status = "FINISH",
                    ErrorStatus = "NORMAL",
                    ErrorInfo = "",
                };

                //获取接口进行调取
                var ConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_MES_IPAddress, SysConfigConst.MESTransferCompletionFeedback);      //获取到wcs全部类型的接口
                string WCSReceiveTaskAPI = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;
                if (WCSReceiveTaskAPI == null)
                {
                    return webResponse.Error($"出库失败，未配置MES移库完成反馈接口");
                }
                var respon = HttpHelper.Post(WCSReceiveTaskAPI, JsonConvert.SerializeObject(transferRequest));
                if (respon != null)
                {
                    var response = JsonConvert.DeserializeObject<ApiResponse<object>>(respon);
                    if (response.Success)
                    {
                        return webResponse.OK();
                    }
                    else
                    {
                        return webResponse.Error($"调取接口失败，反馈参数原因：{response.Message}");
                    }
                }
                else
                {
                    return webResponse.Error($"调取接口失败，反馈参数为空");
                }
            }
            catch (Exception ex)
            {
                return webResponse.Error($"移库任务上传失败！原因：{ex.Message}");
                throw;
            }
        }


        /// <summary>
        /// ä¸Šä¼ å‡ºå…¥åº“任务完成给MES
        /// </summary>
        /// <param name="dt_Task"></param>
        /// <returns></returns>
        public WebResponseContent TaskCompletionFeedback(Dt_Task dt_Task)
        {
            WebResponseContent webResponse = new WebResponseContent();

            try
            {
                TaskNotification transferRequest = new TaskNotification()
                {
                    //业务id，任务id后续进行更改
                    TaskId = "1",   //任务id
                    BusinessId = "1",   //业务id
                    PalletCode = dt_Task.PalletCode,
                    SubPalletCode = "",//子托盘编码
                    LocationCode = dt_Task.SourceAddress,
                    ErrorStatus = "NORMAL",
                    ErrorInfo = "",
                };

                //获取接口进行调取
                var ConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_MES_IPAddress, SysConfigConst.MESTaskFeedback);      //获取到wcs全部类型的接口
                string WCSReceiveTaskAPI = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;
                if (WCSReceiveTaskAPI == null)
                {
                    return webResponse.Error($"任务反馈MES失败，未配置MES任务完成反馈接口");
                }
                var respon = HttpHelper.Post(WCSReceiveTaskAPI, JsonConvert.SerializeObject(transferRequest));
                if (respon != null)
                {
                    var response = JsonConvert.DeserializeObject<ApiResponse<object>>(respon);
                    if (response.Success)
                    {
                        return webResponse.OK();
                    }
                    else
                    {
                        return webResponse.Error($"调取接口失败，反馈参数原因：{response.Message}");
                    }
                }
                else
                {
                    return webResponse.Error($"调取接口失败，反馈参数为空");
                }
            }
            catch (Exception ex)
            {
                return webResponse.Error($"任务任务上传失败！原因：{ex.Message}");
                throw;
            }
        }

        public ApiResponse<object> MESresponse(string Message, bool Success)
        {
            ApiResponse<object> apiResponse = new ApiResponse<object>();
            apiResponse.Message = Message;
            apiResponse.Success = Success;
            apiResponse.Code = 1;
            return apiResponse;
        }




        /// <summary>
        /// åˆ›å»ºè´§ä½
        /// </summary>
        /// <param name="locationInfo"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public ApiResponse<object> createLocation(List<LocationInfoDto> locationInfo)
        {
            List<Dt_LocationInfo> dt_LocationInfoList = new List<Dt_LocationInfo>();
            foreach (var item in locationInfo)
            {
                Dt_LocationInfo dt_LocationInfo = new Dt_LocationInfo()
                {
                    LocationCode = item.locationCode,
                    LocationName = item.locationName,
                    RoadwayNo = item.roadwayNo,
                    Row = item.row,
                    Column = item.column,
                    Layer = item.layer,
                    Depth = (int)item.depth,
                    LocationType = item.locationType,
                    LocationStatus = item.locationStatus,
                    EnableStatus = item.enableStatus == true ? 1 : 0,
                    Remark = item.remark,
                    CreateDate = DateTime.Now,
                    Creater = App.User.UserName,
                };
                dt_LocationInfoList.Add(dt_LocationInfo);
            }
            int res = _locationInfoRepository.AddData(dt_LocationInfoList);
            if (res <= 0)
            {
                return MESresponse($"创建货位失败",false);
            }
            return MESresponse($"", true);
        }

        /// <summary>
        /// ä¿®æ”¹è´§ä½
        /// </summary>
        /// <param name="locationInfo"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public ApiResponse<object> updateLocation(LocationInfoDto locationInfo)
        {
            Dt_LocationInfo dt_LocationInfo = new Dt_LocationInfo()
            {
                LocationCode = locationInfo.locationCode,
                LocationName = locationInfo.locationName,
                RoadwayNo = locationInfo.roadwayNo,
                Row = locationInfo.row,
                Column = locationInfo.column,
                Layer = locationInfo.layer,
                Depth = (int)locationInfo.depth,
                LocationType = locationInfo.locationType,
                LocationStatus = locationInfo.locationStatus,
                EnableStatus = locationInfo.enableStatus == true ? 1 : 0,
                Remark = locationInfo.remark,
                CreateDate = DateTime.Now,
            };
            bool res = _locationInfoRepository.Db.Updateable(dt_LocationInfo)
    .Where(x => x.LocationCode == dt_LocationInfo.LocationCode)
    .ExecuteCommand() > 0;
            if (!res)
            {
                return MESresponse($"修改货位失败",false);
            }
            return MESresponse($"", true);
        }

        /// <summary>
        /// åˆ é™¤è´§ä½
        /// </summary>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public ApiResponse<object> deleteLocation(List<string> locationCode)
        {
            WebResponseContent webResponseContent = new WebResponseContent();
            int res = _locationInfoRepository.Db.Deleteable<Dt_LocationInfo>().Where(x => locationCode.Contains(x.LocationCode)).ExecuteCommand();
            if (res <= 0)
            {
                return MESresponse($"删除货位失败",false);
            }
            return MESresponse($"", true);
        }
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/TaskInfo/TaskController.cs

@@ -6,6 +6,7 @@
using WIDESEA_Core.BaseController;
using WIDESEA_DTO.Stock;
using WIDESEA_DTO.Task;
using WIDESEA_DTO.ToMes;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;

@@ -21,6 +22,33 @@
        public TaskController(ITaskService service) : base(service)
        {
        }


        /// <summary>
        /// ä»»åŠ¡å®ŒæˆæŽ¥å£
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        [HttpGet, Route("TaskCompleted"), AllowAnonymous]
        public WebResponseContent TaskCompleted(int taskNum)
        {
            return Service.TaskCompleted(taskNum);
        }


        /// <summary>
        /// ç§»åº“申请判断接口
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        [HttpGet, Route("IsRelocations"), AllowAnonymous]
        public WebResponseContent IsRelocations(int taskNum)
        {
            return Service.IsRelocations(taskNum);
        }



        /// <summary>
        /// WCS申请入库任务(不分配货位)
        /// </summary>
@@ -34,14 +62,53 @@
        }

        /// <summary>
        /// å…¥åº“任务完成
        /// MES下发出库任务
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("InboundTaskCompleted"), AllowAnonymous]
        public WebResponseContent InboundTaskCompleted(int taskNum)
        [HttpPost, HttpGet, Route("sendExTask"), AllowAnonymous]
        public ApiResponse<object> sendExTask([FromBody] InOutboundTaskReceived outbound)
        {
            return Service.InboundTaskCompleted(taskNum);
            return Service.sendExTask(outbound);
        }

        /// <summary>
        /// MES下发入库任务
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("sendEnTask"), AllowAnonymous]
        public ApiResponse<object> sendEnTask([FromBody] InOutboundTaskReceived outbound)
        {
            return Service.sendEnTask(outbound);
        }


        /// <summary>
        /// æ–°å»ºè´§ä½
        /// </summary>
        [HttpPost, HttpGet, Route("createLocation"), AllowAnonymous]
        public ApiResponse<object> createLocation([FromBody] List<LocationInfoDto> locationInfo)
        {
            return Service.createLocation(locationInfo);
        }

        /// <summary>
        /// ä¿®æ”¹è´§ä½
        /// </summary>
        [HttpPost, HttpGet, Route("updateLocation"), AllowAnonymous]
        public ApiResponse<object> updateLocation([FromBody] LocationInfoDto locationInfo)
        {
            return Service.updateLocation(locationInfo);
        }

        /// <summary>
        /// åˆ é™¤è´§ä½
        /// </summary>
        [HttpPost, HttpGet, Route("deleteLocation"), AllowAnonymous]
        public ApiResponse<object> deleteLocation([FromBody] List<string> locationCode)
        {
            return Service.deleteLocation(locationCode);
        }
    }
}

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_WMSServer/Program.cs

@@ -45,7 +45,7 @@
builder.Services.AddWebSocketSetup();
builder.Services.AddSqlsugarSetup();//SqlSugar å¯åŠ¨æœåŠ¡
builder.Services.AddDbSetup();//Db å¯åŠ¨æœåŠ¡
builder.Services.AddInitializationHostServiceSetup();//应用初始化服务注入
//builder.Services.AddInitializationHostServiceSetup();//应用初始化服务注入
//builder.Services.AddHostedService<PermissionDataHostService>();//数据权限
builder.Services.AddAutoMapperSetup();


 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_WMSServer/appsettings.json

@@ -12,7 +12,7 @@
    "MainDB": "DB_WIDESEA", //当前项目的主库，所对应的连接字符串的Enabled必须为true
    //连接字符串
    //"ConnectionString": "HTI6FB1H05Krd07mNm9yBCNhofW6edA5zLs9TY~MNthRYW3kn0qKbMIsGp~3yyPDF1YZUCPBQx8U0Jfk4PH~ajNFXVIwlH85M3F~v_qKYQ3CeAz3q1mLVDn8O5uWt1~3Ut2V3KRkEwYHvW2oMDN~QIDXPxDgXN0R2oTIhc9dNu7QNaLEknblqmHhjaNSSpERdDVZIgHnMKejU_SL49tralBkZmDNi0hmkbL~837j1NWe37u9fJKmv91QPb~16JsuI9uu0EvNZ06g6PuZfOSAeFH9GMMIZiketdcJG3tHelo=",
    "ConnectionString": "Data Source=.;Initial Catalog=WIDESEAWMS_SYLK;User ID=sa;Password=sa123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
    "ConnectionString": "Data Source=.;Initial Catalog=SY_WIDESEAWMS_SYLK;User ID=sa;Password=123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
    //"ConnectionString": "Data Source=10.30.4.92;Initial Catalog=WMS_TC;User ID=sa;Password=duo123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
    //旧WMS数据库连接
    //"TeConnectionString": "Data Source=10.30.4.92;Initial Catalog=TeChuang;User ID=sa;Password=duo123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",

 ÏîÄ¿×ÊÁÏ/½Ó¿ÚÇåµ¥/ÍÐÅÌ¿â½Ó¿ÚÇåµ¥V1.6.xlsx

Binary files differ