Merge branch 'master' of http://115.159.85.185:8098/r/SuZhouGuanHong/ShanMe...

wanshenmean

2026-03-30 1faef6894400be9923b24038fddb7f9218bd7b6b

Merge branch 'master' of http://115.159.85.185:8098/r/SuZhouGuanHong/ShanMeiXinNengYuan

 Code/WMS/WIDESEA_WMSClient/src/views/taskinfo/task.vue

@@ -48,7 +48,7 @@
        { title: "创建人", field: "creater", type: "like" },
      ],
      [
        { title: "任务类型",field: "taskType",type: "selectList",dataKey: "taskType",data: [],},
        { title: "任务类型",field: "taskType",type: "selectList",dataKey: "taskTypeEnum",data: [],},
        { title: "任务状态",field: "taskStatus",type: "selectList",dataKey: "taskStatusEnum",data: [],},
        { title: "巷道号", field: "roadway", type: "like" },
      ],
@@ -96,7 +96,7 @@
        type: "int",
        width: 120,
        align: "left",
        bind: { key: "taskType", data: [] },
        bind: { key: "taskTypeEnum", data: [] },
      },
      {
        field: "taskStatus",

 Code/WMS/WIDESEA_WMSServer/WIDESEA_Common/LocationEnum/LocationTypeEnum.cs

@@ -19,15 +19,15 @@
        Undefined = 0,

        /// <summary>
        /// å°æ‰˜ç›˜
        /// æ¨¡åˆ‡æ®µ
        /// </summary>
        [Description("小托盘")]
        [Description("模切段")]
        SmallPallet = 1,

        /// <summary>
        /// ä¸­æ‰˜ç›˜
        /// å·ç»•æ®µ
        /// </summary>
        [Description("中托盘")]
        [Description("卷绕段")]
        MediumPallet = 2,

        /// <summary>

 Code/WMS/WIDESEA_WMSServer/WIDESEA_Common/WareHouseEnum/WarehouseEnum.cs

@@ -9,68 +9,45 @@
{
    /// <summary>
    /// ä»“库
    /// HA57 = æ·®å®‰äºŒåŽ‚ - æ¿æ–™ä»“<br/>
    /// HA58 = æ·®å®‰äºŒåŽ‚ - PP仓<br/>
    /// HA60 = æ·®å®‰äºŒåŽ‚ - è¾…料仓<br/>
    /// HA64 = æ·®å®‰äºŒåŽ‚ - æµ‹è¯•æž¶ä»“<br/>
    /// HA71 = æ·®å®‰äºŒåŽ‚ - æˆå“ä»“<br/>
    /// HA72 = æ·®å®‰äºŒåŽ‚ - å°¾æ•°ä»“<br/>
    /// HA73 = æ·®å®‰äºŒåŽ‚ - ç ”发仓<br/>
    /// HA101 = æ·®å®‰äºŒåŽ‚ - æˆå“ä»“平库<br/>
    /// HA152 = æ·®å®‰äºŒåŽ‚ - å¹²è†œä»“<br/>
    /// HA153 = æ·®å®‰äºŒåŽ‚ - æ²¹å¢¨ä»“<br/>
    /// GW1 = é™•ç…¤äºŒåŽ‚ - é«˜æ¸©1号仓库<br/>
    /// CW1 = é™•ç…¤äºŒåŽ‚ - å¸¸æ¸©1号仓库<br/>
    /// HCFR1 = é™•ç…¤äºŒåŽ‚ - åˆ†å®¹1号仓库<br/>
    /// GW2 = é™•ç…¤äºŒåŽ‚ - é«˜æ¸©2号仓库<br/>
    /// ZJ1 = é™•ç…¤äºŒåŽ‚ - æ­£æžå·ä»“<br/>
    /// FJ1 = é™•ç…¤äºŒåŽ‚ - è´Ÿæžå·ä»“<br/>

    /// </summary>
    public enum WarehouseEnum
    {
        /// <summary>
        /// æ¿æ–™ä»“
        /// é«˜æ¸©1号仓库
        /// </summary>
        [Description("板料仓")]
        HA57,
        [Description("高温1号仓库")]
        GW1 = 1,
        /// <summary>
        /// PP仓
        /// å¸¸æ¸©1号仓库
        /// </summary>
        [Description("PP仓")]
        HA58,
        [Description("常温1号仓库")]
        CW1 = 2,
        /// <summary>
        /// è¾…料仓
        /// åˆ†å®¹1号仓库
        /// </summary>
        [Description("辅料仓")]
        HA60,
        [Description("分容1号仓库")]
        HCFR1 = 3,
        /// <summary>
        /// æµ‹è¯•æž¶ä»“
        /// é«˜æ¸©2号仓库
        /// </summary>
        [Description("测试架仓")]
        HA64,
        [Description("高温2号仓库")]
        GW2 = 4,
        /// <summary>
        /// æˆå“ä»“
        /// æ­£æžå·ä»“
        /// </summary>
        [Description("成品仓")]
        HA71,
        [Description("正极卷仓")]
        ZJ1 = 5,
        /// <summary>
        /// å°¾æ•°ä»“
        /// è´Ÿæžå·ä»“
        /// </summary>
        [Description("尾数仓")]
        HA72,
        /// <summary>
        /// ç ”发仓
        /// </summary>
        [Description("研发仓")]
        HA73,
        /// <summary>
        /// æˆå“ä»“平库
        /// </summary>
        [Description("成品仓平库")]
        HA101,
        /// <summary>
        /// å¹²è†œä»“
        /// </summary>
        [Description("干膜仓")]
        HA152,
        /// <summary>
        /// æ²¹å¢¨ä»“
        /// </summary>
        [Description("油墨仓")]
        HA153
        [Description("负极卷仓")]
        FJ1 = 6
    }
}

 Code/WMS/WIDESEA_WMSServer/WIDESEA_DTO/Task/AGVTaskDto.cs

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

namespace WIDESEA_DTO.Task
{
    public class AGVResponse
    {
        /// <summary>
        /// è¯·æ±‚结果代码 - å¿…填，true成功，false失败
        /// </summary>
        public bool Code { get; set; }

        /// <summary>
        /// è¯·æ±‚结果说明 - é€‰å¡«ï¼Œæ˜¯å¦æˆåŠŸï¼ŒæˆåŠŸè¿”回空，异常返回异常信息
        /// </summary>
        public string Msg { get; set; }
        /// <summary>
        /// å…¥åº“口编号 - é€‰å¡«
        /// </summary>
        public string Devid { get; set; }

        /// <summary>
        /// æ‰˜ç›˜å· - é€‰å¡«
        /// </summary>
        public string Traynumber { get; set; }

        /// <summary>
        /// æ•´æ‰˜ç»„别-厚度 - é€‰å¡«
        /// </summary>
        public string Group { get; set; }

        /// <summary>
        /// å®½åº¦ - é€‰å¡«
        /// </summary>
        public int? Width { get; set; }

        /// <summary>
        /// æ•°æ®åˆ—表 - é€‰å¡«
        /// </summary>
        public List<string> Data { get; set; }

        /// <summary>
        /// æ¡ç å· - é€‰å¡«
        /// </summary>
        public string Labelnumber { get; set; }

        /// <summary>
        /// ç‰©æ–™ç¼–码 - é€‰å¡«
        /// </summary>
        public string Productno { get; set; }

        /// <summary>
        /// ç‰©æ–™æè¿° - é€‰å¡«
        /// </summary>
        public string Productname { get; set; }

        /// <summary>
        /// æ•°é‡ - é€‰å¡«
        /// </summary>
        public string Quantity { get; set; }

        /// <summary>
        /// å•ä½ - é€‰å¡«
        /// </summary>
        public string Uomcode { get; set; }

        /// <summary>
        /// ç‰©æ–™ç±»åž‹ - é€‰å¡«
        /// </summary>
        public string Producttype { get; set; }

        /// <summary>
        /// äº§å‡ºè®¾å¤‡ - é€‰å¡«
        /// </summary>
        public string Equipment { get; set; }

        /// <summary>
        /// äº§å‡ºæ—¶é—´ - é€‰å¡«
        /// </summary>
        public string Productiondate { get; set; }

        /// <summary>
        /// ä¸‹é™æ—¶é—´ - é€‰å¡«
        /// </summary>
        public string Lowerlimittime { get; set; }

        /// <summary>
        /// é¢„警时间 - é€‰å¡«
        /// </summary>
        public string Warningtime { get; set; }

        /// <summary>
        /// è¶…期时间 - é€‰å¡«
        /// </summary>
        public string Overduetime { get; set; }

        /// <summary>
        /// é¢„留自定义字段1 - é€‰å¡«
        /// </summary>
        public string Define1 { get; set; }

        /// <summary>
        /// é¢„留自定义字段2 - é€‰å¡«
        /// </summary>
        public string Define2 { get; set; }

        public AGVResponse OK(AGVDataDto aGVDataDto = null)
        {
            Msg = "";
            Code = true;
            if (aGVDataDto != null)
            {
                // å°†AGVDataDto的属性赋值给AGVResponse
                Devid = aGVDataDto.DevId;
                Traynumber = aGVDataDto.TrayNumber;
                Group = aGVDataDto.Group;
                Width = aGVDataDto.Width;
                Data = aGVDataDto.Data;
                Labelnumber = aGVDataDto.LabelNumber;
                Productno = aGVDataDto.ProductNo;
                Productname = aGVDataDto.ProductName;
                Quantity = aGVDataDto.Quantity;
                Uomcode = aGVDataDto.UomCode;
                Producttype = aGVDataDto.ProductType;
                Equipment = aGVDataDto.Equipment;
                Productiondate = aGVDataDto.ProductionDate;
                Lowerlimittime = aGVDataDto.LowerLimitTime;
                Warningtime = aGVDataDto.WarningTime;
                Overduetime = aGVDataDto.OverdueTime;
                Define1 = aGVDataDto.Define1;
                Define2 = aGVDataDto.Define2;
            }
            return this;
        }
        public AGVResponse Error(string msg)
        {
            Msg = msg;
            Code = false;
            return this;
        }
    }
    /// <summary>
    /// AGV响应数据项
    /// </summary>
    /// <summary>
    /// AGV数据DTO
    /// </summary>
    public class AGVDataDto
    {
        /// <summary>
        /// å…¥åº“口编号 - é€‰å¡«
        /// </summary>
        [JsonPropertyName("devid")]
        [StringLength(50, ErrorMessage = "入库口编号长度不能超过50个字符")]
        public string DevId { get; set; }

        /// <summary>
        /// æ‰˜ç›˜å· - é€‰å¡«
        /// </summary>
        [JsonPropertyName("traynumber")]
        [StringLength(50, ErrorMessage = "托盘号长度不能超过50个字符")]
        public string TrayNumber { get; set; }

        /// <summary>
        /// æ•´æ‰˜ç»„别-厚度 - é€‰å¡«
        /// </summary>
        [JsonPropertyName("group")]
        [StringLength(50, ErrorMessage = "整托组别长度不能超过50个字符")]
        public string Group { get; set; }

        /// <summary>
        /// å®½åº¦ - é€‰å¡«
        /// </summary>
        [JsonPropertyName("width")]
        public int? Width { get; set; }

        /// <summary>
        /// æ•°æ®åˆ—表 - é€‰å¡«
        /// </summary>
        [JsonPropertyName("data")]
        public List<string> Data { get; set; }

        /// <summary>
        /// æ¡ç å· - é€‰å¡«
        /// </summary>
        [JsonPropertyName("labelnumber")]
        [StringLength(50, ErrorMessage = "条码号长度不能超过50个字符")]
        public string LabelNumber { get; set; }

        /// <summary>
        /// ç‰©æ–™ç¼–码 - é€‰å¡«
        /// </summary>
        [JsonPropertyName("productno")]
        [StringLength(50, ErrorMessage = "物料编码长度不能超过50个字符")]
        public string ProductNo { get; set; }

        /// <summary>
        /// ç‰©æ–™æè¿° - é€‰å¡«
        /// </summary>
        [JsonPropertyName("productname")]
        [StringLength(50, ErrorMessage = "物料描述长度不能超过50个字符")]
        public string ProductName { get; set; }

        /// <summary>
        /// æ•°é‡ - é€‰å¡«
        /// </summary>
        [JsonPropertyName("quantity")]
        [StringLength(50, ErrorMessage = "数量长度不能超过50个字符")]
        public string Quantity { get; set; }

        /// <summary>
        /// å•ä½ - é€‰å¡«
        /// </summary>
        [JsonPropertyName("uomcode")]
        [StringLength(50, ErrorMessage = "单位长度不能超过50个字符")]
        public string UomCode { get; set; }

        /// <summary>
        /// ç‰©æ–™ç±»åž‹ - é€‰å¡«
        /// </summary>
        [JsonPropertyName("producttype")]
        [StringLength(50, ErrorMessage = "物料类型长度不能超过50个字符")]
        public string ProductType { get; set; }

        /// <summary>
        /// äº§å‡ºè®¾å¤‡ - é€‰å¡«
        /// </summary>
        [JsonPropertyName("equipment")]
        [StringLength(50, ErrorMessage = "产出设备长度不能超过50个字符")]
        public string Equipment { get; set; }

        /// <summary>
        /// äº§å‡ºæ—¶é—´ - é€‰å¡«
        /// </summary>
        [JsonPropertyName("productiondate")]
        [StringLength(50, ErrorMessage = "产出时间长度不能超过50个字符")]
        public string ProductionDate { get; set; }

        /// <summary>
        /// ä¸‹é™æ—¶é—´ - é€‰å¡«
        /// </summary>
        [JsonPropertyName("lowerlimittime")]
        [StringLength(50, ErrorMessage = "下限时间长度不能超过50个字符")]
        public string LowerLimitTime { get; set; }

        /// <summary>
        /// é¢„警时间 - é€‰å¡«
        /// </summary>
        [JsonPropertyName("warningtime")]
        [StringLength(50, ErrorMessage = "预警时间长度不能超过50个字符")]
        public string WarningTime { get; set; }

        /// <summary>
        /// è¶…期时间 - é€‰å¡«
        /// </summary>
        [JsonPropertyName("overduetime")]
        [StringLength(50, ErrorMessage = "超期时间长度不能超过50个字符")]
        public string OverdueTime { get; set; }

        /// <summary>
        /// é¢„留自定义字段1 - é€‰å¡«
        /// </summary>
        [JsonPropertyName("define1")]
        [StringLength(50, ErrorMessage = "自定义字段1长度不能超过50个字符")]
        public string Define1 { get; set; }

        /// <summary>
        /// é¢„留自定义字段2 - é€‰å¡«
        /// </summary>
        [JsonPropertyName("define2")]
        [StringLength(50, ErrorMessage = "自定义字段2长度不能超过50个字符")]
        public string Define2 { get; set; }
    }
    /// <summary>
    /// ä»»åŠ¡åˆ›å»ºæ•°æ®ä¼ è¾“对象
    /// </summary>
    public class ApplyInOutDto
    {
        /// <summary>
        /// ä»»åŠ¡å·
        /// </summary>
        [JsonPropertyName("taskid")]
        [Required(ErrorMessage = "任务号不能为空")]
        [StringLength(50, ErrorMessage = "任务号长度不能超过50个字符")]
        public string TaskId { get; set; }

        /// <summary>
        /// 1-模切段；2-卷绕段
        /// </summary>
        [JsonPropertyName("floor")]
        [Required(ErrorMessage = "楼层段不能为空")]
        [Range(1, 2, ErrorMessage = "楼层段值必须是1或2")]
        public int Floor { get; set; }

        /// <summary>
        /// 1-阴极；2-阳极
        /// </summary>
        [JsonPropertyName("yinyang")]
        [Required(ErrorMessage = "阴阳极不能为空")]
        [Range(1, 2, ErrorMessage = "阴阳极值必须是1或2")]
        public int YinYang { get; set; }

        /// <summary>
        /// 1-入库；2-出库
        /// </summary>
        [JsonPropertyName("inout")]
        [Required(ErrorMessage = "出入库类型不能为空")]
        [Range(1, 2, ErrorMessage = "出入库类型值必须是1或2")]
        public int InOut { get; set; }

        /// <summary>
        /// ç‰©æ–™ç±»åž‹
        /// </summary>
        [JsonPropertyName("materialtype")]
        [Required(ErrorMessage = "物料类型不能为空")]
        [StringLength(50, ErrorMessage = "物料类型长度不能超过50个字符")]
        public string MaterialType { get; set; }

        /// <summary>
        /// ç‰©æ–™æè¿°
        /// </summary>
        [JsonPropertyName("materialname")]
        [Required(ErrorMessage = "物料描述不能为空")]
        [StringLength(50, ErrorMessage = "物料描述长度不能超过50个字符")]
        public string MaterialName { get; set; }

        /// <summary>
        /// æ‰˜ç›˜å·
        /// </summary>
        [JsonPropertyName("traynumber")]
        [StringLength(50, ErrorMessage = "托盘号长度不能超过50个字符")]
        public string TrayNumber { get; set; }

        /// <summary>
        /// æ•´æ‰˜ç»„别-厚度
        /// </summary>
        [JsonPropertyName("group")]
        [StringLength(50, ErrorMessage = "整托组别长度不能超过50个字符")]
        public string Group { get; set; }

        /// <summary>
        /// å®½åº¦
        /// </summary>
        [JsonPropertyName("width")]
        public int? Width { get; set; }

        /// <summary>
        /// æ•°æ®é›†åˆ
        /// </summary>
        [JsonPropertyName("data")]
        public List<string> Data { get; set; }

        /// <summary>
        /// æ¡ç å·
        /// </summary>
        [JsonPropertyName("labelnumber")]
        [StringLength(50, ErrorMessage = "条码号长度不能超过50个字符")]
        public string LabelNumber { get; set; }

        /// <summary>
        /// ç‰©æ–™ç¼–码
        /// </summary>
        [JsonPropertyName("productno")]
        [StringLength(50, ErrorMessage = "物料编码长度不能超过50个字符")]
        public string ProductNo { get; set; }

        /// <summary>
        /// ç‰©æ–™æè¿°
        /// </summary>
        [JsonPropertyName("productname")]
        [StringLength(50, ErrorMessage = "物料描述长度不能超过50个字符")]
        public string ProductName { get; set; }

        /// <summary>
        /// æ•°é‡
        /// </summary>
        [JsonPropertyName("quantity")]
        [StringLength(50, ErrorMessage = "数量长度不能超过50个字符")]
        public string Quantity { get; set; }

        /// <summary>
        /// å•ä½
        /// </summary>
        [JsonPropertyName("uomcode")]
        [StringLength(50, ErrorMessage = "单位长度不能超过50个字符")]
        public string UomCode { get; set; }

        /// <summary>
        /// ç‰©æ–™ç±»åž‹
        /// </summary>
        [JsonPropertyName("producttype")]
        [StringLength(50, ErrorMessage = "物料类型长度不能超过50个字符")]
        public string ProductType { get; set; }

        /// <summary>
        /// äº§å‡ºè®¾å¤‡
        /// </summary>
        [JsonPropertyName("equipment")]
        [StringLength(50, ErrorMessage = "产出设备长度不能超过50个字符")]
        public string Equipment { get; set; }

        /// <summary>
        /// äº§å‡ºæ—¶é—´
        /// </summary>
        [JsonPropertyName("productiondate")]
        [StringLength(50, ErrorMessage = "产出时间长度不能超过50个字符")]
        public string ProductionDate { get; set; }

        /// <summary>
        /// ä¸‹é™æ—¶é—´
        /// </summary>
        [JsonPropertyName("lowerlimittime")]
        [StringLength(50, ErrorMessage = "下限时间长度不能超过50个字符")]
        public string LowerLimitTime { get; set; }

        /// <summary>
        /// é¢„警时间
        /// </summary>
        [JsonPropertyName("warningtime")]
        [StringLength(50, ErrorMessage = "预警时间长度不能超过50个字符")]
        public string WarningTime { get; set; }

        /// <summary>
        /// è¶…期时间
        /// </summary>
        [JsonPropertyName("overduetime")]
        [StringLength(50, ErrorMessage = "超期时间长度不能超过50个字符")]
        public string OverdueTime { get; set; }

        /// <summary>
        /// é¢„留自定义字段1
        /// </summary>
        [JsonPropertyName("define1")]
        [StringLength(50, ErrorMessage = "自定义字段1长度不能超过50个字符")]
        public string Define1 { get; set; }

        /// <summary>
        /// é¢„留自定义字段2
        /// </summary>
        [JsonPropertyName("define2")]
        [StringLength(50, ErrorMessage = "自定义字段2长度不能超过50个字符")]
        public string Define2 { get; set; }

        /// <summary>
        /// è¯·æ±‚时间
        /// </summary>
        [JsonPropertyName("reqtime")]
        [Required(ErrorMessage = "请求时间不能为空")]
        [StringLength(50, ErrorMessage = "请求时间长度不能超过50个字符")]
        public string ReqTime { get; set; }
    }
    /// <summary>
    /// è¾“送线申请进入请求模型
    /// </summary>
    public class ApplyEnterDto
    {
        /// <summary>
        /// è®¾å¤‡ID
        /// </summary>
        [JsonPropertyName("devid")]
        [Required(ErrorMessage = "设备ID不能为空")]
        [StringLength(50, ErrorMessage = "设备ID长度不能超过50个字符")]
        public string DevId { get; set; }

        /// <summary>
        /// å‡ºå…¥åº“类型 1-入库；2-出库
        /// </summary>
        [JsonPropertyName("inout")]
        [Required(ErrorMessage = "出入库类型不能为空")]
        [Range(1, 2, ErrorMessage = "出入库类型值必须是1或2")]
        public int InOut { get; set; }

        /// <summary>
        /// ä»»åŠ¡å·
        /// </summary>
        [JsonPropertyName("taskid")]
        [Required(ErrorMessage = "任务号不能为空")]
        [StringLength(50, ErrorMessage = "任务号长度不能超过50个字符")]
        public string TaskId { get; set; }

        /// <summary>
        /// é¢„留自定义字段1
        /// </summary>
        [JsonPropertyName("define1")]
        [StringLength(50, ErrorMessage = "自定义字段1长度不能超过50个字符")]
        public string Define1 { get; set; }

        /// <summary>
        /// é¢„留自定义字段2
        /// </summary>
        [JsonPropertyName("define2")]
        [StringLength(50, ErrorMessage = "自定义字段2长度不能超过50个字符")]
        public string Define2 { get; set; }

        /// <summary>
        /// è¯·æ±‚时间
        /// </summary>
        [JsonPropertyName("reqtime")]
        [Required(ErrorMessage = "请求时间不能为空")]
        [StringLength(50, ErrorMessage = "请求时间长度不能超过50个字符")]
        public string ReqTime { get; set; }
    }
    /// <summary>
    /// å‡ºåº“完成反馈
    /// </summary>
    public class OutTaskCompleteDto
    {
        /// <summary>
        /// ä»»åŠ¡å·
        /// </summary>
        [JsonPropertyName("taskid")]
        [Required(ErrorMessage = "任务号不能为空")]
        [StringLength(50, ErrorMessage = "任务号长度不能超过50个字符")]
        public string TaskId { get; set; }
        /// <summary>
        /// å‡ºåº“口编号
        /// </summary>
        [JsonPropertyName("devid")]
        [Required(ErrorMessage = "出库口编号不能为空")]
        [StringLength(50, ErrorMessage = "出库口编号长度不能超过50个字符")]
        public string DevId { get; set; }
        /// <summary>
        /// é¢„留自定义字段1
        /// </summary>
        [JsonPropertyName("define1")]
        [StringLength(50, ErrorMessage = "自定义字段1长度不能超过50个字符")]
        public string? Define1 { get; set; }

        /// <summary>
        /// é¢„留自定义字段2
        /// </summary>
        [JsonPropertyName("define2")]
        [StringLength(50, ErrorMessage = "自定义字段2长度不能超过50个字符")]
        public string? Define2 { get; set; }

        /// <summary>
        /// è¯·æ±‚时间
        /// </summary>
        [JsonPropertyName("reqtime")]
        [Required(ErrorMessage = "请求时间不能为空")]
        [StringLength(50, ErrorMessage = "请求时间长度不能超过50个字符")]
        public string ReqTime { get; set; }
    }
    /// <summary>
    /// å–放货完成请求模型
    /// </summary>
    public class TaskCompleteDto
    {
        /// <summary>
        /// è®¾å¤‡ID
        /// </summary>
        [JsonPropertyName("devid")]
        [Required(ErrorMessage = "设备ID不能为空")]
        [StringLength(50, ErrorMessage = "设备ID长度不能超过50个字符")]
        public string DevId { get; set; }

        /// <summary>
        /// å‡ºå…¥åº“类型 1-入库；2-出库
        /// </summary>
        [JsonPropertyName("inout")]
        [Required(ErrorMessage = "出入库类型不能为空")]
        [Range(1, 2, ErrorMessage = "出入库类型值必须是1或2")]
        public int InOut { get; set; }

        /// <summary>
        /// ä»»åŠ¡å·
        /// </summary>
        [JsonPropertyName("taskid")]
        [Required(ErrorMessage = "任务号不能为空")]
        [StringLength(50, ErrorMessage = "任务号长度不能超过50个字符")]
        public string TaskId { get; set; }

        /// <summary>
        /// é¢„留自定义字段1
        /// </summary>
        [JsonPropertyName("define1")]
        [StringLength(50, ErrorMessage = "自定义字段1长度不能超过50个字符")]
        public string? Define1 { get; set; }

        /// <summary>
        /// é¢„留自定义字段2
        /// </summary>
        [JsonPropertyName("define2")]
        [StringLength(50, ErrorMessage = "自定义字段2长度不能超过50个字符")]
        public string? Define2 { get; set; }

        /// <summary>
        /// è¯·æ±‚时间
        /// </summary>
        [JsonPropertyName("reqtime")]
        [Required(ErrorMessage = "请求时间不能为空")]
        [StringLength(50, ErrorMessage = "请求时间长度不能超过50个字符")]
        public string ReqTime { get; set; }
    }

    /// <summary>
    /// ä»»åŠ¡å–消数据传输对象
    /// </summary>
    public class TaskCancelDto
    {
        /// <summary>
        /// ä»»åŠ¡å·
        /// </summary>
        [JsonPropertyName("taskid")]
        [Required(ErrorMessage = "任务号不能为空")]
        [StringLength(50, ErrorMessage = "任务号长度不能超过50个字符")]
        public string TaskId { get; set; }

        /// <summary>
        /// é¢„留自定义字段1
        /// </summary>
        [JsonPropertyName("define1")]
        [StringLength(50, ErrorMessage = "自定义字段1长度不能超过50个字符")]
        public string? Define1 { get; set; }

        /// <summary>
        /// é¢„留自定义字段2
        /// </summary>
        [JsonPropertyName("define2")]
        [StringLength(50, ErrorMessage = "自定义字段2长度不能超过50个字符")]
        public string? Define2 { get; set; }

        /// <summary>
        /// è¯·æ±‚时间
        /// </summary>
        [JsonPropertyName("reqtime")]
        [Required(ErrorMessage = "请求时间不能为空")]
        [StringLength(50, ErrorMessage = "请求时间长度不能超过50个字符")]
        public string ReqTime { get; set; }
    }
}

 Code/WMS/WIDESEA_WMSServer/WIDESEA_ITaskInfoService/ITaskService.cs

@@ -154,5 +154,49 @@
        /// <param name="stock"></param>
        /// <returns></returns>
        Task<WebResponseContent> CreateRobotChangePalletTaskAsync(StockDTO stock);


        #region æžå·åº“任务模块
        /// <summary>
        /// å‡ºå…¥åº“申请
        /// </summary>
        /// <param name="applyInOutDto">请求参数</param>
        /// <returns></returns>
        public Task<AGVResponse> ApplyInOutAsync(ApplyInOutDto applyInOutDto);

        /// <summary>
        /// æ‰‹åŠ¨å‡ºåº“完成反馈给AGV
        /// </summary>
        /// <param name="outTaskCompleteDto">请求参数</param>
        /// <returns></returns>
        public Task<WebResponseContent> OutTaskComplete(OutTaskCompleteDto outTaskCompleteDto);

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

        /// <summary>
        /// ä»»åŠ¡å–消
        /// </summary>
        /// <param name="taskCancelDto">请求参数</param>
        /// <returns></returns>
        public Task<AGVResponse> TaskCancelAsync(TaskCancelDto taskCancelDto);
        /// <summary>
        /// å–放货完成
        /// </summary>
        /// <param name="taskCompleteDto">请求参数</param>
        /// <returns></returns>
        public Task<AGVResponse> TaskCompleteAsync(TaskCompleteDto taskCompleteDto);
        /// <summary>
        /// è¾“送线申请进入
        /// </summary>
        /// <param name="applyEnterDto">请求参数</param>
        /// <returns></returns>
        public Task<AGVResponse> ApplyEnterAsync(ApplyEnterDto applyEnterDto);

        #endregion æžå·åº“任务模块
    }
}

 Code/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -2,14 +2,17 @@
using MapsterMapper;
using Microsoft.Extensions.Configuration;
using SqlSugar;
using System.DirectoryServices.Protocols;
using System.Text.Json;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Core;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.GradingMachine;
using WIDESEA_DTO.MES;
@@ -33,6 +36,7 @@
        private readonly IMesService _mesService;
        private readonly ITask_HtyService _task_HtyService;
        private readonly IStockInfo_HtyService _stockInfo_HtyService;
        private readonly IUnitOfWorkManage _unitOfWorkManage;

        public IRepository<Dt_Task> Repository => BaseDal;

@@ -55,7 +59,8 @@
            RoundRobinService roundRobinService,
            IMesService mesService,
            ITask_HtyService task_HtyService,
            IStockInfo_HtyService stockInfo_HtyService) : base(BaseDal)
            IStockInfo_HtyService stockInfo_HtyService,
            IUnitOfWorkManage unitOfWorkManage) : base(BaseDal)
        {
            _mapper = mapper;
            _stockInfoService = stockInfoService;
@@ -66,6 +71,7 @@
            _mesService = mesService;
            _task_HtyService = task_HtyService;
            _stockInfo_HtyService = stockInfo_HtyService;
            _unitOfWorkManage = unitOfWorkManage;
        }

        #region WCS逻辑处理
@@ -222,6 +228,12 @@
                var stockInfo = await _stockInfoService.GetStockInfoAsync(taskDto.PalletCode);
                if (stockInfo == null) return WebResponseContent.Instance.Error("未找到对应库存信息");

                // åˆ¤æ–­æ˜¯ä¸æ˜¯æžå·åº“任务
                //if (taskDto.WarehouseId == (int)WarehouseEnum.FJ1 || taskDto.WarehouseId == (int)WarehouseEnum.ZJ1)
                //{
                //    return WebResponseContent.Instance.OK();
                //}

                return await ExecuteWithinTransactionAsync(async () =>
                {
                    WebResponseContent content = new WebResponseContent();
@@ -278,6 +290,18 @@

                var stockInfo = await _stockInfoService.GetStockInfoAsync(taskDto.PalletCode);
                if (stockInfo == null) return WebResponseContent.Instance.Error("未找到对应库存信息");

                // åˆ¤æ–­æ˜¯ä¸æ˜¯æžå·åº“任务
                if (taskDto.WarehouseId == (int)WarehouseEnum.FJ1 || taskDto.WarehouseId == (int)WarehouseEnum.ZJ1)
                {
                    OutTaskCompleteDto outTaskCompleteDto = new OutTaskCompleteDto()
                    {
                        TaskId = task.OrderNo,
                        DevId = task.TargetAddress,
                        ReqTime = DateTime.Now.ToString()
                    };
                    return await OutTaskComplete(outTaskCompleteDto);
                }

                WebResponseContent content = new WebResponseContent();
                return await ExecuteWithinTransactionAsync(async () =>
@@ -1096,5 +1120,401 @@
        }

        #endregion åˆ†å®¹æŸœæŽ¥å£


        #region æžå·åº“任务模块
        public string AGV_OutTaskComplete = WIDESEA_Core.Helper.AppSettings.Configuration["AGV_OutTaskComplete"]; // ä¸ŠæŠ¥AGV出库输送线完成
        public string WCS_ReceiveTask = WIDESEA_Core.Helper.AppSettings.Configuration["WCS_ReceiveTask"]; // WMS输送线任务下发
        /// <summary>
        /// å‡ºå…¥åº“申请
        /// </summary>
        /// <param name="applyInOutDto">请求参数</param>
        /// <returns></returns>
        public async Task<AGVResponse> ApplyInOutAsync(ApplyInOutDto applyInOutDto)
        {
            AGVResponse aGVResponse = new AGVResponse();
            try
            {
                // å‚数验证
                if (applyInOutDto == null) return aGVResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.TrayNumber)) return aGVResponse.Error("托盘号不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.TaskId)) return aGVResponse.Error("任务号不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.MaterialType)) return aGVResponse.Error("物料类型不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.MaterialName)) return aGVResponse.Error("物料描述不能为空");
                if (string.IsNullOrWhiteSpace(applyInOutDto.ReqTime)) return aGVResponse.Error("请求时间不能为空");
                if (applyInOutDto.Floor != 1 && applyInOutDto.Floor != 2) return aGVResponse.Error($"楼层段错误，必须为1(模切段)或2(卷绕段)，当前值：{applyInOutDto.Floor}");
                if (applyInOutDto.YinYang != 1 && applyInOutDto.YinYang != 2) return aGVResponse.Error($"阴阳极错误，必须为1(阴极)或2(阳极)，当前值：{applyInOutDto.YinYang}");
                if (applyInOutDto.InOut != 1 && applyInOutDto.InOut != 2) return aGVResponse.Error($"出入库类型错误，必须为1(入库)或2(出库)，当前值：{applyInOutDto.InOut}");
                if (applyInOutDto.InOut == 1) // å…¥åº“
                {
                    if (applyInOutDto.Width == null || applyInOutDto.Width <= 0) return aGVResponse.Error("入库时宽度不能为空且必须大于0");
                    if (string.IsNullOrWhiteSpace(applyInOutDto.Group)) return aGVResponse.Error("入库时整托组别不能为空");
                }
                // æ£€æŸ¥ä»»åŠ¡æ˜¯å¦å·²å­˜åœ¨
                var existingTask = await BaseDal.QueryFirstAsync(x => x.PalletCode == applyInOutDto.TrayNumber);
                if (existingTask != null) return aGVResponse.Error($"WMS已有当前任务，不可重复下发，任务号：{applyInOutDto.TaskId}");
                // åˆ›å»ºä»»åŠ¡
                Dt_Task task = new Dt_Task
                {
                    OrderNo = applyInOutDto.TaskId, // ä½¿ç”¨AGV的任务号
                    PalletCode = applyInOutDto.TrayNumber,
                    PalletType = applyInOutDto.Floor,
                    //WarehouseId = applyInOutDto.YinYang,
                    Grade = 1,
                    Creater = "AGV",
                    CreateDate = DateTime.Now,
                    Remark = $"物料类型：{applyInOutDto.MaterialType}，物料描述：{applyInOutDto.MaterialName}"
                };
                // æ ¹æ®é˜´æž/阳极设置巷道和站台
                if (applyInOutDto.YinYang == 1) // é˜´æž
                {
                    // è´§ç‰©åˆ°è¾¾åŽåˆ†é…è´§ç‰©ä½
                    task.Roadway = WarehouseEnum.FJ1.ToString();
                    task.WarehouseId = (int)WarehouseEnum.FJ1;
                    task.SourceAddress = applyInOutDto.InOut == 1 ? "D10010" : "D10020"; // å…¥åº“口/出库口
                    task.NextAddress = "D10080"; // é˜´æžå…¬å…±å‡ºåº“口
                    task.TargetAddress = "阴极卷库";
                }
                else if (applyInOutDto.YinYang == 2) // é˜³æž
                {
                    task.Roadway = WarehouseEnum.ZJ1.ToString();
                    task.WarehouseId = (int)WarehouseEnum.ZJ1;
                    task.SourceAddress = applyInOutDto.InOut == 1 ? "D10100" : "D10090"; // å…¥åº“口/出库口
                    task.NextAddress = "D10160"; // é˜³æžå…¬å…±å‡ºåº“口
                    task.TargetAddress = "正极卷库";
                }
                // æ ¹æ®å‡ºå…¥åº“类型设置目标地址
                if (applyInOutDto.InOut == 1) // å…¥åº“
                {
                    var stockInfo = await _stockInfoService.GetStockInfoAsync(applyInOutDto.TrayNumber);
                    if (stockInfo != null) return aGVResponse.Error($"当前托盘{applyInOutDto.TrayNumber}已经入库了");

                    task.TaskType = (int)TaskInboundTypeEnum.Inbound;
                    task.TaskStatus = (int)TaskInStatusEnum.InNew;
                    task.CurrentAddress = task.SourceAddress; // å½“前在入库口
                    // ä¿å­˜ä»»åŠ¡
                    var result = await BaseDal.AddDataAsync(task);
                }
                else // å‡ºåº“
                {
                    // åˆ¤æ–­æ˜¯å¦ç§»åº“
                    task.TaskType = (int)TaskOutboundTypeEnum.Outbound;
                    task.TaskStatus = (int)TaskOutStatusEnum.OutNew;
                    task.CurrentAddress = task.SourceAddress; // å½“前在入库口
                    // æŸ¥æ‰¾åº“å­˜
                    var stockInfo = await _stockInfoService.GetStockInfoAsync(applyInOutDto.TrayNumber);
                    if (stockInfo == null) return aGVResponse.Error($"未找到托盘{applyInOutDto.TrayNumber}的库存信息");
                    // éªŒè¯åº“存所属是否正确
                    if (stockInfo.WarehouseId != applyInOutDto.YinYang) return aGVResponse.Error($"托盘{applyInOutDto.TrayNumber}不属于当前{(applyInOutDto.YinYang == 1 ? "阴极" : "阳极")}");
                    if (stockInfo.StockStatus != (int)StockStatusEmun.入库完成) return aGVResponse.Error($"托盘{applyInOutDto.TrayNumber}正在移动中，请稍后！");
                    task.SourceAddress = stockInfo.LocationCode; // æºåœ°å€ä¸ºè´§ä½
                    task.CurrentAddress = stockInfo.LocationCode; // å½“前位置在货位
                    task.TargetAddress = applyInOutDto.YinYang == 1 ? "D10020" : "D10090"; // ç›®æ ‡åœ°å€ä¸ºå‡ºåº“口

                    // ä¿å­˜ä»»åŠ¡
                    var result = await BaseDal.AddDataAsync(task);
                    // åˆ¤æ–­æ˜¯å¦ç§»åº“
                    //var transferTask = await _locationInfoService.TransferCheckAsync(result);
                }

                // æž„建响应数据
                AGVDataDto aGVDataDto = new AGVDataDto
                {
                    DevId = applyInOutDto.InOut == 1 ? task.SourceAddress : task.TargetAddress,
                    TrayNumber = task.PalletCode,
                    Group = applyInOutDto.Group,
                    Width = applyInOutDto.Width ?? 0,
                    LabelNumber = applyInOutDto.LabelNumber,
                    ProductNo = applyInOutDto.ProductNo,
                    ProductName = applyInOutDto.ProductName,
                    Quantity = applyInOutDto.Quantity,
                    UomCode = applyInOutDto.UomCode,
                    ProductType = applyInOutDto.ProductType,
                    Equipment = applyInOutDto.Equipment,
                    ProductionDate = applyInOutDto.ProductionDate,
                    LowerLimitTime = applyInOutDto.LowerLimitTime,
                    WarningTime = applyInOutDto.WarningTime,
                    OverdueTime = applyInOutDto.OverdueTime
                };

                return aGVResponse.OK(aGVDataDto);
            }
            catch (Exception ex)
            {
                return aGVResponse.Error($"WMS任务创建接口错误: {ex.Message}");
            }
        }
        /// <summary>
        /// æ‰‹åŠ¨å‡ºåº“完成反馈给AGV
        /// </summary>
        /// <param name="outTaskCompleteDto">请求参数</param>
        /// <returns></returns>
        public async Task<WebResponseContent> OutTaskComplete(OutTaskCompleteDto outTaskCompleteDto)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                if (outTaskCompleteDto == null) return webResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(outTaskCompleteDto.TaskId)) return webResponse.Error("任务号不能为空");
                if (string.IsNullOrWhiteSpace(outTaskCompleteDto.DevId)) return webResponse.Error("出库口编号不能为空");
                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == outTaskCompleteDto.TaskId);
                if (task == null) return webResponse.Error("未找到任务信息");
                outTaskCompleteDto.ReqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                var httpResponse = _httpClientHelper.Post<AGVResponse>(AGV_OutTaskComplete, JsonSerializer.Serialize(outTaskCompleteDto)).Data;
                // åˆ¤æ–­è¿œç¨‹æŽ¥å£è¿”回是否成功
                if (httpResponse != null && httpResponse.Data != null)
                {
                    AGVResponse agvResponse = httpResponse;
                    // æ ¹æ®code字段判断，code为true表示成功
                    if (agvResponse.Code == true)
                    {
                        var stockInfo = await _stockInfoService.GetStockInfoAsync(task.PalletCode);
                        if (stockInfo == null) return webResponse.Error($"未找到托盘{task.PalletCode}的库存信息");
                        var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
                        if (locationInfo == null) return webResponse.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");
                        if (stockInfo.StockStatus != (int)StockStatusEmun.出库锁定 || locationInfo.LocationStatus != (int)LocationStatusEnum.InStockLock)
                        {
                            return webResponse.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");
                        }
                        locationInfo.LocationStatus = (int)LocationStatusEnum.Free;
                        _unitOfWorkManage.BeginTran();
                        BaseDal.DeleteData(task);
                        _locationInfoService.UpdateData(locationInfo);
                        _stockInfoService.DeleteData(stockInfo);
                        _unitOfWorkManage.CommitTran();
                        return webResponse.OK(agvResponse.Msg);
                    }
                    else
                    {
                        // å¤±è´¥ï¼šè¿”回AGV返回的错误信息
                        return webResponse.Error(string.IsNullOrWhiteSpace(agvResponse.Msg)
                            ? "AGV接口调用失败"
                            : agvResponse.Msg);
                    }
                }
                else
                {
                    // HTTP请求本身失败
                    return webResponse.Error(httpResponse?.Msg ?? "AGV接口调用异常");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return webResponse.Error($"WMS任务完成接口错误：{ex.Message}");
            }
        }
        ///// <summary>
        ///// ä»»åŠ¡å®ŒæˆæŽ¥å£
        ///// </summary>
        ///// <param name="wCSTask"></param>
        ///// <returns></returns>
        //public async Task<WebResponseContent> TaskCompleted(WCSTaskDTO wCSTask)
        //{
        //    WebResponseContent webResponse = new WebResponseContent();
        //    try
        //    {
        //        Dt_Task task = await BaseDal.QueryFirstAsync(x => x.TaskId == wCSTask.TaskNum && x.PalletCode == wCSTask.PalletCode);
        //        if (task == null) return webResponse.Error("未找到任务信息");
        //        // å‡ºåº“完成反馈
        //        OutTaskCompleteDto outTaskCompleteDto = new OutTaskCompleteDto()
        //        {
        //            TaskId = task.OrderNo,
        //            DevId = task.TargetAddress,
        //            ReqTime = DateTime.Now.ToString()
        //        };
        //        return await OutTaskComplete(outTaskCompleteDto);
        //    }
        //    catch (Exception ex)
        //    {
        //        return webResponse.Error($"WMS任务完成接口错误：{ex.Message}");
        //    }
        //}
        /// <summary>
        /// è¾“送线申请进入
        /// </summary>
        /// <param name="applyEnterDto">请求参数</param>
        /// <returns></returns>
        public async Task<AGVResponse> ApplyEnterAsync(ApplyEnterDto applyEnterDto)
        {
            AGVResponse aGVResponse = new AGVResponse();
            try
            {
                // å‚数验证
                if (applyEnterDto == null) return aGVResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(applyEnterDto.DevId)) return aGVResponse.Error("设备编号不能为空");
                if (string.IsNullOrWhiteSpace(applyEnterDto.TaskId)) return aGVResponse.Error("任务号不能为空");
                if (applyEnterDto.InOut != 1 && applyEnterDto.InOut != 2) return aGVResponse.Error($"出入库类型错误，必须为1(入库)或2(出库)，当前值：{applyEnterDto.InOut}");

                // æŸ¥è¯¢ä»»åŠ¡æ˜¯å¦å­˜åœ¨
                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == applyEnterDto.TaskId);
                if (task == null) return aGVResponse.Error($"未找到任务信息，任务号：{applyEnterDto.TaskId}");
                if (applyEnterDto.InOut == 1 && task.TaskType == (int)TaskInboundTypeEnum.Inbound && task.TaskStatus == (int)TaskInStatusEnum.InNew)
                {
                    aGVResponse.OK();
                }
                else if(applyEnterDto.InOut == 2 && task.TaskType == (int)TaskOutboundTypeEnum.Outbound && task.TaskStatus == (int)TaskStatusEnum.Line_Finish)
                {
                    aGVResponse.OK();
                }
                return aGVResponse.Error($"输送线{applyEnterDto.DevId}当前繁忙，请稍后重试");

                // Dt_Task.SourceAddress询问wcs站台1-阴极入口叫D10010和D10020；2-阳极D10090和D10100是否有货物
                //var httpResponse = _httpClientHelper.Post<WebResponseContent>("http://127.0.0.1:9999/api/Task/ApplyInOut", JsonSerializer.Serialize(task)).Data;
                //if (httpResponse != null && httpResponse.Status == true)
                //{
                //    _unitOfWorkManage.BeginTran();
                //    task.TaskStatus = (int)TaskStatusEnum.AGV_Executing;
                //    await BaseDal.UpdateDataAsync(task);
                //    _unitOfWorkManage.CommitTran();
                //    return aGVResponse.OK();
                //}
                //else
                //{
                //    return aGVResponse.Error($"站台{task.SourceAddress}已经载货");
                //}
            }
            catch (Exception ex)
            {
                //_unitOfWorkManage.RollbackTran();
                return aGVResponse.Error($"WMS输送线申请接口错误：{ex.Message}");
            }
        }
        /// <summary>
        /// å–放货完成
        /// </summary>
        /// <param name="taskCompleteDto">请求参数</param>
        /// <returns></returns>
        public async Task<AGVResponse> TaskCompleteAsync(TaskCompleteDto taskCompleteDto)
        {
            AGVResponse aGVResponse = new AGVResponse();
            try
            {
                if (taskCompleteDto == null) return aGVResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(taskCompleteDto.TaskId)) return aGVResponse.Error("任务号不能为空");
                if (string.IsNullOrWhiteSpace(taskCompleteDto.DevId)) return aGVResponse.Error("设备编号不能为空");
                if (taskCompleteDto.InOut != 1 && taskCompleteDto.InOut != 2) return aGVResponse.Error($"出入库类型错误，必须为1(入库)或2(出库)，当前值：{taskCompleteDto.InOut}");
                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == taskCompleteDto.TaskId);
                if (task == null) return aGVResponse.Error($"未找到任务信息，任务号：{taskCompleteDto.TaskId}");
                if (taskCompleteDto.InOut == 2)
                {
                    var stockInfo = await _stockInfoService.GetStockInfoAsync(task.PalletCode);
                    if (stockInfo == null) return aGVResponse.Error($"未找到托盘{task.PalletCode}的库存信息");
                    var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
                    if (locationInfo == null) return aGVResponse.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");
                    if (stockInfo.StockStatus != (int)StockStatusEmun.出库锁定 || locationInfo.LocationStatus != (int)LocationStatusEnum.InStockLock)
                    {
                        return aGVResponse.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");
                    }
                    locationInfo.LocationStatus = (int)LocationStatusEnum.Free;
                    task.TaskStatus = (int)TaskOutStatusEnum.OutFinish;
                    _unitOfWorkManage.BeginTran();
                    _stockInfoService.DeleteData(stockInfo);
                    await _locationInfoService.UpdateLocationInfoAsync(locationInfo);
                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _unitOfWorkManage.CommitTran();
                }
                else
                {
                    //查找可用货位
                    var availableLocation = await _locationInfoService.GetLocationInfo(task.Roadway);

                    if (availableLocation == null) return aGVResponse.Error("无可用的入库货位");

                    task.TargetAddress = availableLocation.LocationCode;
                    // é€šçŸ¥WCS入库
                    var wcsTaskDto = _mapper.Map<WCSTaskDTO>(task);
                    var httpResponse = _httpClientHelper.Post<WebResponseContent>(WCS_ReceiveTask, JsonSerializer.Serialize(wcsTaskDto));
                    if (httpResponse == null) return aGVResponse.Error("下发WCS失败");

                    task.TaskStatus = (int)TaskStatusEnum.Line_Executing;
                    task.Dispatchertime = DateTime.Now;
                    var locationInfo = await _locationInfoService.GetLocationInfoAsync(task.TargetAddress);
                    if (locationInfo == null) return aGVResponse.Error($"未找到托盘{task.TargetAddress}的货位信息");
                    if (locationInfo.LocationStatus != (int)LocationStatusEnum.InStock)
                    {
                        return aGVResponse.Error($"当前货位{locationInfo.LocationStatus}状态信息错误");
                    }
                    Dt_StockInfo dt_Stock = new Dt_StockInfo()
                    {
                        PalletCode = task.PalletCode,
                        StockStatus = (int)StockStatusEmun.入库确认,
                        LocationCode = locationInfo.LocationCode,
                        WarehouseId = task.WarehouseId,
                        Creater = "AGV",
                        CreateDate = DateTime.Now
                    };
                    locationInfo.LocationStatus = (int)LocationStatusEnum.FreeLock;
                    _unitOfWorkManage.BeginTran();
                    BaseDal.UpdateData(task);
                    _locationInfoService.UpdateData(locationInfo);
                    _stockInfoService.AddData(dt_Stock);
                    _unitOfWorkManage.CommitTran();
                }
                return aGVResponse.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return aGVResponse.Error($"WMS取放货完成接口错误：{ex.Message}");
            }
        }
        /// <summary>
        /// ä»»åŠ¡å–消
        /// </summary>
        /// <param name="taskCancelDto">请求参数</param>
        /// <returns></returns>
        public async Task<AGVResponse> TaskCancelAsync(TaskCancelDto taskCancelDto)
        {
            AGVResponse aGVResponse = new AGVResponse();
            try
            {
                if (taskCancelDto == null) return aGVResponse.Error("请求参数不能为空");
                if (string.IsNullOrWhiteSpace(taskCancelDto.TaskId)) return aGVResponse.Error("任务号不能为空");

                var task = await BaseDal.QueryFirstAsync(x => x.OrderNo == taskCancelDto.TaskId);
                // æ²¡æœ‰ä»»åŠ¡å¼ºåˆ¶å–消
                if (task == null) return aGVResponse.OK();
                
                if (task.TaskStatus == (int)TaskInStatusEnum.InNew)
                {
                    task.TaskStatus = (int)TaskInStatusEnum.InCancel;
                    // å…¥åº“任务直接删除
                    _unitOfWorkManage.BeginTran();
                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _unitOfWorkManage.CommitTran();
                    return aGVResponse.OK();
                }
                else if(task.TaskStatus == (int)TaskOutStatusEnum.OutNew)
                {
                    // å‡ºåº“任务恢复库存
                    var stockInfo = await _stockInfoService.GetStockInfoAsync(task.PalletCode);
                    if (stockInfo == null) return aGVResponse.Error($"未找到托盘{task.PalletCode}的库存信息");
                    var locationInfo = await _locationInfoService.GetLocationInfoAsync(stockInfo.LocationCode);
                    if (locationInfo == null) return aGVResponse.Error($"未找到托盘{stockInfo.LocationCode}的货位信息");
                    if (stockInfo.StockStatus != (int)StockStatusEmun.出库锁定 || locationInfo.LocationStatus != (int)LocationStatusEnum.InStockLock)
                    {
                        return aGVResponse.Error($"当前库存{stockInfo.StockStatus}或者货位{locationInfo.LocationStatus}状态信息错误");
                    }
                    stockInfo.StockStatus = (int)StockStatusEmun.入库完成;
                    locationInfo.LocationStatus = (int)LocationStatusEnum.InStock;
                    task.TaskStatus = (int)TaskOutStatusEnum.OutCancel;
                    _unitOfWorkManage.BeginTran();
                    _locationInfoService.UpdateData(locationInfo);
                    _stockInfoService.UpdateData(stockInfo);
                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _unitOfWorkManage.CommitTran();
                    return aGVResponse.OK();
                }
                return aGVResponse.Error("任务已经在执行中，不可取消");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return aGVResponse.Error($"WMS任务取消接口错误：{ex.Message}");
            }
        }

        #endregion æžå·åº“任务模块
    }
}

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

@@ -1,6 +1,7 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.DirectoryServices.Protocols;
using WIDESEA_Common.CommonEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseController;
@@ -198,5 +199,71 @@
        {
            return await Service.GetPalletCodeCellAsync(input);
        }

        #region æžå·åº“任务模块

        /// <summary>
        /// å‡ºå…¥åº“申请
        /// </summary>
        /// <param name="applyInOutDto">请求参数</param>
        /// <returns></returns>
        [HttpPost("ApplyInOut"), AllowAnonymous]
        public async Task<AGVResponse> ApplyInOutAsync([FromBody] ApplyInOutDto applyInOutDto)
        {
            return await Service.ApplyInOutAsync(applyInOutDto);
        }
        /// <summary>
        /// æ‰‹åŠ¨å‡ºåº“完成反馈给AGV
        /// </summary>
        /// <param name="outTaskCompleteDto">请求参数</param>
        /// <returns></returns>
        [HttpPost, Route("OutTaskComplete"), AllowAnonymous]
        public async Task<WebResponseContent> OutTaskComplete([FromBody] OutTaskCompleteDto outTaskCompleteDto)
        {
            return await Service.OutTaskComplete(outTaskCompleteDto);
        }
        ///// <summary>
        ///// ä»»åŠ¡å®Œæˆ
        ///// </summary>
        ///// <param name="wCSTask">请求参数</param>
        ///// <returns></returns>
        //[HttpPost, Route("TaskCompleted"), AllowAnonymous]
        //public async Task<WebResponseContent?> TaskCompleted([FromBody] WCSTaskDTO wCSTask)
        //{
        //    return await Service.TaskCompleted(wCSTask);
        //}
        /// <summary>
        /// è¾“送线申请进入
        /// </summary>
        /// <param name="applyEnterDto">请求参数</param>
        /// <returns></returns>
        [HttpPost("ApplyEnter"), AllowAnonymous]
        public async Task<AGVResponse?> ApplyEnterAsync([FromBody] ApplyEnterDto applyEnterDto)
        {
            return await Service.ApplyEnterAsync(applyEnterDto);
        }

        /// <summary>
        /// å–放货完成
        /// </summary>
        /// <param name="taskCompleteDto">请求参数</param>
        /// <returns></returns>
        [HttpPost("TaskComplete"), AllowAnonymous]
        public async Task<AGVResponse?> TaskCompleteAsync([FromBody] TaskCompleteDto taskCompleteDto)
        {
            return await Service.TaskCompleteAsync(taskCompleteDto);
        }

        /// <summary>
        /// ä»»åŠ¡å–消
        /// </summary>
        /// <param name="taskCancelDto">请求参数</param>
        /// <returns></returns>
        [HttpPost("TaskCancel"), AllowAnonymous]
        public async Task<AGVResponse?> TaskCancelAsync([FromBody] TaskCancelDto taskCancelDto)
        {
            return await Service.TaskCancelAsync(taskCancelDto);
        }
        #endregion æžå·åº“任务模块
    }
}

 Code/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/appsettings.json

@@ -35,6 +35,7 @@
  //连接字符串
  //"ConnectionString": "HTI6FB1H05Krd07mNm9yBCNhofW6edA5zLs9TY~MNthRYW3kn0qKbMIsGp~3yyPDF1YZUCPBQx8U0Jfk4PH~ajNFXVIwlH85M3F~v_qKYQ3CeAz3q1mLVDn8O5uWt1~3Ut2V3KRkEwYHvW2oMDN~QIDXPxDgXN0R2oTIhc9dNu7QNaLEknblqmHhjaNSSpERdDVZIgHnMKejU_SL49tralBkZmDNi0hmkbL~837j1NWe37u9fJKmv91QPb~16JsuI9uu0EvNZ06g6PuZfOSAeFH9GMMIZiketdcJG3tHelo=",
  "ConnectionString": "Data Source=.;Initial Catalog=WIDESEAWMS_ShanMei;User ID=sa;Password=P@ssw0rd;Integrated Security=False;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
  //"ConnectionString": "Data Source=.;Initial Catalog=WIDESEAWMS_ShanMei;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",
@@ -72,5 +73,7 @@
  "MES": {
    "BaseUrl": "http://localhost:5000",
    "Authorization": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMwMTcyNzM5Mzk5NzYxOTIwIiwibmFtZSI6IlBBQ0voo4XphY3lt6XkvY0wMSIsIkZhY3RvcnlJZCI6IjEyMzQ1NiIsIlNpdGVJZCI6IjEyMzQ1NiIsIkNvZGUiOiJYWExQQUNLMDRBRTAzMiIsIm5iZiI6MTcwNDE4NzY5MCwiZXhwIjoyMTQ1NjkxNjkwLCJpc3MiOiJodHRwczovL3d3dy5oeW1zb24uY29tIiwiYXVkIjoiaHR0cHM6Ly93d3cuaHltc29uLmNvbSJ9.An1BE7UgfcSP--LtTOmmmWVE2RQFPDahLkDg1xy5KqY"
  }
  },
  "AGV_OutTaskComplete": "http://localhost:9999/OutTaskComplete", // ä¸ŠæŠ¥AGV出库输送线完成
  "WCS_ReceiveTask": "http://localhost:9292/api/Task/ReceiveTask" // WMS输送线任务下发
}