1

刘磊

2024-12-24 79a7c2707011902ec4df62ed8a285fa2029a1782

1

 .gitignore

@@ -1579,3 +1579,11 @@
/Code Management/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/CopilotIndices/17.12.31.40377/SemanticSymbols.db-shm
/Code Management/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/CopilotIndices/17.12.31.40377/SemanticSymbols.db-wal
/Code Management/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/CopilotIndices/17.12.31.40377/SemanticSymbols.db
/Code Management/.vs/Code Management/CopilotIndices/17.12.31.40377/CodeChunks.db
/Code Management/.vs/Code Management/CopilotIndices/17.12.31.40377/CodeChunks.db-shm
/Code Management/.vs/Code Management/CopilotIndices/17.12.31.40377/CodeChunks.db-wal
/Code Management/.vs/Code Management/CopilotIndices/17.12.31.40377/SemanticSymbols.db
/Code Management/.vs/Code Management/CopilotIndices/17.12.31.40377/SemanticSymbols.db-shm
/Code Management/.vs/Code Management/CopilotIndices/17.12.31.40377/CodeChunks.db-wal
/Code Management/.vs/Code Management/CopilotIndices/17.12.31.40377/SemanticSymbols.db-wal
/Code Management/.vs/slnx.sqlite

 Code Management/.vs/slnx.sqlite

Binary files differ

 Code Management/WCS/WIDESEAWCS_Client/src/extension/basicinfo/Dt_needBarcode.js

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

//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码
import gridBody from './extend/routerview.vue';
import gridHeader from './extend/addrouters.vue';
let extension = {
    components: {
      //查询界面扩展组件
      gridHeader: gridHeader,
      gridBody: gridBody,
      gridFooter: '',
      //新建、编辑弹出框扩展组件
      modelHeader: '',
      modelBody: '',
      modelFooter: ''
    },
    tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
    buttons: { view: [], box: [], detail: [] }, //扩展的按钮
    methods: {
       //下面这些方法可以保留也可以删除
      onInit() {  
        
      },
      onInited() {
        //框架初始化配置后
        //如果要配置明细表,在此方法操作
        //this.detailOptions.columns.forEach(column=>{ });
      },
      searchBefore(param) {
        //界面查询前,可以给param.wheres添加查询参数
        //返回false，则不会执行查询
        return true;
      },
      searchAfter(result) {
        //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
        return true;
      },
      addBefore(formData) {
        //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
        return true;
      },
      updateBefore(formData) {
        //编辑保存前formData为对象，包括明细表、删除行的Id
        return true;
      },
      rowClick({ row, column, event }) {
        //查询界面点击行事件
        // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
      },
      modelOpenAfter(row) {
        //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
        //(1)判断是编辑还是新建操作： this.currentAction=='Add';
        //(2)给弹出框设置默认值
        //(3)this.editFormFields.字段='xxx';
        //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
        //看不懂就把输出看：console.log(this.editFormOptions)
      }
    }
  };
  export default extension;
  

 Code Management/WCS/WIDESEAWCS_Client/src/extension/taskinfo/task_Hty.js

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

//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码
import gridBody from './extend/taskExecuteDetail.vue'
let extension = {
    components: {
        //查询界面扩展组件
        gridHeader: '',
        gridBody: gridBody,
        gridFooter: '',
        //新建、编辑弹出框扩展组件
        modelHeader: '',
        modelBody: '',
        modelFooter: ''
    },
    tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
    buttons: { view: [], box: [], detail: [] }, //扩展的按钮
    methods: {
        //下面这些方法可以保留也可以删除
        onInit() {
            // this.$Notice.success({ title: this.detailOptions.cnName + ',查询结果', desc: '返回的对象：' + JSON.stringify(data) });

            // var previousButton = this.buttons.find((x) => x.value == "Previous");
            // if (previousButton) previousButton.hidden = true;
            // var nextButton = this.buttons.find((x) => x.value == "Next");
            // if (nextButton) nextButton.hidden = true;
            // var recoveryButton = this.buttons.find((x) => x.value == "TaskRecovery");
            // if (recoveryButton) recoveryButton.hidden = true;

            //扩展页面初始化操作
            this.columns.push({
                field: '操作',
                title: '操作',
                width: 70,
                fixed: 'right',
                align: 'center',
                formatter: (row) => {
                    return (
                        '<i style="cursor: pointer;color: #2d8cf0;"class="el-icon-view">查看</i>'
                    );
                },
                click: (row) => {
                    this.$refs.gridBody.open(row);
                }
            });
        },
        onInited() {
            //框架初始化配置后
            //如果要配置明细表,在此方法操作
            //this.detailOptions.columns.forEach(column=>{ });
        },
        searchBefore(param) {
            //界面查询前,可以给param.wheres添加查询参数
            //返回false，则不会执行查询
            return true;
        },
        searchAfter(result) {
            //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
            return true;
        },
        addBefore(formData) {
            //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
            return true;
        },
        updateBefore(formData) {
            //编辑保存前formData为对象，包括明细表、删除行的Id
            return true;
        },
        rowClick({ row, column, event }) {
            //查询界面点击行事件
            // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
        },
        modelOpenAfter(row) {
            //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
            //(1)判断是编辑还是新建操作： this.currentAction=='Add';
            //(2)给弹出框设置默认值
            //(3)this.editFormFields.字段='xxx';
            //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
            //看不懂就把输出看：console.log(this.editFormOptions)
        }
    }
};
export default extension;

 Code Management/WCS/WIDESEAWCS_Client/src/uitils/signalr.js

@@ -95,6 +95,9 @@
    connection.on("LineData", (data) => {
      eventBus.emit("locationData", data);
    });
    connection.on("Logs", (data) => {
      eventBus.emit("Logs", data);
    });
  };

  //页面销毁

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

@@ -1,21 +1,38 @@
<template>
  <div class="title"></div>
  <el-container>
    <el-header>日志</el-header>
    <el-main>
      <el-card v-for="(log, index) in logs" :key="index" class="log-card" :style="{ color: log.color }">
        <div :style="{ color: log.color }">{{ log.logEntry }}</div>
        <div :style="{ color: log.color }">{{ log.time }}</div>
      </el-card>
    </el-main>
  </el-container>
</template>

<script>
import { ref, reactive } from 'vue'
import eventBus from "../uitils/eventBus";
import { ref, onMounted } from 'vue'
import eventBus from "@/uitils/eventBus";

export default {
  setup() {
    return {
    const logs = ref([]);
    onMounted(() => {
      eventBus.on('Logs', eventData => {
        if (logs.value.length > 500) {
          logs.value = [];
    }
        const logEntry = "日志信息：" + eventData.log
        const time = "时间：" + eventData.time 
        logs.value.unshift({ logEntry: logEntry, time: time, color: eventData.color });

    eventBus.on('stackerData', eventData => {
        console.log(eventData);
    })
    eventBus.on('locationData', eventData => {
        console.log(eventData);
    })
        // logs.value.unshift(logEntry);
      });
    });
    return {
      logs
    }
  }
}
</script>
@@ -27,4 +44,8 @@
  font-size: 28px;
  color: orange;
}

.log-card {
  margin-bottom: 10px;
}
</style>

 Code Management/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/copilot-chat/bef6627e/sessions/0fd52b0d-b36f-4668-871f-5e1c1d23e2e3

Binary files differ

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Common/Const/SysConfigKeyConst.cs

@@ -69,6 +69,9 @@
        /// </summary>
        public const string RequestOutTaskToBZ = "RequestOutTaskToBZ";


        /// <summary>
        /// é™ç½®NG入库
        /// </summary>
        public const string RequestInBoundTaskNG = "RequestInBoundTaskNG";
    }
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Server/appsettings.json

@@ -15,6 +15,8 @@
  //"ConnectionString": "Data Source=127.0.0.1;Initial Catalog=WIDESEA_WCS2F08;User ID=sa;Password=P@ssw0rd;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=True",
  //"ConnectionString": "Data Source=192.168.20.251;Initial Catalog=WIDESEA_WCSDB;User ID=sa;Password=123456@gy;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  "ConnectionString": "Data Source=.\\LIULEI;Initial Catalog=WIDESEAWCS_TEST;User ID=sa;Password=123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  "ConnectionString": "Data Source=127.0.0.1;Initial Catalog=WIDESEA_WCS2F08;User ID=sa;Password=P@ssw0rd;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=True",
  //"ConnectionString": "Data Source=192.168.20.251;Initial Catalog=WIDESEA_WCSDB;User ID=sa;Password=123456@gy;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  //"ConnectionString": "Data Source=192.168.5.251;Initial Catalog=WIDESEAWCS_TEST;User ID=sa;Password=P@ssw0rd;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  //跨域
  "Cors": {

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_SignalR/Hub/ISimpleHub.cs

@@ -32,4 +32,11 @@
    /// <param name="context"></param>
    /// <returns></returns>
    Task LineData(object context);

    /// <summary>
    /// çº¿ä½“数据
    /// </summary>
    /// <param name="context"></param>
    /// <returns></returns>
    Task Logs(object context);
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_SignalR/Service/INoticeService.cs

@@ -51,4 +51,13 @@
    /// <param name="message">通知内容</param>
    /// <returns></returns>
    Task LineData(int? userId, List<string> clientIds, object message);

    /// <summary>
    /// æ—¥å¿—流程数据
    /// </summary>
    /// <param name="userId">用户ID</param>
    /// <param name="clientIds">clientId列表</param>
    /// <param name="message">通知内容</param>
    /// <returns></returns>
    Task Logs(List<string> clientIds, object message);
}

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_SignalR/Service/SignalrNoticeService.cs

@@ -59,5 +59,12 @@
        await GetHubContext().Clients.Users(clientIds).LineData(message);
    }

    /// <inheritdoc/>
    public async Task Logs(List<string> clientIds, object message)
    {
        //发送消息给用户
        await GetHubContext().Clients.Users(clientIds).Logs(message);
    }

    #endregion MyRegion
}

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

@@ -1,5 +1,4 @@

using AutoMapper;
using AutoMapper;
using HslCommunication;
using Mapster;
using Microsoft.AspNetCore.Components.Routing;
@@ -76,76 +75,110 @@
        /// <returns>返回处理结果</returns>
        public WebResponseContent ReceiveWMSTask([NotNull] List<WMSTaskDTO> taskDTOs)
        {
            // åˆ›å»ºä¸€ä¸ªWebResponseContent对象用于存储返回结果
            WebResponseContent content = new WebResponseContent();
            try
            {
                // åˆ›å»ºä¸€ä¸ªDt_Task类型的列表用于存储转换后的任务数据
                List<Dt_Task> tasks = new List<Dt_Task>();
                // éåŽ†ä¼ å…¥çš„WMSTaskDTO列表
                foreach (var item in taskDTOs)
                {
                    // æŸ¥è¯¢æ•°æ®åº“中是否存在相同任务编号或托盘码的任务，如果存在则跳过当前循环
                    if (BaseDal.QueryFirst(x => x.TaskNum == item.TaskNum || x.PalletCode == item.PalletCode) != null)
                    {
                        continue;
                    }
                    // å°†WMSTaskDTO对象映射为Dt_Task对象
                    Dt_Task task = _mapper.Map<Dt_Task>(item);
                    // è®¾ç½®ä»»åŠ¡çš„创建者为"WMS"
                    task.Creater = "WMS";
                    // åˆ¤æ–­ä»»åŠ¡ç±»åž‹æ˜¯å¦ä¸ºå‡ºåº“任务
                    if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                    {
                        if (task.TargetAddress == "002-021-001")
                        // åˆ¤æ–­ä»»åŠ¡ç›®æ ‡åœ°å€å’Œè·¯å¾„是否满足特定条件
                        if (task.TargetAddress == "002-021-001" && task.Roadway.Contains("JZ") && task.TaskType == (int)TaskOutboundTypeEnum.OutTray)
                        {
                            // è®¾ç½®ä»»åŠ¡çŠ¶æ€ä¸ºå‡ºåº“新建
                            task.TaskState = (int)TaskOutStatusEnum.OutNew;
                            // è®¾ç½®å½“前地址为源地址
                            task.CurrentAddress = item.SourceAddress;
                            // è®¾ç½®ä¸‹ä¸€ä¸ªåœ°å€ä¸ºç›®æ ‡åœ°å€
                            task.NextAddress = item.TargetAddress;
                        }
                        else
                        {
                            // æŸ¥è¯¢ä¸‹ä¸€ä¸ªè·¯ç”±
                            List<Dt_Router> routers = _routerService.QueryNextRoutes(item.RoadWay, item.TargetAddress);
                            if (routers.Count > 0)
                            {
                                // è®¾ç½®ä»»åŠ¡çŠ¶æ€ä¸ºå‡ºåº“新建
                                task.TaskState = (int)TaskOutStatusEnum.OutNew;
                                // è®¾ç½®å½“前地址为源地址
                                task.CurrentAddress = item.SourceAddress;
                                // è®¾ç½®ä¸‹ä¸€ä¸ªåœ°å€ä¸ºç¬¬ä¸€ä¸ªå­ä½ç½®
                                task.NextAddress = routers.FirstOrDefault().ChildPosi;
                            }
                            else
                            {
                                // æŸ¥è¯¢ä»Žæºåœ°å€åˆ°ç›®æ ‡åœ°å€çš„路由
                                routers = _routerService.QueryNextRoutes(item.SourceAddress, item.TargetAddress);
                                if (routers.Count > 0)
                                {
                                    // è®¾ç½®ä»»åŠ¡çŠ¶æ€ä¸ºå‡ºåº“完成
                                    task.TaskState = (int)TaskOutStatusEnum.SC_OutFinish;
                                    // è®¾ç½®å½“前地址为源地址
                                    task.CurrentAddress = item.SourceAddress;
                                    // è®¾ç½®ä¸‹ä¸€ä¸ªåœ°å€ä¸ºç¬¬ä¸€ä¸ªå­ä½ç½®
                                    task.NextAddress = routers.FirstOrDefault().ChildPosi;
                                }
                            }
                        }
                    }
                    // åˆ¤æ–­ä»»åŠ¡ç±»åž‹æ˜¯å¦ä¸ºå…¥åº“任务
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                    {
                        if (task.SourceAddress == "1359-4")
                        // åˆ¤æ–­æºåœ°å€æ˜¯å¦ä¸ç­‰äºŽ"1359-4"
                        if (task.SourceAddress != "1359-4")
                        {
                            task.TaskState = (int)TaskInStatusEnum.InNew;
                            task.CurrentAddress = item.SourceAddress;
                        }
                        else
                        {
                            // æŸ¥è¯¢ä»Žæºåœ°å€åˆ°ç›®æ ‡åœ°å€çš„路由
                            List<Dt_Router> routers = _routerService.QueryNextRoutes(item.SourceAddress, item.TargetAddress);
                            if (routers.Count > 0)
                            {
                                // è®¾ç½®ä»»åŠ¡çŠ¶æ€ä¸ºå…¥åº“新建
                                task.TaskState = (int)TaskInStatusEnum.InNew;
                                // è®¾ç½®å½“前地址为源地址
                                task.CurrentAddress = item.SourceAddress;
                                // è®¾ç½®ä¸‹ä¸€ä¸ªåœ°å€ä¸ºç¬¬ä¸€ä¸ªå­ä½ç½®
                                task.NextAddress = routers.FirstOrDefault().ChildPosi;
                            }
                        }
                        else
                        {
                            // è®¾ç½®å½“前地址为"002-021-001"
                            task.CurrentAddress = "002-021-001";
                            // è®¾ç½®ä¸‹ä¸€ä¸ªåœ°å€ä¸ºç›®æ ‡åœ°å€
                            task.NextAddress = item.TargetAddress;
                    }
                    }
                    // å°†è½¬æ¢åŽçš„任务添加到任务列表中
                    tasks.Add(task);
                }
                // å°†ä»»åŠ¡åˆ—表添加到数据库中
                BaseDal.AddData(tasks);

                // æ·»åŠ ä»»åŠ¡æ‰§è¡Œè¯¦æƒ…
                _taskExecuteDetailService.AddTaskExecuteDetail(tasks.Select(x => x.TaskNum).ToList(), "接收WMS任务");

                // è®¾ç½®è¿”回结果为成功
                content = WebResponseContent.Instance.OK("成功");
            }
            catch (Exception ex)
            {
                // æ•èŽ·å¼‚常并设置返回结果为错误信息
                content = WebResponseContent.Instance.Error($"任务接收错误,错误信息:{ex.Message}");
            }
            // è¿”回结果
            return content;
        }

@@ -166,14 +199,16 @@
                    return content.OK("当前托盘存在任务");
                }

                var config = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
                var wmsBase = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.WMSIP_BASE)?.ConfigValue;
                var requestTask = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.RequestTask)?.ConfigValue;
                if (wmsBase == null || requestTask == null)
                var wmsIpAddrss = string.Empty;
                var stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == sourceAddress);
                if (stationManager.stationType == 5)
                {
                    throw new InvalidOperationException("WMS IP æœªé…ç½®");
                    wmsIpAddrss = GetIpAddress(SysConfigKeyConst.WMSIP_BASE, SysConfigKeyConst.RequestInBoundTaskNG);
                }
                var wmsIpAddrss = wmsBase + requestTask;
                else
                {
                    wmsIpAddrss = GetIpAddress(SysConfigKeyConst.WMSIP_BASE, SysConfigKeyConst.RequestTask);
                }

                var result = await HttpHelper.PostAsync(wmsIpAddrss, new { Position = sourceAddress, PalletCode = palletCode }.ToJsonString());
                content = JsonConvert.DeserializeObject<WebResponseContent>(result);
@@ -192,8 +227,7 @@
                    _Task.TaskState = (int)TaskInStatusEnum.InNew;
                    _Task.CurrentAddress = task.SourceAddress;
                    _Task.NextAddress = station.stationNGChildCode;
                    _Task.TargetAddress = station.stationNGLocation;
                    _Task.Roadway = station.Roadway;
                    _Task.TargetAddress = task.TargetAddress;

                    BaseDal.AddData(_Task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(_Task.TaskNum, "接收WMS任务");
@@ -218,7 +252,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) && x.TaskState == (int)TaskInStatusEnum.InNew) || (TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish)) && x.CurrentAddress == currentAddress, TaskOrderBy);
        }

        /// <summary>
@@ -229,7 +263,7 @@
        /// <returns></returns>
        public Dt_Task QueryNextConveyorLineTask(string deviceNo, string currentAddress)
        {
            return BaseDal.QueryFirst(x => (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.InNew || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish) && x.NextAddress == currentAddress, TaskOrderBy);
            return BaseDal.QueryFirst(x => ((TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.InNew) || (TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish)) && x.NextAddress == currentAddress, TaskOrderBy);
        }

        /// <summary>
@@ -240,7 +274,7 @@
        /// <returns></returns>
        public Dt_Task QueryBarCodeConveyorLineTask(string Barcode, string currentAddress)
        {
            return BaseDal.QueryFirst(x => (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.InNew || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish) && x.CurrentAddress == currentAddress && x.PalletCode == Barcode, TaskOrderBy);
            return BaseDal.QueryFirst(x => ((TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.InNew) || (TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish)) && x.CurrentAddress == currentAddress && x.PalletCode == Barcode, TaskOrderBy);
        }

        /// <summary>
@@ -265,11 +299,16 @@
            return BaseDal.QueryFirst(x => x.TaskNum == taskNum && x.CurrentAddress == currentAddress && (x.TaskState == (int)TaskInStatusEnum.Line_InFinish || x.TaskState == (int)TaskOutStatusEnum.Line_OutFinish), TaskOrderBy);
        }

        /// <summary>
        /// æ ¹æ®æ‰˜ç›˜å·ã€å½“前地址查询任务
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns></returns>
        public Dt_Task QueryBarcodeTask(string barcode, string currentAddress)
        {
            return BaseDal.QueryFirst(x => x.PalletCode == barcode && x.CurrentAddress == currentAddress, TaskOrderBy);
        }


        /// <summary>
        /// æ ¹æ®ä»»åŠ¡å·ã€å½“前地址查询输送线新建的任务
@@ -291,7 +330,7 @@
        public Dt_Task? QuertStackerCraneTask(string deviceNo, TaskTypeGroup? taskTypeGroup = null)
        {
            if (taskTypeGroup == null)
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.Line_InFinish || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew), TaskOrderBy);
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && ((TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.Line_InFinish) || (TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew)), TaskOrderBy);
            if (taskTypeGroup.Value == TaskTypeGroup.InboundGroup)
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.Line_InFinish, TaskOrderBy);
            if (taskTypeGroup.Value == TaskTypeGroup.OutbondGroup)
@@ -308,9 +347,9 @@
        public Dt_Task QueryStackerCraneTask(string deviceNo, string currentAddress = "")
        {
            if (string.IsNullOrEmpty(currentAddress))
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.Line_InFinish || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew), TaskOrderBy);
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && ((TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.Line_InFinish) || (TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew)), TaskOrderBy);
            else
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && x.CurrentAddress == currentAddress && (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.Line_InFinish || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew), TaskOrderBy);
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && x.CurrentAddress == currentAddress && ((TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.Line_InFinish) || (TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew)), TaskOrderBy);
        }

        /// <summary>
@@ -472,8 +511,8 @@

                    if (task.TaskState == (int)TaskInStatusEnum.Line_InFinish)
                    {

                        #region å…¥åº“调用接口获取货位地址

                        // TODO: è°ƒç”¨æŽ¥å£èŽ·å–货位地址
                        // åˆ›å»ºè¯·æ±‚对象
                        var taskDto = new RequestTaskDto()
@@ -509,12 +548,11 @@
                        task.CurrentAddress = task.NextAddress;
                        task.NextAddress = taskResult.TargetAddress;
                        task.TargetAddress = task.NextAddress;
                        #endregion

                        #endregion å…¥åº“调用接口获取货位地址
                    }
                    else if (task.TaskState == (int)TaskInStatusEnum.SC_InFinish)
                    {

                        task.ModifyDate = DateTime.Now;
                        task.Modifier = "System";

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

                #region  æ›´æ–°ä»»åŠ¡çŠ¶æ€

                // èŽ·å–WMSip地址
                var config = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
                var wmsBase = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.WMSIP_BASE)?.ConfigValue;
@@ -554,7 +593,8 @@

                var result = HttpHelper.PostAsync(wmsIpAddress, new { TaskNum = task.TaskNum, TaskState = task.TaskState }.ToJsonString()).Result;
                content = JsonConvert.DeserializeObject<WebResponseContent>(result);
                #endregion

                #endregion æ›´æ–°ä»»åŠ¡çŠ¶æ€

                content = WebResponseContent.Instance.OK();
            }
@@ -614,6 +654,7 @@
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");

                #region WMS同步任务完成

                var keys = new Dictionary<string, object>()
                {
                    {"taskNum", taskNum}
@@ -640,7 +681,8 @@
                    }
                }
                task.ExceptionMessage += "   " + content.Message;
                #endregion

                #endregion WMS同步任务完成

                if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup && task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                {
@@ -678,7 +720,6 @@
                        _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机出库完成");
                    }


                    //暂不考虑多个出库口
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup && task.TaskState == (int)TaskInStatusEnum.SC_InExecuting)
@@ -707,21 +748,6 @@
                {
                    throw new Exception($"任务类型错误,未找到该任务类型,任务号:【{taskNum}】,任务类型:【{task.TaskType}】");
                }


                #region  æ›´æ–°ä»»åŠ¡çŠ¶æ€

                //var updateTask = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.UpdateTask)?.ConfigValue;
                //if (wmsBase == null || updateTask == null)
                //{
                //    throw new InvalidOperationException("WMS IP æœªé…ç½®");
                //}
                //wmsIpAddress = wmsBase + updateTask;

                //result = HttpHelper.PostAsync(wmsIpAddress, new { TaskNum = task.TaskNum, TaskState = task.TaskState }.ToJsonString()).Result;
                //content = JsonConvert.DeserializeObject<WebResponseContent>(result);
                #endregion
                //content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
@@ -829,5 +855,17 @@
        {
            return BaseDal.QueryFirst(x => x.PalletCode == barcode && x.NextAddress == nextAddress && (x.TaskState == (int)TaskInStatusEnum.Line_InExecuting || x.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting), TaskOrderBy);
        }

        private string GetIpAddress(string baseIp, string name)
        {
            var configz = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
            var wcsBasez = configz.Where(x => x.ConfigKey == baseIp).FirstOrDefault()?.ConfigValue;
            var address = configz.Where(x => x.ConfigKey == name).FirstOrDefault()?.ConfigValue;
            if (wcsBasez == null || address == null)
            {
                throw new InvalidOperationException("WMS IP æœªé…ç½®");
            }
            return wcsBasez + address;
        }
    }
}

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

@@ -1,5 +1,6 @@
using AutoMapper;
using HslCommunication;
using NetTaste;
using Newtonsoft.Json;
using Quartz;
using SqlSugar;
@@ -43,6 +44,10 @@
        private readonly ICacheService _cacheService;
        private readonly INoticeService _noticeService;

        private static List<string>? userTokenIds;
        private static List<int>? userIds;


        public CommonConveyorLineJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IMapper mapper, ITaskRepository taskRepository, IPlatFormRepository platFormRepository, ISys_ConfigService sys_ConfigService, IDt_StationManagerService stationManagerService, IDt_StationManagerRepository stationManagerRepository, ICacheService cacheService, INoticeService noticeService)
        {
            _taskService = taskService;
@@ -61,34 +66,71 @@
        public async Task Execute(IJobExecutionContext context)
        {
            string jobName = context.JobDetail.Key.Name;
            if (MemoryLockManager.TryAcquireLock(jobName))
            {
            //if (MemoryLockManager.TryAcquireLock(jobName))
            //{
                try
                {
                // ä»ŽJobDataMap中获取传递的参数
                    CommonConveyorLine conveyorLine = (CommonConveyorLine)context.JobDetail.JobDataMap.Get("JobParams");
                    if (conveyorLine != null)
                    {
                    // æŸ¥è¯¢æ‰€æœ‰å­è®¾å¤‡çš„位置
                        List<string> childDeviceCodes = _routerService.QueryAllPositions(conveyorLine.DeviceCode);
                    // å¹¶è¡Œå¤„理每个子设备
                        var tasks = childDeviceCodes.Select(childDeviceCode => ProcessDeviceAsync(conveyorLine, childDeviceCode)).ToList();
                        await Task.WhenAll(tasks);

                    // èŽ·å–所有站点管理器
                        List<Dt_StationManager> stationManagers = _stationManagerService.GetAllStationByDeviceCode(conveyorLine.DeviceCode);
                        foreach (var station in stationManagers)
                        {
                            if (station.stationType == 11)
                            {
                            // è¯»å–任务命令和设备命令
                                ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                                ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                                if (command != null && commandWrite != null)
                                {
                                // å°†äº¤äº’信号转换为布尔数组
                                    var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                                    if (structs[0] == true)
                                    {
                                    // è¾“出警告信息
                                        ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{station.stationChildCode}】空托盘请求扫码入库");
                                    // å¤„理入库请求
                                        NGRequestTaskInbound(conveyorLine, command, station.stationChildCode, 0, station.stationLocation);
                                    }
                                    else
                                    {
                                    // å‘送完成信号
                                    ConveyorLineSendFinish(conveyorLine, station.stationChildCode, 0, false);
                                }
                            }
                        }
                        else if (station.stationType == 5)
                        {
                            // è¯»å–任务命令和设备命令
                            ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                            ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                            if (command != null && commandWrite != null)
                            {
                                // å°†äº¤äº’信号转换为布尔数组
                                var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                                if (structs[0] == true)
                                {
                                    // æ£€æŸ¥æ˜¯å¦å­˜åœ¨ä»»åŠ¡
                                    if (_taskRepository.QueryData(x => x.SourceAddress == station.stationChildCode).Count() > 0)
                                    {
                                        return;
                                    }
                                    // è¾“出警告信息
                                    ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{station.stationChildCode}】异常口请求扫码入库");
                                    // å¤„理新任务
                                    await HandleNewTaskAsync(conveyorLine, command, station.stationChildCode, 0);
                                }
                                else
                                {
                                    // å‘送完成信号
                                        ConveyorLineSendFinish(conveyorLine, station.stationChildCode, 0, false);
                                    }
                                }
@@ -98,46 +140,68 @@
                }
                catch (Exception ex)
                {
                // è¾“出异常信息
                    Console.Out.WriteLine(nameof(CommonConveyorLineJob) + ":" + ex.ToString());
                }
                finally
                {
                    MemoryLockManager.ReleaseLock(jobName);
                }
            }
            else
            {
                ConsoleHelper.WriteErrorLine($"[CommonConveyorLineJob]【{jobName}】任务已被锁定，无法处理");
            }
            //    finally
            //    {
            //        MemoryLockManager.ReleaseLock(jobName);
            //    }
            // }
            // else
            // {
            //     ConsoleHelper.WriteErrorLine($"[CommonConveyorLineJob]【{jobName}】任务已被锁定，无法处理");
            // }
            return;
        }

        private Task ProcessDeviceAsync(CommonConveyorLine conveyorLine, string childDeviceCode)
        {
            // è¯»å–任务命令和设备命令
            ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(childDeviceCode);
            ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(childDeviceCode, "DeviceCommand");
            if (command != null && commandWrite != null)
            {

                #region è°ƒç”¨äº‹ä»¶æ€»çº¿é€šçŸ¥å‰ç«¯

                // èŽ·å–缓存中的用户信息
                if (userTokenIds == null && userIds == null)
                {
                var tokenInfos = _cacheService.Get<List<UserInfo>>("Cache_UserToken");
                if (tokenInfos != null && tokenInfos.Any())
                {
                    var userTokenIds = tokenInfos.Select(x => x.Token_ID).ToList();
                    var userIds = tokenInfos.Select(x => x.UserId).ToList();
                        userTokenIds = tokenInfos.Select(x => x.Token_ID).ToList();
                        userIds = tokenInfos.Select(x => x.UserId).ToList();

                        // æž„造通知数据
                    object obj = new
                    {
                        command,
                        commandWrite
                    };
                        // å‘送通知
                        _noticeService.LineData(userIds.FirstOrDefault(), userTokenIds, new { conveyorLine.DeviceName, childDeviceCode, data = obj });
                    }
                }
                else
                {
                    // æž„造通知数据
                    object obj = new
                    {
                        command,
                        commandWrite
                    };
                    // å‘送通知
                    _noticeService.LineData(userIds.FirstOrDefault(), userTokenIds, new { conveyorLine.DeviceName, childDeviceCode, data = obj });
                }

                #endregion è°ƒç”¨äº‹ä»¶æ€»çº¿é€šçŸ¥å‰ç«¯

                // å°†äº¤äº’信号转换为布尔数组
                var writeInteractiveSignal = commandWrite.WriteInteractiveSignal;
                var structs = BitConverter.GetBytes(writeInteractiveSignal).Reverse().ToArray().ToBoolArray();
                // èŽ·å–设备协议详情
                List<DeviceProtocolDetailDTO>? deviceProtocolDetails = conveyorLine.DeviceProtocolDetailDTOs.Where(x => x.DeviceProParamName == nameof(ConveyorLineTaskCommand.InteractiveSignal)).ToList();

                if (deviceProtocolDetails != null)
@@ -147,116 +211,48 @@
                        int itemValue = item.ProtocalDetailValue.ObjToInt();
                        if (structs[itemValue] == true)
                        {
                            var numRead = itemValue;
                            var numWrite = itemValue + 1;
                            ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】【{childDeviceCode}】【{numRead.ToString()}】位输送线读取信号：【{structs[itemValue]}】 ã€{numWrite}】位WCS写入信号：【{structs[itemValue + 1]}】");
                            if (structs[itemValue + 1] != structs[itemValue])
                            {
                            // èŽ·å–处理方法
                                MethodInfo? method = GetType().GetMethod(item.ProtocolDetailType);
                                if (method != null)
                                {
                                    command.InteractiveSignal = writeInteractiveSignal;
                                // è°ƒç”¨å¤„理方法
                                    method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, itemValue });
                                }
                            }
                        }
                        else
                        {
                            // å‘送完成信号
                            ConveyorLineSendFinish(conveyorLine, childDeviceCode, itemValue, false);
                        }
                    }
                }

                // æŸ¥è¯¢å¹³å°ä¿¡æ¯
                Platform platform = _platFormRepository.QueryFirst(x => x.PLCCode == conveyorLine.DeviceCode && x.PlatCode == childDeviceCode && x.Status == "Active");
                if (platform != null && !string.IsNullOrEmpty(platform.Location))
                {
                    var strings = platform.Location.Split(',').ToList();
                    foreach (var ite in strings)
                    {
                        // è¯»å–任务命令
                        ConveyorLineTaskCommand command1 = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(ite);
                        if (command1.InteractiveSignal != 2)
                        {
                            command.InteractiveSignal = writeInteractiveSignal;
                            int count = strings.Count;
                            // èŽ·å–处理方法
                            MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                            if (method != null)
                            {
                                command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                                // è°ƒç”¨å¤„理方法
                                method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                            };
                        }
                    }
                }

                #region
                //var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();

                //List<DeviceProtocolDetailDTO>? deviceProtocolDetails = conveyorLine.DeviceProtocolDetailDTOs.Where(x => x.DeviceProParamName == nameof(ConveyorLineTaskCommand.InteractiveSignal)).ToList();

                //if (deviceProtocolDetails != null)
                //{
                //    foreach (var item in deviceProtocolDetails)
                //    {
                //        if (structs[item.ProtocalDetailValue.ObjToInt()] == true)
                //        {
                //            MethodInfo? method = GetType().GetMethod(item.ProtocolDetailType);
                //            if (method != null)
                //            {
                //                var numRead = item.ProtocalDetailValue.ObjToInt();
                //                var numWrite = item.ProtocalDetailValue.ObjToInt() + 1;
                //                ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】【{childDeviceCode}】【{numRead.ToString()}】位输送线读取信号：【{structs[item.ProtocalDetailValue.ObjToInt()]}】 ã€{numWrite}】位WCS写入信号：【{structs[item.ProtocalDetailValue.ObjToInt() + 1]}】");
                //                if (structs[item.ProtocalDetailValue.ObjToInt() + 1] != structs[item.ProtocalDetailValue.ObjToInt()])
                //                {
                //                    command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                //                    method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, item.ProtocalDetailValue.ObjToInt() });
                //                }
                //            }
                //        }
                //        else
                //        {
                //            ConveyorLineSendFinish(conveyorLine, childDeviceCode, item.ProtocalDetailValue.ObjToInt(), false);
                //        }
                //    }
                //}

                //Platform platform = _platFormRepository.QueryFirst(x => x.PLCCode == conveyorLine.DeviceCode && x.PlatCode == childDeviceCode && x.Status == "Active");
                //if (platform != null)
                //{
                //    if (command.InteractiveSignal != 2)
                //    {
                //        MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                //        if (method != null)
                //        {
                //            command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                //            int count = string.IsNullOrEmpty(platform.Location) ? 0 + 1 : platform.Location.Split(',').Count() + 1;
                //            method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                //        }
                //    }
                //    else
                //    {
                //        if (platform.Location != null && platform.Location != "")
                //        {
                //            var strings = platform.Location.Split(',').ToList();
                //            foreach (var ite in strings)
                //            {
                //                //int index = strings.FindIndex(p => p == ite);
                //                ConveyorLineTaskCommand command1 = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(ite);
                //                if (command1.InteractiveSignal != 2)
                //                {
                //                    MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                //                    if (method != null)
                //                    {
                //                        command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                //                        //int count = strings.Count - index;
                //                        int count = strings.Count;
                //                        method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                //                    }
                //                }
                //            }
                //        }
                //    }
                //}
                #endregion
            }
            return Task.CompletedTask;
        }
@@ -270,44 +266,62 @@
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        public void RequestInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        public async Task RequestInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            try
            {
                ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库");
                // è¾“出警告信息，表示任务已到达子设备并请求扫码入库
                var log = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库";
                ConsoleHelper.WriteWarningLine(log);
                // å‘送通知
                await _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "red" });
                WriteInfo(conveyorLine.DeviceName, log);

                // æŸ¥è¯¢æ¡ç å¯¹åº”的任务
                var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
                if (task != null)
                {
                    // å¦‚果任务类型是出库或出托盘，则处理出库任务
                    if (task.TaskType == (int)TaskOutboundTypeEnum.OutTray || task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
                    {
                        HandleTaskOut(conveyorLine, command, childDeviceCode, ProtocalDetailValue, task);
                    }
                    else
                    {
                        // èŽ·å–任务的下一目标地址
                        var next = task.NextAddress;
                        // å°†ä»»åŠ¡æ˜ å°„为命令
                        var taskCommand = MapTaskCommand(task, command);
                        // æ¢å¤ä»»åŠ¡çš„下一目标地址
                        task.NextAddress = next;
                        // å‘送命令到子设备
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        // è¾“出警告信息，表示任务已到达子设备并请求扫码入库，下一目标地址
                        ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库,下一目标地址【{taskCommand.TargetAddress}】");

                        // å‘送任务完成通知
                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                        // æ›´æ–°ä»»åŠ¡çŠ¶æ€ä¸ºä¸‹ä¸€çŠ¶æ€
                        _taskService.UpdateTaskStatusToNext(task);
                    }
                }
                else
                {
                    // å¦‚果任务为空且条码不为"NoRead"且条码不为空，则处理新任务
                    if (task == null && command.Barcode != "NoRead" && command.Barcode.IsNotEmptyOrNull())
                    {
                        // æŸ¥è¯¢æ¡ç å¯¹åº”的任务
                        task = _taskService.QueryBarcodeTask(command.Barcode, childDeviceCode);
                        if (task == null)
                            HandleNewTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
                            // å¼‚步处理新任务
                            await HandleNewTaskAsync(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
                    }
                }
            }
            catch (Exception ex)
            {
                // æ•èŽ·å¹¶è¾“出异常信息
                Console.Out.WriteLine(ex.ToString());
            }
        }
@@ -322,6 +336,7 @@
        /// <param name="childDeviceCode">子设备编号</param>
        public void RequestInNextAddress(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        {
            ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求入库下一地址");
            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null)
            {
@@ -361,7 +376,10 @@
            {
                if (command.Barcode == task.PalletCode && childDeviceCode == task.NextAddress)
                {
                    ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成,下一目标地址【等待分配货位】");
                    //conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, "1000", childDeviceCode);

                    ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成,下一目标地址【等待分配货位,并写入1000】");

                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                    if (task.TaskType == (int)TaskInboundTypeEnum.InNG)
@@ -399,31 +417,40 @@
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        public void RequestOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            // æŸ¥è¯¢è¾“送线任务，根据输送线设备和子设备代码获取任务信息
            var task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);

            // è¾“出成功信息，包括输送线名称、任务号、托盘条码和子设备代码，以及任务信息
            ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,task{task.ToJsonString()}");

            // å¦‚果任务不为空，则执行以下操作
            if (task != null)
            {
                //if (command.Barcode == task.PalletCode)
                {
                    //task.NextAddress = task.NextAddress.Replace("-1", "");
                    //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                    //taskCommand.InteractiveSignal = command.InteractiveSignal;

                    //ConveyorLineTaskCommand taskCommand = MapTaskCommand(task, command);

                // èŽ·å–任务的下一目标地址
                    var next = task.NextAddress;

                // å°†ä»»åŠ¡å‘½ä»¤æ˜ å°„到当前任务
                    var taskCommand = MapTaskCommand(task, command);

                // æ¢å¤ä»»åŠ¡çš„下一目标地址
                    task.NextAddress = next;

                // è¾“出成功信息，包括输送线名称、任务号、托盘条码、子设备代码和下一目标地址
                    ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,下一目标地址【{taskCommand.TargetAddress}】");

                // å‘输送线发送命令
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);

                // å®Œæˆè¾“送线发送任务，并更新任务状态
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                // æ›´æ–°ä»»åŠ¡çŠ¶æ€åˆ°ä¸‹ä¸€ä¸ªçŠ¶æ€
                    _taskService.UpdateTaskStatusToNext(task);

                // å¦‚果任务的目标地址是"1020-1"，则再次更新任务状态到下一个状态
                    if (task.TargetAddress == "1020-1")
                    {
                        _taskService.UpdateTaskStatusToNext(task);
                    }
                }
            }
        }
@@ -436,26 +463,40 @@
        /// <param name="childDeviceCode">子设备编号</param>
        public void RequestOutNextAddress(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            // æ‰“印成功日志，显示当前设备名称、任务号、托盘条码以及请求出库下一地址的子设备代码
            ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库下一地址");

            // æŸ¥è¯¢æ­£åœ¨æ‰§è¡Œçš„输送线任务，根据任务号和子设备代码获取任务信息
            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);

            // å¦‚果任务存在
            if (task != null)
            {
                // æ£€æŸ¥ä»»åŠ¡ä¸­çš„托盘条码是否与命令中的托盘条码一致
                if (command.Barcode == task.PalletCode)
                {
                    // æ›´æ–°ä»»åŠ¡çš„位置信息，并获取更新后的任务对象
                    Dt_Task? newTask = _taskService.UpdatePosition(task.TaskNum, task.CurrentAddress);

                    // å¦‚果更新后的任务对象不为空
                    if (newTask != null)
                    {
                        //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(newTask);
                        //taskCommand.InteractiveSignal = command.InteractiveSignal;

                        //ConveyorLineTaskCommand taskCommand = MapTaskCommand(newTask, command);

                        // èŽ·å–下一目标地址
                        var next = newTask.NextAddress;

                        // å°†æ–°ä»»åŠ¡å¯¹è±¡æ˜ å°„为任务命令对象
                        var taskCommand = MapTaskCommand(newTask, command);

                        // æ¢å¤æ–°ä»»åŠ¡å¯¹è±¡çš„下一目标地址
                        newTask.NextAddress = next;

                        // æ‰“印成功日志，显示当前设备名称、任务号、托盘条码、子设备代码以及下一目标地址
                        ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库下一地址,下一目标地址【{taskCommand.TargetAddress}】");

                        // å‘送任务命令到子设备
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        // æ ‡è®°è¾“送线发送任务完成
                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    }
                }
@@ -470,34 +511,63 @@
        /// <param name="childDeviceCode">子设备编号</param>
        public void ConveyorLineOutFinish(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            // æ‰“印成功信息，表示托盘已到达指定输送线并完成出库
            ConsoleHelper.WriteSuccessLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成");

            // æŸ¥è¯¢æ­£åœ¨æ‰§è¡Œçš„输送线任务
            var task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);

            // å¦‚果任务存在
            if (task != null)
            {
                // å¦‚果任务中的托盘条码与命令中的托盘条码一致
                if (command.Barcode == task.PalletCode)
                {
                    // åˆ›å»ºä¸€ä¸ªç©ºçš„WebResponseContent对象
                    WebResponseContent content = new WebResponseContent();
                    //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                    //taskCommand.InteractiveSignal = command.InteractiveSignal;
                    //ConveyorLineTaskCommand taskCommand = MapTaskCommand(task, command);

                    // ä¿å­˜ä»»åŠ¡çš„下一目标地址
                    var next = task.NextAddress;
                    // å°†ä»»åŠ¡æ˜ å°„为命令
                    var taskCommand = MapTaskCommand(task, command);
                    // æ¢å¤ä»»åŠ¡çš„下一目标地址
                    task.NextAddress = next;

                    // å¦‚果任务的托盘条码与命令中的托盘条码不一致或者任务备注为"NG"
                    if (task.PalletCode != command.Barcode || task.Remark == "NG")
                    {
                        // æŸ¥è¯¢ç›®æ ‡åœ°å€çš„容量
                        var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == task.TargetAddress).Capacity;
                        // è®¾ç½®å‘½ä»¤çš„目标地址为NG地址
                        taskCommand.TargetAddress = NGAddress;
                    }
                    else
                    {
                        // è®¾ç½®å‘½ä»¤çš„目标地址为1000
                        taskCommand.TargetAddress = 1000;
                    }

                    // æ‰“印成功信息，表示托盘已到达指定输送线并完成出库，下一目标地址已确定
                    ConsoleHelper.WriteSuccessLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成,下一目标地址【{taskCommand.TargetAddress}】");
                    // å‘送命令到输送线
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    // å®Œæˆè¾“送线发送
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    // æ›´æ–°ä»»åŠ¡çŠ¶æ€åˆ°ä¸‹ä¸€ä¸ªçŠ¶æ€
                    content = _taskService.UpdateTaskStatusToNext(task);
                }
                else
                {
                    // æŸ¥è¯¢ç›®æ ‡åœ°å€çš„容量
                    var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == task.TargetAddress).Capacity;
                    // æ‰“印成功信息，表示托盘已到达指定输送线并完成出库，下一目标地址已确定
                    ConsoleHelper.WriteSuccessLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成,下一目标地址【{NGAddress}】");
                    // è®¾ç½®è¾“送线的目标地址为NG地址
                    conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, NGAddress, childDeviceCode);
                    // å®Œæˆè¾“送线发送
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    // æ›´æ–°ä»»åŠ¡çŠ¶æ€åˆ°ä¸‹ä¸€ä¸ªçŠ¶æ€
                    _taskService.UpdateTaskStatusToNext(task);
                }
            }
        }
@@ -513,10 +583,21 @@
        /// <param name="value">值</param>
        public void ConveyorLineSendFinish(CommonConveyorLine conveyorLine, string childDeviceCode, int ProtocalDetailValue, bool value)
        {
            // ä»ŽconveyorLine中的DeviceProDTOs列表中查找第一个符合条件的DeviceProDTO对象
            // æ¡ä»¶æ˜¯DeviceProParamType等于DeviceCommand，且DeviceChildCode等于childDeviceCode
            // æŸ¥æ‰¾ç»“果按DeviceProOffset升序排列
            DeviceProDTO? devicePro = conveyorLine.DeviceProDTOs.Where(x => x.DeviceProParamType == nameof(DeviceCommand) && x.DeviceChildCode == childDeviceCode).OrderBy(x => x.DeviceProOffset).FirstOrDefault();

            // å°†devicePro的DeviceProAddress按'.'分割成字符串数组x
            string[] x = devicePro.DeviceProAddress.Split('.');

            // å°†æ•°ç»„x的最后一个元素替换为ProtocalDetailValue加1后的字符串形式
            x[x.Length - 1] = (ProtocalDetailValue + 1).ToString();

            // å°†ä¿®æ”¹åŽçš„数组x重新拼接成字符串，作为新的DeviceProAddress
            string DeviceProAddress = string.Join(".", x);

            // ä½¿ç”¨conveyorLine的Communicator对象的Write方法，将value写入新的DeviceProAddress地址
            conveyorLine.Communicator.Write(DeviceProAddress, value);
        }

@@ -529,19 +610,24 @@
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="index">线体当前bool读取偏移地址</param>
        // å®šä¹‰ä¸€ä¸ªå¼‚步方法，用于处理空托盘返回任务
        public async void EmptyTrayReturn(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int index, Platform platform)
        {
            try
            {
                // å®šä¹‰ä»»åŠ¡ç±»åž‹æžšä¸¾å˜é‡
                TaskOutboundTypeEnum taskOutboundTypeEnum;
                // æ ¹æ®å¹³å°ç±»åž‹è®¾ç½®ä»»åŠ¡ç±»åž‹æžšä¸¾
                if (platform.PlatformType.Contains("OutTray"))
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.OutTray;
                else
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.Outbound;
                // è°ƒç”¨æ£€æŸ¥å¹¶åˆ›å»ºä»»åŠ¡çš„方法
                await CheckAndCreateTask(taskOutboundTypeEnum, childDeviceCode, index, platform.Stacker, platform);
            }
            catch (Exception)
            {
                // æ•èŽ·å¹¶å¿½ç•¥å¼‚常
            }
        }

@@ -550,38 +636,44 @@
        /// </summary>
        private async Task CheckAndCreateTask(TaskOutboundTypeEnum taskType, string childDeviceCode, int index, string roadWay, Platform platform)
        {
            // æŸ¥è¯¢æ•°æ®åº“中已有的任务
            var tasks = _taskRepository.QueryData(x => x.TaskType == (int)taskType && x.TargetAddress == childDeviceCode);
            // å¦‚果已有任务数量小于指定索引
            if (tasks.Count < index)
            {
                //ConsoleHelper.WriteErrorLine($"【{childDeviceCode}】请求【{taskType.ToString()}】任务,已有【{taskType.ToString()}】任务【{tasks.Count}】,最多拥有【{index - 1}】");
                // è°ƒç”¨WMS获取出库任务

                #region è°ƒç”¨WMS获取出库任务

                // å®šä¹‰WMS任务数据传输对象
                WMSTaskDTO taskDTO = new WMSTaskDTO();

                // èŽ·å–WMSip地址
                // èŽ·å–WMS IP地址配置
                var config = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
                var wmsBase = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.WMSIP_BASE)?.ConfigValue;
                var requestTrayOutTask = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.RequestTrayOutTask)?.ConfigValue;
                // å¦‚æžœWMS IP地址未配置，抛出异常
                if (wmsBase == null || requestTrayOutTask == null)
                {
                    throw new InvalidOperationException("WMS IP æœªé…ç½®");
                }
                var wmsIpAddress = wmsBase + requestTrayOutTask;

                // å‘送HTTP POST请求获取任务数据
                var result = await HttpHelper.PostAsync(wmsIpAddress, new { position = childDeviceCode, tag = (int)taskType, areaCdoe = roadWay, platform.ProductionLine }.ToJsonString());
                //var result = await HttpHelper.PostAsync("http://localhost:5000/api/Task/RequestTrayOutTaskAsync", dynamic.ToJsonString());

                // è§£æžè¿”回的JSON数据
                WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);

                // æ£€æŸ¥çŠ¶æ€å¹¶è¿”回
                // æ£€æŸ¥è¿”回状态，如果失败则返回
                if (!content.Status)
                    return;

                // è§£æžä»»åŠ¡æ•°æ®
                taskDTO = JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());

                #endregion è°ƒç”¨WMS获取出库任务

                // åˆ›å»ºå¹¶å‘送任务
                CreateAndSendTask(taskDTO);
            }
        }
@@ -601,7 +693,7 @@

        #endregion æ£€æµ‹ç©ºç›˜å®žç›˜ä»»åŠ¡

        #region åŒ–成NG口入库
        #region è®¾å¤‡NG口入库

        public void NGRequestTaskInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue, string TargetAddress)
        {
@@ -632,6 +724,9 @@
            WriteInfo("入站校验", $"【{childDeviceCode}】入站校验返回参数【{result}】");
            ResultTrayCellsStatus result1 = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(result);

            if (result1.Success)
            {

            var serialNosError = result1.SerialNos.Where(x => x.SerialNoStatus != 1).ToList();
            if (serialNosError.Count > 0)
            {
@@ -648,10 +743,6 @@
                    NextAddress = TargetAddress,
                    TaskNum = 0
                };
                //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(dt_Task);
                //taskCommand.InteractiveSignal = command.InteractiveSignal;

                //ConveyorLineTaskCommand taskCommand = MapTaskCommand(dt_Task, command);

                var next = dt_Task.NextAddress;
                var taskCommand = MapTaskCommand(dt_Task, command);
@@ -663,21 +754,16 @@
            }
            else
            {
                // ç©ºæ‰˜ç›˜å…¥åº“逻辑
                Dt_Task dt_Task = new Dt_Task()
                {
                    TargetAddress = TargetAddress,
                    PalletCode = command.Barcode,
                    NextAddress = "1000",
                    TaskNum = 0
                };
                ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(dt_Task);
                taskCommand.InteractiveSignal = command.InteractiveSignal;
                conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, 1000, childDeviceCode);

                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
            }
        }
            else
            {

            }
        }

        #endregion åŒ–成NG口入库
    }

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

@@ -50,7 +50,7 @@
        /// <summary>
        /// å¤„理新任务
        /// </summary>
        private async void HandleNewTask(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        private async Task HandleNewTaskAsync(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            var stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == childDeviceCode && x.stationPLC == conveyorLine.DeviceCode);

@@ -79,19 +79,6 @@
                default:
                    break;
            }

            //if ((conveyorLine.DeviceCode == "1003" && childDeviceCode == "1016") || (conveyorLine.DeviceCode == "1005" && childDeviceCode == "1048"))
            //{
            //    await CreateAndSendEmptyTrayTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
            //}
            //else if ((conveyorLine.DeviceCode == "1001" && childDeviceCode == "1088") || (conveyorLine.DeviceCode == "1004" && childDeviceCode == "1339"))
            //{
            //    await RequestWmsTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
            //}
            //else if ((conveyorLine.DeviceCode == "1001" && childDeviceCode == "1068"))
            //{
            //    ConveyorLineOutFinish(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
            //}
        }

        /// <summary>
@@ -221,18 +208,15 @@
                var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
                if (task != null)
                {
                    if (task.NextAddress.Contains("JZ"))
                    if (task.SourceAddress == "1059-4")
                    {
                        int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskInStatusEnum>();
                        task.TaskState = nextStatus;
                        //conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, "1000", childDeviceCode);

                        ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{task.TaskNum}】,托盘条码：【{task.PalletCode}】已到达【{childDeviceCode}】请求扫码入库(实盘),下一目标地址【{task.TargetAddress}】");
                        _taskService.UpdateTaskStatusToNext(task);
                        ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{task.TaskNum}】,托盘条码：【{task.PalletCode}】已到达【{childDeviceCode}】请求扫码入库(实盘),下一目标地址【{1000}】");
                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    }
                    else
                    {
                        //var taskCommand = MapTaskCommand(task, command);
                        var next = task.NextAddress;
                        var taskCommand = MapTaskCommand(task, command);
                        task.NextAddress = next;

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

@@ -1,21 +1,15 @@
using Autofac.Core;
using HslCommunication;
using Mapster;
using Newtonsoft.Json;
using Mapster;
using Quartz;
using System.Diagnostics.CodeAnalysis;
using System.Threading.Tasks;
using WIDESEAWCS_BasicInfoRepository;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core.Caches;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.HttpContextUser;
using WIDESEAWCS_DTO.MOM;
using WIDESEAWCS_IProcessRepository;
using WIDESEAWCS_ITaskInfo_HtyRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DeviceBase;
@@ -98,11 +92,8 @@
                    #region è°ƒç”¨äº‹ä»¶æ€»çº¿é€šçŸ¥å‰ç«¯

                    var tokenInfos = _cacheService.Get<List<UserInfo>>("Cache_UserToken");
                    if (tokenInfos == null || !tokenInfos.Any())
                    if (tokenInfos != null && tokenInfos.Any())
                    {
                        //throw new Exception(commonStackerCrane.DeviceName + "缓存中未找到Token缓存");
                        return Task.CompletedTask;
                    }
                    var userTokenIds = tokenInfos?.Select(x => x.Token_ID).ToList();
                    var userIds = tokenInfos?.Select(x => x.UserId).ToList();

@@ -117,9 +108,9 @@
                        commonStackerCrane.LastTaskNum,
                    };
                    _noticeService.StackerData(userIds?.FirstOrDefault(), userTokenIds, new { commonStackerCrane.DeviceName, data = obj });
                    }

                    #endregion è°ƒç”¨äº‹ä»¶æ€»çº¿é€šçŸ¥å‰ç«¯

                }
            }
            catch (Exception ex)
@@ -321,7 +312,6 @@
            return null;
        }


        /// <summary>
        /// æŸ¥æ‰¾å…¶ä»–出库任务的辅助方法（排除指定任务ID的任务）
        /// </summary>
@@ -370,6 +360,37 @@
            stackerCraneTaskCommand.StartCommand = 1;
            if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)//判断是否是入库任务
            {
                if (task.SourceAddress == "1359-4" && task.Roadway.Contains("JZ"))
                {
                    string[] souredCodes = task.CurrentAddress.Split("-");
                    if (souredCodes.Length == 3)
                    {
                        stackerCraneTaskCommand.StartRow = Convert.ToInt16(souredCodes[0]);
                        stackerCraneTaskCommand.StartColumn = Convert.ToInt16(souredCodes[1]);
                        stackerCraneTaskCommand.StartLayer = Convert.ToInt16(souredCodes[2]);
                    }
                    else
                    {
                        //数据配置错误
                        _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务起点错误，起点：【{task.CurrentAddress}】");
                        return null;
                    }
                    string[] targetCodes = task.NextAddress.Split("-");
                    if (targetCodes.Length == 3)
                    {
                        stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]) % 2 != 0 ? (short)1 : (short)2;
                        stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
                        stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);
                    }
                    else
                    {
                        //数据配置错误
                        _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务终点错误，起点：【{task.NextAddress}】");
                        return null;
                    }
                }
                else
                {
                List<Dt_Router> routers = _routerService.QueryNextRoutes(task.CurrentAddress, task.Roadway);
                if (routers.Count > 0)
                {
@@ -397,9 +418,23 @@
                    return null;
                }
            }
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
            {
                if (task.Roadway.Contains("GW"))
                {
                    string[] endCodes = task.NextAddress.Split("-");
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(endCodes[0]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(endCodes[1]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(endCodes[2]);
                    string[] sourceCodes = task.SourceAddress.Split("-");
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]) % 2 != 0 ? (short)1 : (short)2;
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                }
                else
                {
                    if (task.TargetAddress == "002-021-001" && task.Roadway.Contains("JZ") && task.TaskType == (int)TaskOutboundTypeEnum.OutTray)
                {
                    string[] endCodes = task.NextAddress.Split("-");
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(endCodes[0]);
@@ -440,6 +475,7 @@
                    }
                }
            }
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
            {
                string[] targetCodes = task.NextAddress.Split("-");
@@ -471,6 +507,5 @@
            }
            return stackerCraneTaskCommand;
        }

    }
}

 Code Management/WMS/WIDESEA_WMSClient/src/api/http.js

@@ -11,8 +11,8 @@
let loadingInstance
let loadingStatus = false
if (process.env.NODE_ENV == 'development') {
  axios.defaults.baseURL = 'http://localhost:5000/';
  // axios.defaults.baseURL = 'http://192.168.20.251:5000/';
  // axios.defaults.baseURL = 'http://localhost:5000/';
  axios.defaults.baseURL = 'http://192.168.5.251:5000/';
}
else if (process.env.NODE_ENV == 'debug') {
  axios.defaults.baseURL = 'http://127.0.0.1:9991/';

 Code Management/WMS/WIDESEA_WMSClient/src/views/widesea_wms/stock/Dt_BillGroupStock.vue

@@ -53,7 +53,7 @@
            [{ field: 'id', title: '库存ID', type: 'int', width: 110, hidden: true, readonly: true, require: true, align: 'left' },
            { field: 'locationCode', title: '库位', type: 'string', width: 110, align: 'left',  },
            { field: 'palletCode', title: '托盘条码', type: 'string', width: 110, align: 'left', },
            { field: 'isFull', title: '库存类型', type: 'bool', width: 110, align: 'left', bind: { key: "isFull", data: [] }, },
            { field: 'isFull', title: '库存类型', type: 'bool', width: 110, align: 'left', bind: { key: "isFull", data: [{ key: false, value: '空盘'},{ key: true, value: '实盘'}] }, },
            { field: 'linedProcessFeedbackTime', title: '工艺开始时间', type: 'string', width: 110, align: 'left',},
            { field: 'specialParameterDuration', title: '工艺时长', type: 'string', width: 110, align: 'left', sort: true },
            { field: 'outboundTime', title: '应出库时间', type: 'string', width: 110, align: 'left', sort: true  },

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseServices/ServiceBase.cs

@@ -130,9 +130,22 @@
                if (expressionType == LinqExpressionType.Equal)
                {
                    if (string.IsNullOrEmpty(where))
                    {
                        // é’ˆå¯¹å­—符串类型的字段使用模糊查询
                        where += $"{searchParametersList[i].Name} like '%{searchParametersList[i].Value}%'";
                    }
                    else
                        where += $" and {searchParametersList[i].Name} = '{searchParametersList[i].Value}'";
                    {
                        // é’ˆå¯¹å¸ƒå°”类型字段进行精确查询
                        if (searchParametersList[i].Value.ToLower() == "true" || searchParametersList[i].Value.ToLower() == "false")
                        {
                            where += $" and {searchParametersList[i].Name} = {searchParametersList[i].Value.ToLower()}";
                        }
                        else
                        {
                            where += $" and {searchParametersList[i].Name} like '%{searchParametersList[i].Value}%'";
                        }
                    }
                }
                else
                {

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

@@ -190,6 +190,14 @@
    Task<WebResponseContent> CreateAndSendOutboundTask(string locationCode, string palletCode);

    /// <summary>
    /// æŒ‡å®šä»»åŠ¡å‡ºåº“
    /// </summary>
    /// <param name="palletCode">托盘号</param>
    /// <param name="position">位置</param>
    /// <returns></returns>
    Task<WebResponseContent> CreateAndSendInboundTask(string palletCode, string position);

    /// <summary>
    /// å¸¸æ¸©è¡¥ç©ºæ‰˜ç›˜è‡³åˆ†å®¹
    /// </summary>
    /// <param name="taskDTO"></param>

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

@@ -1,6 +1,7 @@
using Mapster;
using Masuit.Tools;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WIDESEA_Core.Const;
using WIDESEA_DTO.MOM;
using WIDESEA_DTO.WMS;
@@ -285,7 +286,7 @@
        WebResponseContent content = new WebResponseContent();
        try
        {
            if (task.TaskType == (int)TaskInboundTypeEnum.InNG)
            if (task.TaskType == (int)TaskInboundTypeEnum.InNG || task.TaskType == (int)TaskInboundTypeEnum.InQuality)
            {
                task.TaskState = (int)TaskInStatusEnum.SC_InFinish;
                // åˆ›å»ºåŽ†å²ä»»åŠ¡å®žä¾‹æ¨¡åž‹
@@ -539,6 +540,7 @@
            case (int)TaskInboundTypeEnum.Inbound:
            case (int)TaskInboundTypeEnum.InTray:
            case (int)TaskInboundTypeEnum.InNG:
            case (int)TaskInboundTypeEnum.InQuality:
                LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务", "");
                return await CompleteInboundTaskAsync(task);

@@ -1325,7 +1327,7 @@

    #region é™ç½®å¼‚常口入库

    public async Task<WebResponseContent> CreateAndSendInboundTask(string locationCode, string palletCode, string position)
    public async Task<WebResponseContent> CreateAndSendInboundTask(string palletCode, string position)
    {
        WebResponseContent content = new WebResponseContent();
        try
@@ -1334,22 +1336,40 @@
            var stockInfo = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == palletCode);
            if (stockInfo == null)
            {
                var taskOld = BaseDal.QueryFirst(x => x.PalletCode == palletCode);
                if (!taskOld.IsNullOrEmpty())
                {// åˆ›å»ºWMS任务
                    WMSTaskDTO taskDTO = new WMSTaskDTO()
                    {
                        TaskNum = taskOld.TaskNum.Value,
                        Grade = 1,
                        PalletCode = taskOld.PalletCode,
                        RoadWay = taskOld.Roadway,
                        SourceAddress = taskOld.CurrentAddress,
                        TargetAddress = taskOld.TargetAddress,
                        TaskState = taskOld.TaskState.Value,
                        Id = 0,
                        TaskType = taskOld.TaskType,
                    };
                    return content.OK(data: taskDTO);
                }
                var area = _areaInfoRepository.QueryFirst(x => x.AreaID == 2);
                var station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == position);
                TrayCellsStatusDto trayCells = CreateTrayCellsStatusDto(area, palletCode);
                content = await GetTrayCellStatusAsync(trayCells);
                if (!content.Status) return content;

                ConsoleHelper.WriteErrorLine(content.ToJsonString());
                var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
                if (!result.Success)
                {
                    if (result.SerialNos.Count <= 0)
                if (result.SerialNos.Count > 0)
                    {
                        var location = await GetLocationDistributeAsync(station.Roadway);

                    ConsoleHelper.WriteErrorLine(location.ToJsonString());
                        // åˆ›å»ºæ–°ä»»åŠ¡å®žä¾‹
                        var task = new Dt_Task
                        {
                            CurrentAddress = locationCode,
                        CurrentAddress = station.stationLocation,
                            Grade = 1,
                            Roadway = station.Roadway,
                            TargetAddress = location.LocationCode,
@@ -1358,7 +1378,7 @@
                            NextAddress = location.LocationCode,
                            OrderNo = null,
                            PalletCode = palletCode,
                            SourceAddress = locationCode,
                        SourceAddress = position,
                            TaskState = (int)TaskInStatusEnum.Line_InFinish,
                            TaskType = (int)TaskInboundTypeEnum.Inbound,
                            TaskNum = await BaseDal.GetTaskNo(),
@@ -1373,7 +1393,7 @@
                            PalletCode = task.PalletCode,
                            RoadWay = task.Roadway,
                            SourceAddress = task.SourceAddress,
                            TargetAddress = task.Roadway,
                        TargetAddress = task.TargetAddress,
                            TaskState = task.TaskState.Value,
                            Id = 0,
                            TaskType = task.TaskType,
@@ -1392,7 +1412,6 @@
                    }
                    else
                        content.Error(result.MOMMessage);
                }
            }
            else
            {
@@ -1690,6 +1709,14 @@
            var content = new WebResponseContent();

            // èŽ·å–目标地址和更新任务状态


            input.Position = Regex.Replace(input.Position, @"-(\d+)", "");
            if (Convert.ToInt32(input.Position) > 1999)
            {
                input.Position = (Convert.ToInt32(input.Position) - 1000).ToString();
            }

            if (task.TaskType == (int)TaskInboundTypeEnum.InNG)
            {
                // TODO æ ¹æ®å··é“查找对应NG口，现在默认去静置堆垛机的异常口货位号
@@ -1702,7 +1729,7 @@
            }
            else if (task.TaskType == (int)TaskInboundTypeEnum.InQuality)
            {
                var stockInfo = _stockInfoRepository.QueryFirst(x => x.PalletCode == input.PalletCode);
                var stockInfo = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == input.PalletCode);
                task.CurrentAddress = input.Position;
                task.TargetAddress = stockInfo.LocationInfo.LocationCode;
                task.NextAddress = stockInfo.LocationInfo.LocationCode;

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageTaskServices/Task/Partial/RequestInTaskAsync.cs

@@ -44,7 +44,7 @@
        //var station = stationManagers.Select(x => x.stationChildCode).ToList();

        //// èŽ·å–WCSip地址相关配置
        //var wcsIpAddrss = GetWCSIpAddress();
        var wcsIpAddrss = GetWCSIpAddress();
        //if (wcsIpAddrss == null)
        //{
        //    throw new InvalidOperationException("WCS IP æœªé…ç½®");

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

@@ -146,6 +146,18 @@
    }

    /// <summary>
    /// é™ç½®NG入库
    /// </summary>
    /// <param name="locationCode">货位号</param>
    /// <param name="palletCode">托盘号</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestInBoundTaskNG")]
    public async Task<WebResponseContent> RequestInBoundTaskNG([FromBody] RequestTaskDto input)
    {
        return await Service.CreateAndSendInboundTask(input.PalletCode, input.Position);
    }

    /// <summary>
    /// å¸¸æ¸©è¡¥ç©ºæ‰˜ç›˜è‡³åˆ†å®¹
    /// </summary>
    /// <param name="input">请求数据</param>

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/appsettings.json

@@ -10,9 +10,9 @@
  "MainDB": "DB_WIDESEA", //当前项目的主库，所对应的连接字符串的Enabled必须为true
  //连接字符串
  //"ConnectionString": "HTI6FB1H05Krd07mNm9yBCNhofW6edA5zLs9TY~MNthRYW3kn0qKbMIsGp~3yyPDF1YZUCPBQx8U0Jfk4PH~ajNFXVIwlH85M3F~v_qKYQ3CeAz3q1mLVDn8O5uWt1~3Ut2V3KRkEwYHvW2oMDN~QIDXPxDgXN0R2oTIhc9dNu7QNaLEknblqmHhjaNSSpERdDVZIgHnMKejU_SL49tralBkZmDNi0hmkbL~837j1NWe37u9fJKmv91QPb~16JsuI9uu0EvNZ06g6PuZfOSAeFH9GMMIZiketdcJG3tHelo=",
  //"ConnectionString": "Data Source=192.168.5.251;Initial Catalog=WIDESEA_WMSDB_BBMain;User ID=sa;Password=P@ssw0rd;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  "ConnectionString": "Data Source=192.168.5.251;Initial Catalog=WIDESEA_WMSDB_BBMain;User ID=sa;Password=P@ssw0rd;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  //"ConnectionString": "Data Source=127.0.0.1;Initial Catalog=WIDESEA_WMS2F08;User ID=sa;Password=P@ssw0rd;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  "ConnectionString": "Data Source=.\\LIULEI;Initial Catalog=WIDESEA_WMSDB_BBMain;User ID=sa;Password=123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  //"ConnectionString": "Data Source=.\\LIULEI;Initial Catalog=WIDESEA_WMSDB_BBMain;User ID=sa;Password=123456;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  //"ConnectionString": "Data Source=192.168.20.251;Initial Catalog=WIDESEA_WMSDB;User ID=sa;Password=123456@gy;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",

  //跨域