成品代码更新....

wangxinhui

2025-03-19 d8db1698c125618c1b5f62b009204ddc5d4eed5a

成品代码更新....

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Common/TaskEnum/TaskTypeEnum.cs

@@ -62,11 +62,16 @@
        [Description("成品出库")]
        OutProduct = 230,
        /// <summary>
        /// æˆå“å¯„售转仓
        /// æˆå“å¯„售出库
        /// </summary>
        [Description("成品寄售转仓")]
        [Description("成品寄售出库")]
        OutSendProduct = 240,
        /// <summary>
        /// æˆå“MES出库/提库
        /// </summary>
        [Description("成品MES出库/提库")]
        OutMesRworkProduct = 250,
        /// <summary>
        /// é‡‡è´­å…¥åº“
        /// </summary>
        [Description("采购入库")]

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/¸ÉĤ²Ö/StackerCraneJob_GM.cs

@@ -242,7 +242,7 @@
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"未找到WMS移库判断接口");
                    return null;
                }
                HttpHelper.Post($"{url}?taskNum={task.TaskNum}&locationCode={task.NextAddress}", "");//todo è°ƒç”¨WMS任务完成方法
                //HttpHelper.Post($"{url}?taskNum={task.TaskNum}&locationCode={task.NextAddress}", "");//todo è°ƒç”¨WMS任务完成方法
            }

            return task;
@@ -262,7 +262,7 @@
                if (device != null)
                {
                    OtherDevice client = (OtherDevice)device;
                    if (!client.GetValue<R_ConveyorLineDB, bool>(R_ConveyorLineDB.Goods, stationManger.StationCode))//出库站台未被占用
                    if (client.GetValue<R_ConveyorLineDB, bool>(R_ConveyorLineDB.Goods, stationManger.StationCode))//出库站台未被占用
                    {
                        task.NextAddress = stationManger.StackerCraneStationCode;
                        _taskRepository.UpdateData(task);

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/basic/materielCodeInfo.js

@@ -162,7 +162,11 @@
        let year = date.getFullYear();
        let month = String(date.getMonth() + 1).padStart(2, "0");
        let day = String(date.getDate()).padStart(2, "0");
        this.editFormFields.lotNo = year + month + day;
        let hour= String(date.getHours()).padStart(2, "0");
        let minute= String(date.getMinutes()).padStart(2, "0");
        let second= String(date.getSeconds()).padStart(2, "0");
        //将year截取后两位
        this.editFormFields.lotNo = (year.toString().substr(-2)) + month+day + hour + minute+second;
        this.editFormFields.productionDate = year + "-" + month + "-" + day;
        this.editFormFields.effectiveDate = year + 2 + "-" + month + "-" + day;
      }

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/taskinfo/task.vue

@@ -57,6 +57,9 @@
        { title: "目标地址", field: "targetAddress", type: "like" },
        { title: "创建时间", field: "createDate", type: "datetime" },
      ],
      [
        { title: "所属仓库", field: "warehouseId",type: "selectList",dataKey: "warehouses",data: [],}
      ],
    ]);
    const columns = ref([
      {
@@ -77,6 +80,14 @@
        align: "left",
      },
      {
        field: "warehouseId",
        title: "所属仓库",
        type: "string",
        width: 100,
        align: "left",
        bind: { key: "warehouses", data: [] },
      },
      {
        field: "palletCode",
        title: "托盘编号",
        type: "string",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/taskinfo/task_hty.vue

@@ -57,6 +57,9 @@
        { title: "目标地址", field: "targetAddress", type: "like" },
        { title: "创建时间", field: "createDate", type: "datetime" },
      ],
      [
        { title: "所属仓库", field: "warehouseId",type: "selectList",dataKey: "warehouses",data: [],}
      ],
    ]);
    const columns = ref([
      {
@@ -77,6 +80,14 @@
        align: "left",
      },
      {
        field: "warehouseId",
        title: "所属仓库",
        type: "string",
        width: 100,
        align: "left",
        bind: { key: "warehouses", data: [] },
      },
      {
        field: "palletCode",
        title: "托盘编号",
        type: "string",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/03235358-3ae5-4103-a845-c64fa06f092b.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/4097eb55-e5cd-477d-a304-2ebfbecb7877.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/698304e2-84c8-4568-8d00-fafc24f90fa6.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/91b1a3a3-e3b0-4830-964d-9ab1bdf01bb5.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/c0c07971-a8e8-48ed-85a6-a9d507a9fa79.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/d47d14a8-1bd7-49ce-b62d-ff8267c57e45.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/d9a4ac64-ff06-4973-a542-ee01830747ad.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/efb438a8-33f2-4f81-bdb3-e2a568ef889e.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicRepository/BasicRepository.cs

@@ -26,13 +26,15 @@
        public IWarehouseRepository WarehouseRepository { get; }

        public IPalletTypeInfoRepository PalletTypeInfoRepository { get; }
        public ICustomerInfoRepository CustomerInfoRepository { get; }

        public BasicRepository(ILocationInfoRepository locationInfoRepository, IMaterielInfoRepository materielInfoRepository, IWarehouseRepository warehouseRepository, IPalletTypeInfoRepository palletTypeInfoRepository)
        public BasicRepository(ILocationInfoRepository locationInfoRepository, IMaterielInfoRepository materielInfoRepository, IWarehouseRepository warehouseRepository, IPalletTypeInfoRepository palletTypeInfoRepository, ICustomerInfoRepository customerInfoRepository)
        {
            LocationInfoRepository = locationInfoRepository;
            MaterielInfoRepository = materielInfoRepository;
            WarehouseRepository = warehouseRepository;
            PalletTypeInfoRepository = palletTypeInfoRepository;
            CustomerInfoRepository = customerInfoRepository;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/PalletCodeInfoService.cs

@@ -104,11 +104,10 @@
                    List<Dt_PalletCodeInfo> palletCodeInfos = new List<Dt_PalletCodeInfo>();
                    int serialNo = 0;
                    DateTime now = DateTime.Now;
                    Dt_PalletCodeInfo palletCodeInfo = BaseDal.QueryFirst(x => x.WarehouseId == warehouseId && x.PalletTypeId==palletTypeId, new Dictionary<string, OrderByType> { { nameof(Dt_PalletCodeInfo.SerialNo), OrderByType.Desc } });
                    Dt_PalletCodeInfo palletCodeInfo = BaseDal.QueryFirst(x => x.WarehouseId == warehouseId && x.PalletTypeId==palletTypeId && x.CreateDate.Year == now.Year && x.CreateDate.Month == now.Month && x.CreateDate.Day == now.Day, new Dictionary<string, OrderByType> { { nameof(Dt_PalletCodeInfo.SerialNo), OrderByType.Desc } });
                    if (palletCodeInfo != null && palletCodeInfo.CreateDate.Year == now.Year && palletCodeInfo.CreateDate.Month == now.Month && palletCodeInfo.CreateDate.Day == now.Day)
                    {
                        serialNo = palletCodeInfo.SerialNo + 1;

                    }
                    else
                    {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Common/APIEnum/APIEnum.cs

@@ -41,6 +41,11 @@
        /// MES同步成品出库
        /// </summary>
        [Description("MES同步成品出库")]
        WMS_MES_ShipmentOrderSync
        WMS_MES_ShipmentOrderSync,
        /// <summary>
        /// åº“存板出库
        /// </summary>
        [Description("库存板出库")]
        WMS_MES_ProductOutBound
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Common/OrderEnum/MesOutboundOrderType.cs

@@ -36,4 +36,24 @@
        [Description("手动基板出库拣选")]
        HandSubstrateOutPick = 400,
    }
    public enum MesRworkOutTypeEnum
    {
        /// <summary>
        /// å®¢é€€
        /// </summary>
        [Description("客退")]
        ReturnGuest = 1,

        /// <summary>
        /// åº“存不良
        /// </summary>
        [Description("库存不良")]
        OutOfStock = 2,

        /// <summary>
        /// ä½™æ•°æä»“
        /// </summary>
        [Description("余数提仓")]
        Withdrawn = 3
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Common/StockEnum/StockStatusEmun.cs

@@ -53,6 +53,9 @@
        [Description("拣选完成")]
        æ‹£é€‰å®Œæˆ =14,

        [Description("平库入库完成")]
        å¹³åº“入库完成 = 15,

        [Description("退库")]
        MES退库 = 21,


 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Common/TaskEnum/TaskTypeEnum.cs

@@ -65,11 +65,16 @@
        [Description("成品出库")]
        OutProduct = 230,
        /// <summary>
        /// æˆå“å¯„售转仓
        /// æˆå“å¯„售出库
        /// </summary>
        [Description("成品寄售转仓")]
        [Description("成品寄售出库")]
        OutSendProduct = 240,
        /// <summary>
        /// æˆå“MES出库/提库
        /// </summary>
        [Description("成品MES出库/提库")]
        OutMesRworkProduct =250,
        /// <summary>
        /// é‡‡è´­å…¥åº“
        /// </summary>
        [Description("采购入库")]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Common/WareHouseEnum/WarehouseEnum.cs

@@ -73,4 +73,17 @@
        [Description("油墨仓")]
        HA153
    }
    public enum WarehouseTypEnum
    {
        /// <summary>
        /// åŽŸæ–™
        /// </summary>
        [Description("原料")]
        åŽŸæ–™,
        /// <summary>
        /// æˆå“
        /// </summary>
        [Description("成品")]
        æˆå“,
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/CodeConfigEnum/RuleCodeEnum.cs

@@ -60,5 +60,10 @@
        /// </summary>
        [Description("成品入库单号编码规则")]
        ProInCodeRule,
        /// <summary>
        /// æˆå“å‡ºåº“单号编码规则
        /// </summary>
        [Description("成品出库单号编码规则")]
        ProOutCOdeRule
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/ERP/ErpProOutLingOrder.cs

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

namespace WIDESEA_DTO.ERP
{
    /// <summary>
    /// æˆå“é¢†æ–™å‡ºåº“
    /// </summary>
    public class ErpProOutLingOrder
    {
        /// <summary>
        /// 
        /// </summary>
        public int RowId { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string OrderNo { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string PCode { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string PVer { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string PLot { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public int DateCode { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string WaType { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public float SetQty { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public float QtyPcs { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public float XQty { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string XSite { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string Unit { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string OrderDate { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string Note { get; set; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MES/MesProductOutBound.cs

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

namespace WIDESEA_DTO.MES
{
    /// <summary>
    /// åº“存板出库
    /// </summary>
    public class MesProductOutBound
    {
        /// <summary>
        /// ä»»åŠ¡å•å·
        /// </summary>
        public string TaskNo { get; set; }
        /// <summary>
        /// äº§å“ç¼–码
        /// </summary>
        public string ProductCode { get; set; }
        /// <summary>
        /// äº§å“ç‰ˆæœ¬
        /// </summary>
        public string ProductVersion { get; set; }
        /// <summary>
        /// å‘¨æœŸ
        /// </summary>
        public string DateCode { get; set; }
        /// <summary>
        /// é”€å”®è®¢å•
        /// </summary>
        public string SaleOrder { get; set; }
        /// <summary>
        /// ä»“库信息
        /// </summary>
        public List<MesInventoryInfo> InventoryInfo { get; set; }
    }
    /// <summary>
    /// ä»“库信息
    /// </summary>
    public class MesInventoryInfo
    {
        /// <summary>
        /// ä»“库代码
        /// </summary>
        public string Warhouseno { get; set; }
        /// <summary>
        /// å†…包号
        /// </summary>
        public string InternalPackageNumber { get; set; }
        /// <summary>
        /// SET数量
        /// </summary>
        public string SetCount { get; set; }
        /// <summary>
        /// åˆæ ¼PCS数量
        /// </summary>
        public string EligiblePcsCount { get; set; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MES/RworkTaskModel.cs

@@ -3,37 +3,45 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.Attributes;

namespace WIDESEA_DTO.MES
{
    /// <summary>
    /// è¿”工提库
    /// </summary>
    [ModelValidate]
    public class RworkTaskModel
    {
        /// <summary>
        /// ä»»åŠ¡å•å·
        /// </summary>
        [PropertyValidate("任务单号", NotNullAndEmpty = true)]
        public string TaskNo {  get; set; }
        /// <summary>
        /// äº§å“ç¼–码
        /// </summary>
        [PropertyValidate("产品编码", NotNullAndEmpty = true)]
        public string ProductCode { get; set; }
        /// <summary>
        /// äº§å“åç§°
        /// </summary>
        [PropertyValidate("产品名称", NotNullAndEmpty = true)]
        public string ProductName { get; set; }
        /// <summary>
        /// äº§å“ç‰ˆæœ¬
        /// </summary>
        [PropertyValidate("产品版本", NotNullAndEmpty = true)]
        public string ProductVersion { get; set; }
        /// <summary>
        /// å‘¨æœŸ
        /// </summary>
        [PropertyValidate("周期", NotNullAndEmpty = true)]
        public string DateCode { get; set; }
        /// <summary>
        /// éœ€æ±‚数量
        /// </summary>
        [PropertyValidate("需求数量", NotNullAndEmpty = true)]
        public float RequiredQuantity { get; set; }
        /// <summary>
        /// å·¥åŽ‚
@@ -42,10 +50,15 @@
        /// <summary>
        /// é”€å”®è®¢å•
        /// </summary>
        [PropertyValidate("销售订单", NotNullAndEmpty = true)]
        public string SaleOrder { get; set; }
        /// <summary>
        /// åº“存类型
        /// 1:客退<br/>
        /// 2:库存不良<br/>
        /// 3:余数提仓<br/>
        /// </summary>
        [PropertyValidate("库存类型", NotNullAndEmpty = true, Check = new object[] { 1, 2,3 })]
        public int InventoryType { get; set; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_External/ERPService/InvokeERPService.cs

@@ -176,6 +176,63 @@
            return response;
        }
        /// <summary>
        /// æˆå“ä»“检报废出库推送ERP
        /// </summary>
        /// <param name="checkModel"></param>
        /// <returns></returns>
        public string InvokeProCheckApi(ERPProductCheckModel checkModel)
        {
            Dt_ApiInfo apiInfo = _apiInfoRepository.QueryFirst(x => x.ApiCode == APIEnum.InvokeErpApi.ToString());
            ERPBaseModel<ERPProductCheckModel> model = new ERPBaseModel<ERPProductCheckModel>()
            {
                Data = checkModel,
                Desc = "成品检验单",
                Type = " toFGIIqcChecked",
                SecurityCode = "TeChuang"
            };
            string request = JsonConvert.SerializeObject(model, settings);
            string response = HttpHelper.Post(apiInfo.ApiAddress, request);
            return response;
        }
        /// <summary>
        /// æˆå“è¶…周期报废推送ERP
        /// </summary>
        /// <param name="sheetModel"></param>
        /// <returns></returns>
        public string InvokeProScrapSheetApi(ERPScrapSheetModel sheetModel)
        {
            Dt_ApiInfo apiInfo = _apiInfoRepository.QueryFirst(x => x.ApiCode == APIEnum.InvokeErpApi.ToString());
            ERPBaseModel<ERPScrapSheetModel> model = new ERPBaseModel<ERPScrapSheetModel>()
            {
                Data = sheetModel,
                Desc = "成品报废单",
                Type = " toFGIScrapSheet",
                SecurityCode = "TeChuang"
            };
            string request = JsonConvert.SerializeObject(model, settings);
            string response = HttpHelper.Post(apiInfo.ApiAddress, request);
            return response;
        }
        /// <summary>
        /// æˆå“ç›˜ç‚¹ç›˜èµ¢/盘亏
        /// </summary>
        /// <param name="stockCheckModel"></param>
        /// <returns></returns>
        public string InvokeProStockCheckApi(ERPProStockCheckModel stockCheckModel)
        {
            Dt_ApiInfo apiInfo = _apiInfoRepository.QueryFirst(x => x.ApiCode == APIEnum.InvokeErpApi.ToString());
            ERPBaseModel<ERPProStockCheckModel> model = new ERPBaseModel<ERPProStockCheckModel>()
            {
                Data = stockCheckModel,
                Desc = "成品盘点单",
                Type = "toStockCheck",
                SecurityCode = "TeChuang"
            };
            string request = JsonConvert.SerializeObject(model, settings);
            string response = HttpHelper.Post(apiInfo.ApiAddress, request);
            return response;
        }
        /// <summary>
        /// ERP物料出库接口调用
        /// </summary>
        /// <param name="outboundModel"></param>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_External/IERPService/IInvokeERPService.cs

@@ -57,5 +57,23 @@
        /// <param name="inboundModel"></param>
        /// <returns></returns>
        string InvokeProInApi(ERPProInboundModel inboundModel);
        /// <summary>
        /// æˆå“ä»“检报废出库推送ERP
        /// </summary>
        /// <param name="checkModel"></param>
        /// <returns></returns>
        string InvokeProCheckApi(ERPProductCheckModel checkModel);
        /// <summary>
        /// æˆå“è¶…周期报废推送ERp
        /// </summary>
        /// <param name="sheetModel"></param>
        /// <returns></returns>
        string InvokeProScrapSheetApi(ERPScrapSheetModel sheetModel);
        /// <summary>
        /// æˆå“ç›˜ç‚¹ç›˜èµ¢/盘亏
        /// </summary>
        /// <param name="stockCheckModel"></param>
        /// <returns></returns>
        string InvokeProStockCheckApi(ERPProStockCheckModel stockCheckModel);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_External/Model/ERPProStockCheckModel.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_External/Model/ERPStockCheckModel.cs ÐÞ¸Ä
@@ -9,7 +9,7 @@
    /// <summary>
    /// æˆå“ç›˜ç‚¹
    /// </summary>
    public class ERPStockCheckModel
    public class ERPProStockCheckModel
    {
        /// <summary>
        /// æ“ä½œç±»åž‹

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicRepository/IBasicRepository.cs

@@ -17,6 +17,7 @@
        IWarehouseRepository WarehouseRepository { get; }

        IPalletTypeInfoRepository PalletTypeInfoRepository { get; }
        ICustomerInfoRepository CustomerInfoRepository { get; }

    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundRepository/IOutboundRepository.cs

@@ -16,5 +16,8 @@
        IOutStockLockInfoRepository OutboundStockLockInfoRepository { get; }

        IMesPPCutOutboundOrderRepository MesPPCutOutboundOrderRepository { get; }
        IProOutOrderRepository ProOutOrderRepository { get; }
        IProOutOrderDetailRepository ProOutOrderDetailRepository { get; }
        IMesRworkOutboundOrderRepository RworkOutboundOrderRepository { get; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundService/IMesRworkOutboundOrderService.cs

@@ -3,6 +3,8 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_IOutboundRepository;
using WIDESEA_Model.Models;
@@ -12,5 +14,15 @@
    public interface IMesRworkOutboundOrderService : IService<Dt_MesRworkOutboundOrder>
    {
        IMesRworkOutboundOrderRepository Repository { get; }
        /// <summary>
        /// æåº“任务分配库存
        /// </summary>
        /// <param name="mesOutboundOrder"></param>
        /// <returns></returns>
        (List<Dt_ProStockInfo>?, Dt_MesRworkOutboundOrder?, List<Dt_OutProStockInfo>?, List<Dt_LocationInfo>) AssignMesStocks(Dt_MesRworkOutboundOrder mesRworkOutboundOrders);
        /// <summary>
        /// å¤„理出库数据
        /// </summary>
        WebResponseContent LockOutboundStockDataUpdate(List<Dt_ProStockInfo> stockInfos, List<Dt_OutProStockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundService/IOutProStockInfoService.cs

@@ -13,5 +13,7 @@
    {
        IOutProStockInfoRepository Repository { get; }
        Dt_OutProStockInfo GetOutStockLockInfo(Dt_ProOutOrder proOutOrder, Dt_ProOutOrderDetail proOutOrderDetail, Dt_ProStockInfo proStockInfo, float assignQty, int? taskNum = null);
        //处理提库出库详情
        Dt_OutProStockInfo GetOutStockLockInfo(Dt_MesRworkOutboundOrder mesOutboundOrder, Dt_ProStockInfo outStock, float assignQuantity, int? taskNum = null);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundService/IProOutOrderDetailService.cs

@@ -17,7 +17,7 @@
        /// <summary>
        /// åˆ†é…åº“存处理货位数据
        /// </summary>
        (List<Dt_ProStockInfo>, List<Dt_ProOutOrderDetail>, List<Dt_OutProStockInfo>, List<Dt_LocationInfo>) AssignProStockOut(int warehouseId,Dt_ProOutOrder proOutOrder);
        (List<Dt_ProStockInfo>, List<Dt_ProOutOrderDetail>, List<Dt_OutProStockInfo>, List<Dt_LocationInfo>) AssignProStockOut(List<Dt_ProOutOrderDetail> proOutOrderDetails);
        /// <summary>
        /// å‡ºåº“任务数据处理
        /// </summary>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundService/IProOutOrderService.cs

@@ -19,5 +19,10 @@
        /// </summary>
        /// <returns></returns>
        WebResponseContent ProductDeliveryOrder(ErpProOutOrderDTO outOrderDTO);
        /// <summary>
        /// æˆå“å‡ºå¾…发货区(平库)+同步ERP出库
        /// </summary>
        /// <returns></returns>
        WebResponseContent OutProductPK(string[] OutPKCodes, string ProOutNo);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IStockRepository/IProStockInfoRepository.cs

@@ -14,5 +14,9 @@
        /// æŸ¥æ‰¾å¯ç”¨åº“å­˜
        /// </summary>
        List<Dt_ProStockInfo> GetProStocks(Dt_ProOutOrderDetail proOutOrderDetail,List<string> locationInfos);
        /// <summary>
        /// èŽ·å–成品库存
        /// </summary>
        List<Dt_ProStockInfo> GetProStocks(Dt_MesRworkOutboundOrder mesRworkOutboundOrder, List<string> locationInfos);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IStockService/IProStockInfoService.cs

@@ -3,6 +3,7 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_IStockRepository;
using WIDESEA_Model.Models;
@@ -13,6 +14,12 @@
    {
        IProStockInfoRepository Repository { get; }
        /// <summary>
        /// æ ¹æ®å¤–包信息解绑内包与胶框库存信息
        /// </summary>
        /// <param name="proStockInfoDetails"></param>
        /// <returns></returns>
        WebResponseContent UnBindStock(List<Dt_ProStockInfoDetail> proStockInfoDetails);
        /// <summary>
        /// æŸ¥æ‰¾å¯ç”¨åº“å­˜
        /// </summary>
        List<Dt_ProStockInfo> GetUseableStocks(int warehoseId, Dt_ProOutOrderDetail proOutOrderDetail);
@@ -20,5 +27,15 @@
        /// èŽ·å–出库库存
        /// </summary>
        List<Dt_ProStockInfo> GetOutboundStocks(List<Dt_ProStockInfo> stockInfos, Dt_ProOutOrderDetail outOrderDetail, float needQuantity, out float residueQuantity);
        
        /// <summary>
        /// MES提库可用库存
        /// </summary>
        /// <returns></returns>
        public List<Dt_ProStockInfo> GetUseableStocks(Dt_MesRworkOutboundOrder mesRworkOutboundOrder);
        /// <summary>
        /// èŽ·å–MES提库库存
        /// </summary>
        List<Dt_ProStockInfo> GetOutboundStocks(List<Dt_ProStockInfo> stockInfos, Dt_MesRworkOutboundOrder mesRworkOutboundOrder, float needQuantity, out float residueQuantity);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_ITaskInfoService/ITaskService.cs

@@ -15,6 +15,7 @@
 *----------------------------------------------------------------*/
#endregion << ç‰ˆ æœ¬ æ³¨ é‡Š >>

using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using System;
using System.Collections.Generic;
@@ -353,6 +354,8 @@
        /// <param name="ProOutNo">出库订单号</param>
        /// <param name="StationCode">站台地址</param>
        /// <returns></returns>
        WebResponseContent OutProductTask(string ProOutNo, string StationCode);
        WebResponseContent OutProductTask(int[] keys, string StationCode);
        //库存板出库
        WebResponseContent ProductOutBoundSync(MesProductOutBound model);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/InboundOrderService.cs

@@ -7,6 +7,7 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection.Metadata;
@@ -690,6 +691,12 @@
                    return WebResponseContent.Instance.Error($"未找到入库单明细信息");
                }
                List<MatSerNumAnalysisModel> models = CodeAnalysisHelper.CodeAnalysis<MatSerNumAnalysisModel>(AnalysisCodeEnum.MatSerNumAnalysis, serNums);
                //验证判断时间格式
                WebResponseContent IsValidContent = IsValidMCDates(models);
                if (!IsValidContent.Status)
                {
                    return content.Error(IsValidContent.Message);
                }
                //除采购入库单以外其他入库单组盘数据处理
                if (inboundOrder.OrderType != InOrderTypeEnum.Purchase.ObjToInt())
                {
@@ -706,7 +713,6 @@
                }

                List<string> purchaseOrderNos = receiveOrder.Details.Select(x => x.PurchaseOrderNo).ToList();

                if (models.Select(x => x.MaterielCode).Distinct().Count() > 1)
                {
                    return WebResponseContent.Instance.Error($"物料不可混放");
@@ -864,7 +870,12 @@
                {
                    return content.Error($"物料不可混放");
                }

                //验证判断时间格式
                WebResponseContent IsValidContent = IsValidMCDates(models);
                if (!IsValidContent.Status)
                {
                    return content.Error(IsValidContent.Message);
                }
                string materielCode = models.FirstOrDefault()?.MaterielCode ?? "";
                Dt_MaterielInfo materielInfo = _basicRepository.MaterielInfoRepository.QueryFirst(x => x.MaterielCode == materielCode);
                if (materielInfo == null)
@@ -1016,7 +1027,12 @@
                {
                    return WebResponseContent.Instance.Error($"物料不可混放");
                }

                //验证判断时间格式
                WebResponseContent IsValidContent = IsValidMCDates(models);
                if (!IsValidContent.Status)
                {
                    return content.Error(IsValidContent.Message);
                }
                string materielCode = models.FirstOrDefault()?.MaterielCode ?? "";
                Dt_MaterielInfo materielInfo = _basicRepository.MaterielInfoRepository.QueryFirst(x => x.MaterielCode == materielCode);
                if (materielInfo == null)
@@ -1507,5 +1523,50 @@
            }
            return -1;
        }
        /// <summary>
        /// åˆ¤æ–­æ­£ç¡®æ—¶é—´æ ¼å¼
        /// </summary>
        public WebResponseContent IsValidMCDates(List<MatSerNumAnalysisModel> analysisModels)
        {
            string[] effDates = analysisModels.Select(x => x.EffectiveDate).Distinct().ToArray();
            string[] ProDates = analysisModels.Select(x => x.ProductionDate).Distinct().ToArray();
            foreach (string effDate in effDates)
            {
                string format = "yyyy-MM-dd"; // ç›®æ ‡æ ¼å¼
                DateTime parsedDate;
                // è§£æžå¹¶éªŒè¯æ ¼å¼
                bool isValid = DateTime.TryParseExact(
                    effDate,
                    format,
                    CultureInfo.InvariantCulture,
                    DateTimeStyles.None,
                    out parsedDate
                );

                if (!isValid)
                {
                    return WebResponseContent.Instance.Error("格式无效或日期不合法");
                }
            }
            foreach (string ProDate in ProDates)
            {
                string format = "yyyy-MM-dd"; // ç›®æ ‡æ ¼å¼
                DateTime parsedDate;
                // è§£æžå¹¶éªŒè¯æ ¼å¼
                bool isValid = DateTime.TryParseExact(
                    ProDate,
                    format,
                    CultureInfo.InvariantCulture,
                    DateTimeStyles.None,
                    out parsedDate
                );

                if (!isValid)
                {
                    return WebResponseContent.Instance.Error("格式无效或日期不合法");
                }
            }
            return WebResponseContent.Instance.OK();
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/ReceiveOrderDetailService.cs

@@ -2,6 +2,7 @@
using AutoMapper;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
@@ -12,11 +13,13 @@
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.CodeConfigEnum;
using WIDESEA_Core.Helper;
using WIDESEA_DTO;
using WIDESEA_DTO.Basic;
using WIDESEA_IBasicRepository;
using WIDESEA_ICheckRepository;
using WIDESEA_IInboundRepository;
using WIDESEA_IInboundService;
using WIDESEA_IStockRepository;
using WIDESEA_Model.Models;

namespace WIDESEA_InboundService
@@ -28,14 +31,16 @@
        private readonly IInboundRepository _inboundRepository;
        private readonly IBasicRepository _basicRepository;
        private readonly ICheckOrderRepository _checkOrderRepository;
        private readonly IStockRepository _stockRepository;

        public ReceiveOrderDetailService(IReceiveOrderDetailRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IInboundRepository inboundRepository, IBasicRepository basicRepository, ICheckOrderRepository checkOrderRepository) : base(BaseDal)
        public ReceiveOrderDetailService(IReceiveOrderDetailRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IInboundRepository inboundRepository, IBasicRepository basicRepository, ICheckOrderRepository checkOrderRepository, IStockRepository stockRepository) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            _inboundRepository = inboundRepository;
            _basicRepository = basicRepository;
            _checkOrderRepository = checkOrderRepository;
            _stockRepository = stockRepository;
        }

        private static object _rowNoLocker = new object();
@@ -61,7 +66,54 @@
                }

                MatSerNumAnalysisModel model = CodeAnalysisHelper.CodeAnalysis<MatSerNumAnalysisModel>(AnalysisCodeEnum.MatSerNumAnalysis, serNum);
                //收货增加批次卡控
                //查询收货明细是否有存在同一个批次
                Dt_ReceiveOrderDetail receiveOrderDetailOld = _inboundRepository.ReceiveOrderDetailRepository.QueryFirst(x => x.LotNo == model.LotNo);
                Dt_ReceiveOrder? receiveOrderOld = null;
                if (receiveOrderDetailOld!=null)
                {
                    receiveOrderOld = _inboundRepository.ReceiveOrderRepository.QueryFirst(x => x.ReceiveOrderId == receiveOrderDetailOld.ReceiveOrderId);
                }
                if (receiveOrderDetailOld!=null && receiveOrderOld?.WarehouseId== receiveOrder.WarehouseId)
                {
                    return WebResponseContent.Instance.Error($"收货单号{receiveOrderOld.ReceiveOrderNo}中批次{model.LotNo}已存在");
                }
                //查询库存批次是否有存在同一个批次
                Dt_StockInfoDetail stockInfoDetail = _stockRepository.StockInfoDetailRepository.QueryFirst(x => x.BatchNo == model.LotNo);
                Dt_StockInfo? stockInfo = null;
                if (stockInfoDetail!=null)
                {
                    stockInfo = _stockRepository.StockInfoRepository.QueryFirst(x => x.Id == stockInfoDetail.Id);
                }
                if (stockInfoDetail!=null && stockInfo?.WarehouseId==receiveOrder.WarehouseId)
                {
                    return WebResponseContent.Instance.Error($"库存{stockInfo.PalletCode}中批次{model.LotNo}已存在");
                }
                if (model!=null)
                {
                    string format = "yyyy-MM-dd"; // ç›®æ ‡æ ¼å¼
                    DateTime parsedDate;
                    // è§£æžéªŒè¯æ ¼å¼
                    bool isValidEffDate = DateTime.TryParseExact(
                        model.EffectiveDate,
                        format,
                        CultureInfo.InvariantCulture,
                        DateTimeStyles.None,
                        out parsedDate
                    );
                    bool isValidProDate = DateTime.TryParseExact(
                        model.ProductionDate,
                        format,
                        CultureInfo.InvariantCulture,
                        DateTimeStyles.None,
                        out parsedDate
                    );

                    if (!isValidEffDate || !isValidProDate)
                    {
                        return WebResponseContent.Instance.Error("格式无效或日期不合法");
                    }
                }
                Dt_MaterielInfo materielInfo = _basicRepository.MaterielInfoRepository.QueryFirst(x => x.MaterielCode == model.MaterielCode);
                if (materielInfo == null)
                {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/Outbound/Dt_MesRworkOutboundOrder.cs

@@ -41,23 +41,17 @@
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "任务单号")]
        public string TaskNo { get; set; }

        ///// <summary>
        ///// å•æ®æ•°é‡
        ///// </summary>
        //[SugarColumn(IsNullable = false, ColumnDescription = "单据数量")]
        //public float OrderQuantity { get; set; }
        /// <summary>
        /// é”å®šæ•°é‡
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "锁定数量", DefaultValue = "0")]
        public float LockQuantity { get; set; }

        ///// <summary>
        ///// é”å®šæ•°é‡
        ///// </summary>
        //[SugarColumn(IsNullable = false, ColumnDescription = "锁定数量", DefaultValue = "0")]
        //public float LockQuantity { get; set; }

        ///// <summary>
        ///// å·²å‡ºæ•°é‡
        ///// </summary>
        //[SugarColumn(IsNullable = false, ColumnDescription = "已出数量", DefaultValue = "0")]
        //public float OverOutQuantity { get; set; }
        /// <summary>
        /// å·²å‡ºæ•°é‡
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "已出数量", DefaultValue = "0")]
        public float OverOutQuantity { get; set; }

        /// <summary>
        /// å•æ®çŠ¶æ€
@@ -71,11 +65,11 @@
        [SugarColumn(IsNullable = false, ColumnDescription = "创建方式", IsOnlyIgnoreUpdate = true)]
        public int CreateType { get; set; }

        ///// <summary>
        ///// å•æ®ç±»åž‹
        ///// </summary>
        //[SugarColumn(IsNullable = false, ColumnDescription = "单据类型", IsOnlyIgnoreUpdate = true)]
        //public int OrderType { get; set; }
        /// <summary>
        /// å•æ®ç±»åž‹
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "单据类型", IsOnlyIgnoreUpdate = true)]
        public int OrderType { get; set; }

        /// <summary>
        /// äº§å“ç¼–码
@@ -113,10 +107,5 @@
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "销售订单")]
        public string SaleOrder { get; set; }
        /// <summary>
        /// åº“存类型
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "库存类型", IsOnlyIgnoreUpdate = true)]
        public int InventoryType { get; set; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundRepository/OutboundRepository.cs

@@ -16,13 +16,19 @@
        public IOutStockLockInfoRepository OutboundStockLockInfoRepository { get; }

        public IMesPPCutOutboundOrderRepository MesPPCutOutboundOrderRepository { get; }
        public IProOutOrderRepository ProOutOrderRepository { get; }
        public IProOutOrderDetailRepository ProOutOrderDetailRepository { get; }
        public IMesRworkOutboundOrderRepository RworkOutboundOrderRepository { get; }

        public OutboundRepository(IOutboundOrderDetailRepository outboundOrderDetailRepository, IOutboundOrderRepository outboundOrderRepository, IOutStockLockInfoRepository outboundStockLockInfoRepository,IMesPPCutOutboundOrderRepository mesPPCutOutboundOrderRepository)
        public OutboundRepository(IOutboundOrderDetailRepository outboundOrderDetailRepository, IOutboundOrderRepository outboundOrderRepository, IOutStockLockInfoRepository outboundStockLockInfoRepository,IMesPPCutOutboundOrderRepository mesPPCutOutboundOrderRepository, IProOutOrderRepository proOutOrderRepository, IProOutOrderDetailRepository proOutOrderDetailRepository, IMesRworkOutboundOrderRepository rworkOutboundOrderRepository)
        {
            OutboundOrderDetailRepository = outboundOrderDetailRepository;
            OutboundOrderRepository = outboundOrderRepository;
            OutboundStockLockInfoRepository = outboundStockLockInfoRepository;
            MesPPCutOutboundOrderRepository = mesPPCutOutboundOrderRepository;
            ProOutOrderRepository = proOutOrderRepository;
            ProOutOrderDetailRepository = proOutOrderDetailRepository;
            RworkOutboundOrderRepository = rworkOutboundOrderRepository;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/MesRworkOutboundOrderService.cs

@@ -3,7 +3,11 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Helper;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundRepository;
@@ -22,16 +26,127 @@
        private readonly IOutStockLockInfoService _outStockLockInfoService;
        private readonly IBasicService _basicService;
        private readonly IRecordService _recordService;
        private readonly IOutProStockInfoService _outProStockInfoService;

        public IMesRworkOutboundOrderRepository Repository => BaseDal;

        public MesRworkOutboundOrderService(IMesRworkOutboundOrderRepository BaseDal, IBasicRepository basicRepository, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IBasicService basicService, IRecordService recordService) : base(BaseDal)
        public MesRworkOutboundOrderService(IMesRworkOutboundOrderRepository BaseDal, IBasicRepository basicRepository, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IBasicService basicService, IRecordService recordService, IOutProStockInfoService outProStockInfoService) : base(BaseDal)
        {
            _basicRepository = basicRepository;
            _stockService = stockService;
            _outStockLockInfoService = outStockLockInfoService;
            _basicService = basicService;
            _recordService = recordService;
            _outProStockInfoService = outProStockInfoService;
        }
        /// <summary>
        /// æåº“任务分配库存
        /// </summary>
        public (List<Dt_ProStockInfo>?,Dt_MesRworkOutboundOrder?,List<Dt_OutProStockInfo>?,List<Dt_LocationInfo>) AssignMesStocks(Dt_MesRworkOutboundOrder mesRworkOutboundOrder)
        {
            List<Dt_ProStockInfo> proStockInfos = new List<Dt_ProStockInfo>();
            Dt_MesRworkOutboundOrder assignOutOrder= new Dt_MesRworkOutboundOrder();
            List<Dt_OutProStockInfo> outProStockInfos=new List<Dt_OutProStockInfo>();
            List<Dt_LocationInfo> locationInfos=new List<Dt_LocationInfo>();
            float originalNeedQuantity = mesRworkOutboundOrder.RequiredQuantity;

            float needQuantity = originalNeedQuantity;

            //查找可用库存
            List<Dt_ProStockInfo> stockInfoss = _stockService.ProStockInfoService.GetUseableStocks(mesRworkOutboundOrder);
            if (!stockInfoss.Any())
            {
                throw new Exception("未找到可分配库存");
            }
            List<Dt_ProStockInfo> autoAssignStocks = _stockService.ProStockInfoService.GetOutboundStocks(stockInfoss,mesRworkOutboundOrder, needQuantity,out float residueQuantity);
            mesRworkOutboundOrder.LockQuantity += needQuantity - residueQuantity;
            autoAssignStocks.OrderBy(x => x.proStockInfoDetails.FirstOrDefault()?.StockPcsQty).ToList();
            proStockInfos.AddRange(autoAssignStocks);
            float assignQuantity = needQuantity - residueQuantity;

            float orderQuantity = mesRworkOutboundOrder.RequiredQuantity;
            for (int j = 0; j < autoAssignStocks.Count; j++)
            {
                //出库订单明细已分配数量
                float detailAssignQuantity = outProStockInfos
                    .Where(x => x.SaleOrder == mesRworkOutboundOrder.SaleOrder 
                    && x.PCode == mesRworkOutboundOrder.ProductCode 
                    && x.PVer == mesRworkOutboundOrder.ProductVersion)
                    .Sum(x => x.AssignQuantity);

                //出库详情已分配数量
                float palletAssignQuantity = outProStockInfos
                    .Where(x => x.SaleOrder == mesRworkOutboundOrder.SaleOrder 
                    && x.PCode == mesRworkOutboundOrder.ProductCode 
                    && x.PVer == mesRworkOutboundOrder.ProductVersion 
                    && x.PalletCode == autoAssignStocks[j].PalletCode)
                    .Sum(x => x.AssignQuantity);

                float palletOutboundQuantity = autoAssignStocks[j].proStockInfoDetails.Sum(x => x.OutboundQuantity);
                if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
                {
                    float orderDetailNeedQuantity = mesRworkOutboundOrder.RequiredQuantity - detailAssignQuantity;
                    if (orderDetailNeedQuantity > autoAssignStocks[j].proStockInfoDetails.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
                    {
                        mesRworkOutboundOrder.LockQuantity += autoAssignStocks[j].proStockInfoDetails.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
                        Dt_OutProStockInfo outStockLockInfo = _outProStockInfoService.GetOutStockLockInfo(mesRworkOutboundOrder, autoAssignStocks[j], autoAssignStocks[j].proStockInfoDetails.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
                        outProStockInfos.Add(outStockLockInfo);
                    }
                    else
                    {
                        Dt_OutProStockInfo outStockLockInfo = _outProStockInfoService.GetOutStockLockInfo(mesRworkOutboundOrder, autoAssignStocks[j], mesRworkOutboundOrder.RequiredQuantity-mesRworkOutboundOrder.LockQuantity);
                        outProStockInfos.Add(outStockLockInfo);
                        mesRworkOutboundOrder.LockQuantity = mesRworkOutboundOrder.RequiredQuantity;
                        break;
                    }
                }
            }
            locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(proStockInfos.Select(x => x.LocationCode).ToList()));

            return (proStockInfos, assignOutOrder, outProStockInfos, locationInfos);
        }
        public WebResponseContent LockOutboundStockDataUpdate(List<Dt_ProStockInfo> stockInfos, List<Dt_OutProStockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null)
        {
            try
            {
                stockInfos.ForEach(x => {
                    x.StockStatus = StockStatusEmun.出库锁定.ObjToInt();
                });
                _stockService.ProStockInfoService.Repository.UpdateData(stockInfos);
                List<Dt_ProStockInfoDetail> stockInfoDetails = new List<Dt_ProStockInfoDetail>();
                foreach (var item in stockInfos)
                {
                    stockInfoDetails.AddRange(item.proStockInfoDetails);
                }
                _stockService.ProStockInfoDetailService.Repository.UpdateData(stockInfoDetails);

                List<Dt_OutProStockInfo> addOutStockLockInfos = outStockLockInfos.Where(x => x.Id == 0).ToList();
                if (addOutStockLockInfos != null && addOutStockLockInfos.Any())
                {
                    if (tasks != null)
                    {
                        addOutStockLockInfos.ForEach(x =>
                        {
                            x.TaskNum = tasks.FirstOrDefault(v => v.PalletCode == x.PalletCode)?.TaskNum;
                        });
                    }

                    _outProStockInfoService.Repository.AddData(addOutStockLockInfos);
                }
                List<Dt_OutProStockInfo> updateOutStockLockInfos = outStockLockInfos.Where(x => x.Id > 0).ToList();
                if (updateOutStockLockInfos != null && updateOutStockLockInfos.Any())
                {
                    _outProStockInfoService.Repository.UpdateData(updateOutStockLockInfos);
                }

                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfos, locationStatus, LocationChangeType.OutboundAssignLocation, "", tasks?.Select(x => x.TaskNum).ToList());
                _basicService.LocationInfoService.Repository.UpdateLocationStatus(locationInfos, locationStatus);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/OutProStockInfoService.cs

@@ -49,5 +49,33 @@
            };
            return outProStockInfo;
        }
        public Dt_OutProStockInfo GetOutStockLockInfo(Dt_MesRworkOutboundOrder mesOutboundOrder, Dt_ProStockInfo outStock, float assignQuantity, int? taskNum = null)
        {

            Dt_OutProStockInfo outProStockInfo = new Dt_OutProStockInfo()
            {
                OrderNo = mesOutboundOrder.OrderNo,
                OrderDetailId = mesOutboundOrder.Id,
                OrderType = mesOutboundOrder.OrderType,
                BatchNo = outStock.proStockInfoDetails.FirstOrDefault()?.LotNumber,
                SaleOrder = mesOutboundOrder.SaleOrder,
                Customer = "",
                PCode = mesOutboundOrder.ProductCode,
                PVer = mesOutboundOrder.ProductVersion,
                PLot = outStock.proStockInfoDetails.FirstOrDefault()?.LotNumber,
                DateCode = mesOutboundOrder.DateCode,
                StockId = outStock.Id,
                OrderQuantity = mesOutboundOrder.RequiredQuantity,
                OriginalQuantity = outStock.proStockInfoDetails.Sum(x => x.StockPcsQty),
                AssignQuantity = assignQuantity,
                LocationCode = outStock.LocationCode,
                PalletCode = outStock.PalletCode,
                Unit = "PCS",
                TaskNum = taskNum,
                Status = taskNum == null ? OutLockStockStatusEnum.已分配.ObjToInt() : OutLockStockStatusEnum.出库中.ObjToInt()
            };

            return outProStockInfo;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundOrderService.cs

@@ -88,17 +88,17 @@
                int pageNo = saveModel.MainData["pageNo"].ObjToInt();
                string? orderNo = saveModel.MainData["orderNo"].ToString();
                int warehouseId = saveModel.MainData["warehouseId"].ObjToInt();
                List<Dt_OutboundOrder> dt_ReceiveOrders = new List<Dt_OutboundOrder>();
                List<Dt_OutboundOrder> _OutboundOrders = new List<Dt_OutboundOrder>();
                if (string.IsNullOrEmpty(orderNo))
                {
                    dt_ReceiveOrders = Db.Queryable<Dt_OutboundOrder>().Where(x => x.OrderStatus < OutLockStockStatusEnum.出库完成.ObjToInt() && x.WarehouseId == warehouseId).OrderByDescending(x => x.CreateDate).ToPageList(pageNo, 5);
                    _OutboundOrders = Db.Queryable<Dt_OutboundOrder>().Where(x => x.OrderStatus < OutOrderStatusEnum.出库完成.ObjToInt() && x.WarehouseId == warehouseId).OrderByDescending(x => x.CreateDate).ToPageList(pageNo, 5);
                }
                else
                {
                    dt_ReceiveOrders = Db.Queryable<Dt_OutboundOrder>().Where(x => (x.OrderNo.Contains(orderNo)) && x.OrderStatus < OutLockStockStatusEnum.出库完成.ObjToInt() && x.WarehouseId == warehouseId).OrderByDescending(x => x.CreateDate).ToPageList(pageNo, 5);
                    _OutboundOrders = Db.Queryable<Dt_OutboundOrder>().Where(x => (x.OrderNo.Contains(orderNo)) && x.OrderStatus < OutOrderStatusEnum.出库完成.ObjToInt() && x.WarehouseId == warehouseId).OrderByDescending(x => x.CreateDate).ToPageList(pageNo, 5);
                }

                content.OK(data: dt_ReceiveOrders);
                content.OK(data: _OutboundOrders);
            }
            catch (Exception ex)
            {
@@ -283,19 +283,21 @@
        {
            try
            {
                Dt_OutboundOrder oldOutboundOrder = BaseDal.Db.Queryable<Dt_OutboundOrder>().Where(x => x.UpperOrderNo == model.OrderNo && x.OrderStatus < OutOrderStatusEnum.关闭.ObjToInt()).Includes(x => x.Details).OrderBy(x => x.CreateDate).First();
                Dt_MaterielInfo materielInfo = _basicService.MaterielInfoService.Repository.QueryFirst(x => x.MaterielCode == model.MCode);

                if (materielInfo == null)
                {
                    DelOutOrder(oldOutboundOrder);
                    return WebResponseContent.Instance.Error($"未找到该物料信息");
                }

                Dt_Warehouse warehouse = _basicService.WarehouseService.Repository.QueryFirst(x => x.WarehouseCode == model.WaId);
                if (warehouse == null)
                {
                    DelOutOrder(oldOutboundOrder);
                    return WebResponseContent.Instance.Error($"未找到该仓库信息");
                }

                Dt_OutboundOrder oldOutboundOrder = BaseDal.Db.Queryable<Dt_OutboundOrder>().Where(x => x.UpperOrderNo == model.OrderNo).Includes(x => x.Details).First();

                if (model.Way == 1)
                {
@@ -303,10 +305,12 @@
                    {
                        if (oldOutboundOrder.Details.FirstOrDefault(x => x.RowNo == Convert.ToInt32(model.RowNo)) != null)
                        {
                            DelOutOrder(oldOutboundOrder);
                            return WebResponseContent.Instance.Error($"该明细行号已存在");
                        }
                        if (oldOutboundOrder.WarehouseId != warehouse.WarehouseId)
                        {
                            DelOutOrder(oldOutboundOrder);
                            return WebResponseContent.Instance.Error($"仓库不一致");
                        }
                        else
@@ -412,6 +416,28 @@
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        /// <summary>
        /// è¯¥å•æ®å¤±è´¥è¿›è¡Œåˆ é™¤
        /// </summary>
        /// <returns></returns>
        public void DelOutOrder(Dt_OutboundOrder outboundOrder)
        {
            try
            {
                if (outboundOrder != null && outboundOrder.Details.Count > 0)
                {
                    _unitOfWorkManage.BeginTran();
                    _outboundOrderRepository.DeleteAndMoveIntoHty(outboundOrder, OperateTypeEnum.自动删除);
                    _outboundOrderDetailRepository.DeleteAndMoveIntoHty(outboundOrder.Details, OperateTypeEnum.自动删除);
                    _unitOfWorkManage.CommitTran();
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                throw new Exception(ex.Message);
            }
        }
        //上报出库完成
        public WebResponseContent TestOutUpload(int id, List<Dt_OutStockLockInfo>? outStockLockInfos)
        {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/ProOutOrderDetailService.cs

@@ -25,14 +25,16 @@
        private readonly IStockService _stockInfoService;
        private readonly IBasicService _basicService;
        private readonly IOutProStockInfoService _outProStockInfoService;
        private readonly IProOutOrderRepository _proOutOrderRepository;
        private readonly IRecordService _recordService;
        public ProOutOrderDetailService(IProOutOrderDetailRepository BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockService stockInfoService, IBasicService basicService,IOutProStockInfoService outProStockInfoService, IRecordService recordService) : base(BaseDal)
        public ProOutOrderDetailService(IProOutOrderDetailRepository BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockService stockInfoService, IBasicService basicService,IOutProStockInfoService outProStockInfoService, IRecordService recordService, IProOutOrderRepository proOutOrderRepository) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _stockInfoService = stockInfoService;
            _basicService = basicService;
            _outProStockInfoService = outProStockInfoService;
            _recordService = recordService;
            _proOutOrderRepository=proOutOrderRepository;
        }
        /// <summary>
        /// å‡ºåº“库存分配后，更新数据库数据
@@ -81,17 +83,18 @@
        /// <summary>
        /// åˆ†é…åº“存处理货位数据
        /// </summary>
        public (List<Dt_ProStockInfo>, List<Dt_ProOutOrderDetail>, List<Dt_OutProStockInfo>, List<Dt_LocationInfo>) AssignProStockOut(int warehouseId, Dt_ProOutOrder proOutOrder)
        public (List<Dt_ProStockInfo>, List<Dt_ProOutOrderDetail>, List<Dt_OutProStockInfo>, List<Dt_LocationInfo>) AssignProStockOut(List<Dt_ProOutOrderDetail> proOutOrderDetails)
        {
            List<Dt_ProOutOrderDetail> OutOrderDetails = proOutOrder.Details;
            if (!OutOrderDetails.Any())
            {
                throw new Exception($"未找到出库单明细信息");
            }
            List<Dt_ProStockInfo> outStocks = new List<Dt_ProStockInfo>();
            List<Dt_OutProStockInfo> outProStockInfos = new List<Dt_OutProStockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
            List<Dt_ProOutOrderDetail> groupDetails = OutOrderDetails.GroupBy(x => new { x.SaleOrder, x.PCode, x.PVer, x.PLot, x.DateCode }).Select(x => new Dt_ProOutOrderDetail()
            //获取成品订单
            Dt_ProOutOrder proOutOrder = _proOutOrderRepository.QueryFirst(x=>x.Id==proOutOrderDetails.FirstOrDefault().ProOrderId);
            if (proOutOrder==null)
            {
                throw new Exception("未找到成品订单");
            }
            List<Dt_ProOutOrderDetail> groupDetails = proOutOrderDetails.GroupBy(x => new { x.SaleOrder, x.PCode, x.PVer, x.PLot, x.DateCode }).Select(x => new Dt_ProOutOrderDetail()
            {
                QtyPcs = x.Sum(x => x.QtyPcs) - x.Sum(x => x.OverQtyPcs),
                SaleOrder = x.Key.SaleOrder,
@@ -104,7 +107,7 @@
            {
                float needQty = item.QtyPcs;
                //查找可用库存
                List<Dt_ProStockInfo> stockInfoss = _stockInfoService.ProStockInfoService.GetUseableStocks(warehouseId, item);
                List<Dt_ProStockInfo> stockInfoss = _stockInfoService.ProStockInfoService.GetUseableStocks(proOutOrder.WarehouseId, item);
                if (!stockInfoss.Any())
                {
                    throw new Exception("未找到可分配库存");
@@ -116,7 +119,7 @@
                float assignQuantity = needQty - residueQuantity;
                bool isCanLot = !string.IsNullOrEmpty(item.PLot);
                bool isCanDate = !string.IsNullOrEmpty(item.DateCode);
                List<Dt_ProOutOrderDetail> details = OutOrderDetails
                List<Dt_ProOutOrderDetail> details = proOutOrderDetails
                    .Where(x => x.SaleOrder == item.SaleOrder && x.PCode == item.PCode && x.PVer == item.PVer
                    && (isCanLot ? x.PLot == item.PLot : true)
                    && (isCanDate ? x.DateCode == item.DateCode : true))
@@ -166,7 +169,7 @@
                locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(locationArr));

            }
            return (outStocks, OutOrderDetails, outProStockInfos, locationInfos);
            return (outStocks, proOutOrderDetails, outProStockInfos, locationInfos);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/ProOutOrderService.cs

@@ -1,21 +1,28 @@
using AutoMapper;
using Castle.Core.Resource;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.CodeConfigEnum;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.ERP;
using WIDESEA_External.ERPService;
using WIDESEA_External.Model;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundRepository;
using WIDESEA_IOutboundService;
using WIDESEA_IRecordService;
using WIDESEA_IStockRepository;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;

@@ -26,14 +33,22 @@
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IBasicRepository _basicRepository;
        private readonly IMapper _mapper;
        private readonly IStockRepository _stockRepository;
        private readonly IOutboundRepository _outboundRepository;
        private readonly IOutboundOrderService _outboundOrderService;
        private readonly IInvokeERPService _invokeERPService; 

        public IProOutOrderRepository Repository => BaseDal;

        public ProOutOrderService(IProOutOrderRepository BaseDal, IUnitOfWorkManage unitOfWorkManage, IBasicRepository basicRepository, IMapper mapper) : base(BaseDal)
        public ProOutOrderService(IProOutOrderRepository BaseDal, IUnitOfWorkManage unitOfWorkManage, IBasicRepository basicRepository, IMapper mapper, IStockRepository stockRepository, IOutboundRepository outboundRepository, IOutboundOrderService outboundOrderService,IInvokeERPService invokeERPService) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _basicRepository = basicRepository;
            _mapper = mapper;
            _stockRepository = stockRepository;
            _outboundRepository = outboundRepository;
            _outboundOrderService = outboundOrderService;
            _invokeERPService = invokeERPService;
        }
        /// <summary>
        /// æŽ¥æ”¶ERP成品出库单
@@ -70,6 +85,7 @@
                    return content.Error($"出库单号{outOrderDTO.OrderNo}已存在!");
                }
                Dt_Warehouse warehouse=null;
                List<Dt_CustomerInfo> customerInfos = _basicRepository.CustomerInfoRepository.QueryData();
                if (outOrderDTO.OType==1 && string.IsNullOrEmpty(outOrderDTO.WaType))
                {
                    warehouse = _basicRepository.WarehouseRepository.QueryFirst(x=>x.WarehouseCode==WarehouseEnum.HA71.ToString());
@@ -81,6 +97,12 @@
                List<Dt_ProOutOrderDetail> proOutOrderDetails = new List<Dt_ProOutOrderDetail>();
                foreach (var item in outOrderDTO.OrderDetails)
                {
                    //判断客户是否存在
                    Dt_CustomerInfo? customerInfo = customerInfos.Where(x=>x.Code== item.Customer).FirstOrDefault();
                    if (customerInfo==null) 
                    {
                        return content.Error($"客户{item.Customer}不存在!");
                    }
                    proOutOrderDetails.Add(_mapper.Map<Dt_ProOutOrderDetail>(item));
                }
                Dt_ProOutOrder  proOutOrder= new Dt_ProOutOrder()
@@ -136,5 +158,139 @@
            }
            return content;
        }
        /// <summary>
        /// æˆå“å‡ºå¾…发货区(平库)+同步ERP出库
        /// </summary>
        /// <returns></returns>
        public WebResponseContent OutProductPK(string[] OutPKCodes,string ProOutNo)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                if (OutPKCodes.IsNullOrEmpty())
                {
                    return content.Error("不能为空");
                }
                Dt_ProOutOrder proOutOrder = _outboundRepository.ProOutOrderRepository.Db.Queryable<Dt_ProOutOrder>().Where(x => x.ProOutOrderNo == ProOutNo).Includes(x => x.Details).First();
                if (proOutOrder == null)
                {
                    return content.Error($"出库单{ProOutNo}不存在");
                }
                if (proOutOrder.ProOrderStatus==OutOrderStatusEnum.出库完成.ObjToInt())
                {
                    return content.Error($"出库单{ProOutNo}已完成");
                }
                string? userName = App.User.UserName;//GSWMS
                //获取所有外箱的数据
                List<Dt_ProStockInfo> AllproStockInfos = _stockRepository.ProStockInfoRepository.Db.Queryable<Dt_ProStockInfo>()
                    .Where(x => OutPKCodes.Contains(x.PalletCode) && x.StockStatus == StockStatusEmun.平库入库完成.ObjToInt())
                    .Includes(x => x.proStockInfoDetails).ToList();
                List<Dt_ProStockInfo> proStockInfos = new List<Dt_ProStockInfo>();
                List<Dt_ProStockInfoDetail> proStockInfoDetails=new List<Dt_ProStockInfoDetail>();
                List<Dt_Warehouse> warehouses = _basicRepository.WarehouseRepository.QueryData(x => x.WarehouseType == WarehouseTypEnum.成品.ToString());
                foreach (var item in OutPKCodes)
                {
                    //获取库存
                    Dt_ProStockInfo? proStockInfo = AllproStockInfos.Where(x => x.PalletCode == item).FirstOrDefault();
                    if (proStockInfo == null)
                    {
                        return content.Error($"未找到{item}库存");
                    }
                    Dt_Warehouse? dt_Warehouse = warehouses.Where(x=>x.WarehouseId== proStockInfo.WarehouseId).FirstOrDefault();
                    if (dt_Warehouse==null)
                    {
                        return content.Error($"外箱号{item},不属于成品仓");
                    }
                    if (proStockInfo.ShipmentOrder!= proOutOrder.ProOutOrderNo)
                    {
                        return content.Error($"外箱号{item},不属于出库订单{proOutOrder.ProOutOrderNo}");
                    }
                    proStockInfos.Add(proStockInfo);
                    proStockInfoDetails.AddRange(proStockInfo.proStockInfoDetails);
                }
                
                if (proOutOrder.Details.Sum(x=>x.LockQtyPcs-x.OverQtyPcs)< proStockInfoDetails.Sum(x=>x.StockPcsQty))
                {
                    return content.Error($"出库数量{proStockInfoDetails.Sum(x => x.StockPcsQty)}>所剩订单数量{proOutOrder.Details.Sum(x => x.LockQtyPcs - x.OverQtyPcs)}");
                }
                List<StockOutItemsItem> stockOutItems = new List<StockOutItemsItem>();
                List<Dt_ProOutOrderDetail> proOutOrderDetails = proOutOrder.Details.Where(x=> proStockInfoDetails.Select(x=>x.SaleOrder).Contains(x.SaleOrder) && proStockInfoDetails.Select(x=>x.ProductCode).Contains(x.PCode) && proStockInfoDetails.Select(x => x.ProductVersion).Contains(x.PVer)).ToList();
                if (proOutOrderDetails==null || proOutOrderDetails.Count<=0)
                {
                    return content.Error("对应出库订单明细为空");
                }
                foreach (var item in proStockInfoDetails)
                {
                    //获取对应明细处理出库数据
                    Dt_ProOutOrderDetail? proOutOrderDetail = proOutOrderDetails.Where(x => x.SaleOrder == item.SaleOrder && x.PVer == item.ProductVersion && x.PCode == item.ProductCode).FirstOrDefault();
                    if (proOutOrderDetail==null)
                    {
                        return content.Error("未找到对应出库订单明细");
                    }
                    proOutOrderDetail.OverQtyPcs += item.StockPcsQty;
                    if (proOutOrderDetail.OverQtyPcs> proOutOrderDetail.QtyPcs)
                    {
                        return content.Error($"出库订单明细行{proOutOrderDetail.RowId},溢出{proOutOrderDetail.QtyPcs - proOutOrderDetail.OverQtyPcs}");
                    }
                    if (proOutOrderDetail.OverQtyPcs == proOutOrderDetail.QtyPcs)
                    {
                        proOutOrderDetail.ProOrderDetailStatus = OrderDetailStatusEnum.Over.ObjToInt();
                    }
                    StockOutItemsItem outItemsItem = new StockOutItemsItem()
                    {
                        PartNum=item.ProductCode,
                        Rev=item.ProductVersion,
                        SoNumber=item.SaleOrder,
                        BatchNumber=item.BagNo,
                        QtyPcs=item.StockPcsQty,
                        QtySet=item.SETQty
                    };
                    stockOutItems.Add(outItemsItem);
                }
                int OldOverCount = proOutOrder.Details.Where(x => x.ProOrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt()).Count();
                int AddOverCount = proOutOrderDetails.Where(x => x.ProOrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt()).Count();
                if (proOutOrder.Details.Count== (OldOverCount + AddOverCount))
                {
                    proOutOrder.ProOrderStatus = OutOrderStatusEnum.出库完成.ObjToInt();
                }
                Dt_Warehouse warehouse = warehouses.Where(x => x.WarehouseId == proOutOrder.WarehouseId).FirstOrDefault();
                //处理库存数据和上传ERP
                _unitOfWorkManage.BeginTran();
                _stockRepository.ProStockInfoRepository.DeleteAndMoveIntoHty(proStockInfos, OperateTypeEnum.自动完成);
                _stockRepository.ProStockInfoDetailRepository.DeleteAndMoveIntoHty(proStockInfoDetails, OperateTypeEnum.自动完成);
                _outboundRepository.ProOutOrderDetailRepository.UpdateData(proOutOrderDetails);
                BaseDal.UpdateData(proOutOrder);
                //成品库存记录变动待加入
                ERPProOutOrderModel proOutOrderModel = new ERPProOutOrderModel()
                {
                    Way = 1,
                    StockOutCode = _outboundOrderService.CreateCodeByRule(nameof(RuleCodeEnum.ProOutCOdeRule)),
                    ConfirmedUserNo=userName,
                    AssignUserNo=userName,
                    WarehouseCode=warehouse.WarehouseCode,
                    ShipDate=DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    DeliverplanCode=proOutOrder.ProOutOrderNo,
                    Remark=proOutOrder.Remark,
                    StockOutItems= stockOutItems
                };
                string response = _invokeERPService.InvokeProOutApi(proOutOrderModel);
                ErpRequestContent erpRequestContent= response.DeserializeObject<ErpRequestContent>();
                if (erpRequestContent.res==1)
                {
                    _unitOfWorkManage.CommitTran();
                    content.OK();
                }
                else
                {
                    throw new Exception(erpRequestContent.Data);
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                content.Error(ex.Message);
            }
            return content;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockRepository/ProStockInfoRepository.cs

@@ -25,14 +25,37 @@
            proStockInfos = Db.Queryable<Dt_ProStockInfo>().Where(x => locationInfos.Contains(x.LocationCode))
                .Includes(x => x.proStockInfoDetails)
                .Where(x => x.proStockInfoDetails
                .Any(x => x.SaleOrder == proOutOrderDetail.SaleOrder
                && x.ProductCode == proOutOrderDetail.PCode
                && x.ProductVersion == proOutOrderDetail.PVer
                && (isCanLot ? x.LotNumber == proOutOrderDetail.PLot : true)
                && (isCanDate ? x.DateCode == proOutOrderDetail.DateCode : true)
                .Any(v => v.SaleOrder==proOutOrderDetail.SaleOrder
                && v.ProductCode==proOutOrderDetail.PCode
                && v.ProductVersion==proOutOrderDetail.PVer
                && (isCanLot? v.LotNumber== proOutOrderDetail.PLot:true)
                && (isCanDate ? v.DateCode == proOutOrderDetail.DateCode : true)
                ))
            .ToList();
            proStockInfos = proStockInfos.OrderBy(x => x.proStockInfoDetails.FirstOrDefault().DateCode).ToList();
            
            proStockInfos = proStockInfos.OrderBy(x => x.proStockInfoDetails.FirstOrDefault()?.DateCode).ThenBy(x=>x.proStockInfoDetails.Sum(x=>x.StockPcsQty)).ToList();
            return proStockInfos;
        }
        /// <summary>
        /// èŽ·å–MES提库库存
        /// </summary>
        /// <param name="mesRworkOutboundOrder"></param>
        /// <param name="locationInfos"></param>
        /// <returns></returns>
        public List<Dt_ProStockInfo> GetProStocks(Dt_MesRworkOutboundOrder mesRworkOutboundOrder, List<string> locationInfos)
        {
            List<Dt_ProStockInfo>? proStockInfos = null;
            bool isCanDate = !string.IsNullOrEmpty(mesRworkOutboundOrder.DateCode);
            proStockInfos = Db.Queryable<Dt_ProStockInfo>().Where(x => locationInfos.Contains(x.LocationCode))
                .Includes(x => x.proStockInfoDetails)
                .Where(x => x.proStockInfoDetails
                .Any(v => v.SaleOrder == mesRworkOutboundOrder.SaleOrder
                && v.ProductCode == mesRworkOutboundOrder.ProductCode
                && v.ProductVersion == mesRworkOutboundOrder.ProductVersion
                && (isCanDate ? v.DateCode == mesRworkOutboundOrder.DateCode : true)
                ))
            .ToList();
            proStockInfos = proStockInfos.OrderBy(x => x.proStockInfoDetails.FirstOrDefault()?.DateCode).ThenBy(x => x.proStockInfoDetails.Sum(x => x.StockPcsQty)).ToList();
            return proStockInfos;
        }
    }

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/ProStockInfoService.cs

@@ -3,8 +3,11 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.StockEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_IBasicRepository;
using WIDESEA_IStockRepository;
using WIDESEA_IStockService;
@@ -31,11 +34,54 @@
            //根据内包号进行库存扣除
            try
            {
                //获取库存
                List<string> BagNos = proStockInfoDetails.Select(x => x.BagNo).Distinct().ToList();
                List<Dt_ProStockInfo> proStockInfos = _stockRepository.ProStockInfoRepository.Db.Queryable<Dt_ProStockInfo>()
                    .Where(x => x.StockStatus == StockStatusEmun.出库完成.ObjToInt())
                    .Includes(x => x.proStockInfoDetails)
                    .Where(x => x.proStockInfoDetails.Any(v => BagNos.Contains(v.BagNo))).Distinct().ToList();
                List<Dt_ProStockInfoDetail> delProStockDetails=new List<Dt_ProStockInfoDetail>();
                //foreach (var item in collection)
                //{
                //    Dt_ProStockInfoDetail delProStockDetal=
                //}
                List<Dt_ProStockInfoDetail> upProStockDetails = new List<Dt_ProStockInfoDetail>();
                List<Dt_ProStockInfo> delProStockInfos = new List<Dt_ProStockInfo>();
                foreach (var item in proStockInfoDetails)
                {
                    Dt_ProStockInfo? proStockInfo = proStockInfos.Where(x => x.proStockInfoDetails.Any(v => v.BagNo == item?.BagNo)).FirstOrDefault();
                    Dt_ProStockInfoDetail? proStockInfoDetail = proStockInfo?.proStockInfoDetails.Where(x => x.BagNo == item?.BagNo).FirstOrDefault();
                    if (proStockInfo==null || proStockInfoDetail == null)
                    {
                       return content.Error($"未找到{item?.BagNo}库存");
                    }
                    //判断明细是否全部扫出
                    if (proStockInfoDetail.StockPcsQty==item.StockPcsQty)
                    {
                        delProStockDetails.Add(proStockInfoDetail);
                        proStockInfo.proStockInfoDetails.Remove(proStockInfoDetail);
                    }
                    else
                    {
                        proStockInfoDetail.StockPcsQty -= item.StockPcsQty;
                        proStockInfoDetail.SETQty -= item.SETQty;
                        upProStockDetails.Add(proStockInfoDetail);
                    }

                    if (proStockInfo.proStockInfoDetails.Count==0)
                    {
                        delProStockInfos.Add(proStockInfo);
                    }
                }
                if (delProStockInfos.Count>0)
                {
                    BaseDal.DeleteAndMoveIntoHty(delProStockInfos, OperateTypeEnum.自动删除);
                }
                if (delProStockDetails.Count > 0)
                {
                    _stockRepository.ProStockInfoDetailRepository.DeleteAndMoveIntoHty(delProStockDetails, OperateTypeEnum.自动删除);
                }
                if (upProStockDetails.Count > 0)
                {
                    _stockRepository.ProStockInfoDetailRepository.UpdateData(upProStockDetails);
                }
                content.OK();
            }
            catch (Exception ex)
            {
@@ -48,6 +94,15 @@
        {
            List<string> locationCodes = _basicRepository.LocationInfoRepository.GetCanOutLocationCodes(warehoseId);
            return BaseDal.GetProStocks(proOutOrderDetail,locationCodes);
        }
        /// <summary>
        /// MES提库可用库存
        /// </summary>
        /// <returns></returns>
        public List<Dt_ProStockInfo> GetUseableStocks(Dt_MesRworkOutboundOrder mesRworkOutboundOrder)
        {
            List<string> locationCodes = _basicRepository.LocationInfoRepository.GetCanOutLocationCodes(mesRworkOutboundOrder.WarehouseId);
            return BaseDal.GetProStocks(mesRworkOutboundOrder, locationCodes);
        }
        /// <summary>
        /// èŽ·å–出库库存
@@ -132,5 +187,108 @@
            residueQuantity = needQuantity;
            return assignOutStocks;
        }
        /// <summary>
        /// èŽ·å–MES提库库存
        /// </summary>
        public List<Dt_ProStockInfo> GetOutboundStocks(List<Dt_ProStockInfo> stockInfos, Dt_MesRworkOutboundOrder mesRworkOutboundOrder, float needQuantity, out float residueQuantity)
        {
            List<Dt_ProStockInfo> assignOutStocks = new List<Dt_ProStockInfo>();
            float stockTotalQuantity = stockInfos.Select(x => x.proStockInfoDetails.Sum(v => v.StockPcsQty - v.OutboundQuantity)).Sum(x => x);
            //stockInfos = stockInfos.OrderBy(x => x.Id).ToList();
            if (stockTotalQuantity >= needQuantity)//库存够
            {
                int index = 0;
                while (needQuantity > 0)
                {
                    Dt_ProStockInfo stockInfo = stockInfos[index];
                    float useableStockQuantity = stockInfo.proStockInfoDetails
                        .Where(x => x.SaleOrder == mesRworkOutboundOrder.SaleOrder && x.ProductCode == mesRworkOutboundOrder.ProductCode && x.ProductVersion == mesRworkOutboundOrder.ProductVersion)
                        .Sum(x => x.StockPcsQty - x.OutboundQuantity);
                    if (useableStockQuantity < needQuantity)
                    {
                        stockInfo.proStockInfoDetails.ForEach(x => x.OutboundQuantity = x.StockPcsQty);
                        needQuantity -= useableStockQuantity;
                    }
                    else
                    {
                        stockInfo.proStockInfoDetails.ForEach(x =>
                        {
                            if ((x.StockPcsQty > x.OutboundQuantity) && x.SaleOrder == mesRworkOutboundOrder.SaleOrder && x.ProductCode == mesRworkOutboundOrder.ProductCode && x.ProductVersion == mesRworkOutboundOrder.ProductVersion)
                            {
                                if (x.StockPcsQty - x.OutboundQuantity >= needQuantity)
                                {
                                    x.OutboundQuantity += needQuantity;
                                    needQuantity = 0;
                                }
                                else
                                {
                                    needQuantity -= (x.StockPcsQty - x.OutboundQuantity);
                                    x.OutboundQuantity = x.StockPcsQty;
                                }
                            }
                        });
                    }
                    assignOutStocks.Add(stockInfo);
                    index++;
                }
            }
            else
            {
                for (int i = 0; i < stockInfos.Count; i++)
                {
                    Dt_ProStockInfo stockInfo = stockInfos[i];
                    float useableStockQuantity = stockInfo.proStockInfoDetails
                        .Where(x => x.SaleOrder == mesRworkOutboundOrder.SaleOrder && x.ProductCode == mesRworkOutboundOrder.ProductCode && x.ProductVersion == mesRworkOutboundOrder.ProductVersion)
                        .Sum(x => x.StockPcsQty - x.OutboundQuantity);
                    if (useableStockQuantity < needQuantity)
                    {
                        stockInfo.proStockInfoDetails.ForEach(x => x.OutboundQuantity = x.StockPcsQty);
                        needQuantity -= useableStockQuantity;
                    }
                    else
                    {
                        stockInfo.proStockInfoDetails.ForEach(x =>
                        {
                            if (x.StockPcsQty > x.OutboundQuantity && x.SaleOrder == mesRworkOutboundOrder.SaleOrder && x.ProductCode == mesRworkOutboundOrder.ProductCode && x.ProductVersion == mesRworkOutboundOrder.ProductVersion)
                            {
                                if (x.StockPcsQty - x.OutboundQuantity >= needQuantity)
                                {
                                    x.OutboundQuantity += needQuantity;
                                    needQuantity = 0;
                                }
                                else
                                {
                                    needQuantity -= (x.StockPcsQty - x.OutboundQuantity);
                                    x.OutboundQuantity = x.StockPcsQty;
                                }
                            }
                        });
                    }
                    assignOutStocks.Add(stockInfo);
                }
            }
            residueQuantity = needQuantity;
            return assignOutStocks;
        }
        ////处理出库库存
        //public (List<Dt_ProStockInfoDetail>?, List<Dt_ProStockInfoDetail>?) HandleOutProStock(Dt_ProStockInfo proStockInfo)
        //{
        //    List<Dt_ProStockInfoDetail>? deleteStockDetails = null;
        //    List<Dt_ProStockInfoDetail>? updateStockDetails = null;
        //    foreach (var item in proStockInfo.proStockInfoDetails)
        //    {
        //        if (item.StockPcsQty==item.OutboundQuantity)
        //        {
        //            item.ProOutDetailStatus = StockStatusEmun.出库完成.ObjToInt();
        //            deleteStockDetails.Add(item);
        //        }
        //        else if(item.StockPcsQty> item.OutboundQuantity && item.OutboundQuantity>0)
        //        {
        //            item.StockPcsQty-=item.OutboundQuantity;
        //            updateStockDetails.Add(item);
        //        }
        //    }
        //    return (deleteStockDetails, updateStockDetails);
        //}
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/MesTaskService.cs

@@ -295,46 +295,6 @@
            return content;
        }
        /// <summary>
        /// WMS同步成品出库至MES
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public WebResponseContent ShipmentOrderSync(MesShipmentOrderSync model)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo apiInfo = _apiInfoRepository.QueryFirst(x => x.ApiCode == APIEnum.WMS_MES_ShipmentOrderSync.ToString());
                MESRoot<MesShipmentOrderSync> root = new MESRoot<MesShipmentOrderSync>()
                {
                    From = "WMS",
                    DateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    Content = model
                };
                JsonSerializerSettings settings = new JsonSerializerSettings
                {
                    ContractResolver = new CamelCasePropertyNamesContractResolver()
                };
                string request = JsonConvert.SerializeObject(root, settings);
                string response = HttpMesHelper.Post(apiInfo.ApiAddress, request);
                MesResponseContent mesResponseContent = response.DeserializeObject<MesResponseContent>();
                //调用接口
                if (mesResponseContent.BSucc == true)
                {
                    content.OK(mesResponseContent.StrMsg);
                }
                else
                {
                    content.Error(mesResponseContent.StrMsg);
                }
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="stockInfo"></param>
@@ -498,6 +458,7 @@

                Dt_StockInfoDetail stockInfoDetail = new Dt_StockInfoDetail()
                {
                    MaterielSpec = stockInfoDetail_Hty.MaterielSpec,
                    BatchNo = stockInfoDetail_Hty?.BatchNo ?? "",
                    EffectiveDate = model.ExpirationDate,
                    MaterielCode = model.MaterialCode,
@@ -1072,12 +1033,25 @@
            try
            {
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == WarehouseEnum.HA101.ToString());
                //判断MES传入的出库单号是否存在
                Dt_ProOutOrder proOutOrder = _outboundRepository.ProOutOrderRepository.Db.Queryable<Dt_ProOutOrder>().Where(x=>x.ProOutOrderNo== boxInfoModel.ShipmentOrder).Includes(x=>x.Details).First();
                if (proOutOrder==null)
                {
                    return content.Error($"单号{boxInfoModel.ShipmentOrder}不存在");
                }
                //获取所有成品出库内包信息
                List<Dt_ProStockInfoDetail> dt_ProStockInfos = _stockRepository.ProStockInfoDetailRepository.QueryData(x=>x.ProOutDetailStatus==StockStatusEmun.出库完成.ObjToInt());
                //获取MES内包信息
                List<Dt_MesProInOrderDetail> mesProInOrderDetails = new List<Dt_MesProInOrderDetail>();
                foreach (var item in boxInfoModel.Bags)
                {
                    foreach (var child in item.BagItems)
                    {
                        Dt_ProStockInfoDetail? proStockInfoDetail = dt_ProStockInfos.Where(x=>x.BagNo==item.BagNo)?.FirstOrDefault();
                        if (proStockInfoDetail==null)
                        {
                            return content.Error($"内包{item.BagNo}货物状态异常");
                        }
                        Dt_MesProInOrderDetail mesProInOrderDetail = new Dt_MesProInOrderDetail()
                        {
                            BagNo = item.BagNo,
@@ -1103,16 +1077,27 @@
                {
                    proStockInfoDetails.Add(_mapper.Map<Dt_ProStockInfoDetail>(item));
                }
                proStockInfoDetails.ForEach(x =>
                {
                    x.ProOutDetailStatus = StockStatusEmun.平库入库完成.ObjToInt();
                });
                
                Dt_ProStockInfo proStockInfo = new Dt_ProStockInfo()
                {
                    PalletCode = boxInfoModel.BoxNo,
                    PalletType = 0,
                    WarehouseId = warehouse.WarehouseId,
                    ShipmentOrder = boxInfoModel.ShipmentOrder,
                    StockStatus = StockStatusEmun.入库完成.ObjToInt(),
                    StockStatus = StockStatusEmun.平库入库完成.ObjToInt(),
                    proStockInfoDetails = proStockInfoDetails
                };
                _unitOfWorkManage.BeginTran();
                //根据外包信息解绑内包与胶框库存关系
                WebResponseContent UnBindContent = _stockService.ProStockInfoService.UnBindStock(proStockInfoDetails);
                if (!UnBindContent.Status)
                {
                    throw new Exception(UnBindContent.Message);
                }
                Db.InsertNav(proStockInfo).Include(x => x.proStockInfoDetails).ExecuteCommand();
                _unitOfWorkManage.CommitTran();
                return content.OK("外包接收成功");
@@ -1123,50 +1108,6 @@
            }
            return content;
        }
        /// <summary>
        /// æˆå“è¿”工提库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public MesResponseContent RworkTask(RworkTaskModel model)
        {
            MesResponseContent content = new MesResponseContent();
            try
            {
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == WarehouseEnum.HA72.ToString());
                if (warehouse==null)
                {
                    return MesResponseContent.Instance.Error("未找到此仓库");
                }
                Dt_MesRworkOutboundOrder mesRworkOutboundOrder = new Dt_MesRworkOutboundOrder()
                {
                    WarehouseId=warehouse.WarehouseId,
                    TaskNo=model.TaskNo,
                    OrderStatus = InOrderStatusEnum.未开始.ObjToInt(),
                    CreateType = OrderCreateTypeEnum.UpperSystemPush.ObjToInt(),
                    ProductCode=model.ProductCode,
                    ProductName=model.ProductName,
                    ProductVersion=model.ProductVersion,
                    DateCode=model.DateCode,
                    RequiredQuantity=model.RequiredQuantity,
                    FactoryCode= model.FactoryCode,
                    SaleOrder=model.SaleOrder,
                    InventoryType=model.InventoryType,
                };
                _unitOfWorkManage.BeginTran();
                _outboundService.RworkOutboundOrderService.AddData(mesRworkOutboundOrder);
                _unitOfWorkManage.CommitTran();
                return content.OK("提供返库单接收成功");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                content.Error(ex.Message);
            }
            return content;
        }




        /// <summary>
@@ -1660,5 +1601,207 @@
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        /// <summary>
        /// MES成品出库单同步数据处理
        /// </summary>
        public MesShipmentOrderSync MesOutSync(Dt_OutProStockInfo outProStockInfo, Dt_ProOutOrderDetail proOutOrderDetail)
        {
            List<MesShipOrderDetail> mesShipOrderDetails = new List<MesShipOrderDetail>();
            //获取出库单
            Dt_ProOutOrder proOutOrder = _outboundService.ProOutOrderService.Repository.QueryFirst(x=>x.Id== proOutOrderDetail.ProOrderId);
            //获取客户
            Dt_CustomerInfo customerInfo = _basicRepository.CustomerInfoRepository.QueryFirst(x=>x.Code==proOutOrderDetail.Customer);
            
            MesShipOrderDetail orderDetail = new MesShipOrderDetail()
            {
                ProductCode = proOutOrderDetail.PCode,
                ProductVersion = proOutOrderDetail.PVer,
                Qty = outProStockInfo.AssignQuantity,
                SaleOrder = proOutOrderDetail.SaleOrder,
                Sequence = outProStockInfo.Id,
                WorkCenter = "SPCK_OUTER-001"
            };
            mesShipOrderDetails.Add(orderDetail);
            MesShipmentOrderSync shipmentOrderSync = new MesShipmentOrderSync()
            {
                ShipmentOrder = proOutOrder.ProOutOrderNo,
                PlantShipDate = proOutOrder.PlantShipDate.ToString("yyyy-MM-dd HH:mm:ss"),
                Customer = proOutOrderDetail.Customer,
                FactoryCode = proOutOrderDetail.FactoryCode,
                ShipName = customerInfo.Name,
                ShippingAddress = customerInfo.NickName,
                OrderDetails = mesShipOrderDetails
            };
            return shipmentOrderSync;
        }
        /// <summary>
        /// WMS同步成品出库至MES
        /// </summary>
        public WebResponseContent ShipmentOrderSync(MesShipmentOrderSync model)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo apiInfo = _apiInfoRepository.QueryFirst(x => x.ApiCode == APIEnum.WMS_MES_ShipmentOrderSync.ToString());
                MESRoot<MesShipmentOrderSync> root = new MESRoot<MesShipmentOrderSync>()
                {
                    From = "WMS",
                    DateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    Content = model
                };
                JsonSerializerSettings settings = new JsonSerializerSettings
                {
                    ContractResolver = new CamelCasePropertyNamesContractResolver()
                };
                string request = JsonConvert.SerializeObject(root, settings);
                string response = HttpMesHelper.Post(apiInfo.ApiAddress, request);
                MesResponseContent mesResponseContent = response.DeserializeObject<MesResponseContent>();
                //调用接口
                if (mesResponseContent.BSucc == true)
                {
                    content.OK(mesResponseContent.StrMsg);
                }
                else
                {
                    content.Error(mesResponseContent.StrMsg);
                }
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }

        /// <summary>
        /// MES成品返工提库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public MesResponseContent RworkTask(RworkTaskModel model)
        {
            MesResponseContent content = new MesResponseContent();
            try
            {
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == WarehouseEnum.HA72.ToString());
                if (warehouse == null)
                {
                    return content.Error($"尾数仓信息未配置");
                }
                Dt_MesRworkOutboundOrder rworkOutboundOrderOld = _outboundRepository.RworkOutboundOrderRepository.QueryFirst(x=>x.TaskNo== model.TaskNo);
                if (rworkOutboundOrderOld==null)
                {
                    return content.Error($"提库任务单{model.TaskNo}已存在");
                }
                Dt_MesRworkOutboundOrder mesRworkOutboundOrder = new Dt_MesRworkOutboundOrder()
                {
                    WarehouseId = warehouse.WarehouseId,
                    TaskNo = model.TaskNo,
                    OrderStatus = OutOrderStatusEnum.未开始.ObjToInt(),
                    CreateType = OrderCreateTypeEnum.UpperSystemPush.ObjToInt(),
                    ProductCode = model.ProductCode,
                    ProductName = model.ProductName,
                    ProductVersion = model.ProductVersion,
                    DateCode = model.DateCode,
                    RequiredQuantity = model.RequiredQuantity,
                    FactoryCode = model.FactoryCode,
                    SaleOrder = model.SaleOrder,
                    OrderType = model.InventoryType,
                };
                List<Dt_Task> tasks = new List<Dt_Task>();
                List<Dt_ProStockInfo>? proStockInfos = null;
                List<Dt_OutProStockInfo>? outProStockInfos = null;
                List<Dt_LocationInfo>? locationInfos = null;
                //分配库存生成提库任务
                (List<Dt_ProStockInfo>?, Dt_MesRworkOutboundOrder?, List<Dt_OutProStockInfo>?, List<Dt_LocationInfo>) result = _outboundService.RworkOutboundOrderService.AssignMesStocks(mesRworkOutboundOrder);
                if (result.Item1!=null && result.Item1.Count>0)
                {
                    tasks = GetTasks(result.Item1, TaskTypeEnum.MesOutbound);
                    result.Item2.OrderStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
                    result.Item3.ForEach(x =>
                    {
                        x.Status = OutLockStockStatusEnum.出库中.ObjToInt();
                    });

                    proStockInfos = result.Item1;
                    mesRworkOutboundOrder = result.Item2;
                    outProStockInfos = result.Item3;
                    locationInfos = result.Item4;
                }
                else
                {
                    throw new Exception("无库存分配");
                }
                tasks.ForEach(x =>
                {
                    x.TargetAddress = "5236";
                    x.OrderNo = mesRworkOutboundOrder.TaskNo;
                });
                _unitOfWorkManage.BeginTran();

                int id = BaseDal.AddData(tasks);
                outProStockInfos.ForEach(x =>
                {
                    x.OrderNo = mesRworkOutboundOrder.TaskNo;
                    x.OrderDetailId = id;
                });
                if (proStockInfos != null && proStockInfos.Count > 0 && outProStockInfos != null && outProStockInfos.Count > 0 && locationInfos != null && locationInfos.Count > 0)
                {
                    WebResponseContent updateContent = _outboundService.RworkOutboundOrderService.LockOutboundStockDataUpdate(proStockInfos, outProStockInfos, locationInfos, tasks: tasks);

                    if (!updateContent.Status)
                    {
                        _unitOfWorkManage.RollbackTran();
                        return content.Error(updateContent.Message);
                    }
                }
                _outboundService.RworkOutboundOrderService.Repository.AddData(mesRworkOutboundOrder);
                return content.OK("提供返库单接收成功");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// åº“存板同步接口
        /// </summary>
        public WebResponseContent ProductOutBoundSync(MesProductOutBound model)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo apiInfo = _apiInfoRepository.QueryFirst(x => x.ApiCode == APIEnum.WMS_MES_ProductOutBound.ToString());
                MESRoot<MesProductOutBound> root = new MESRoot<MesProductOutBound>()
                {
                    From = "WMS",
                    DateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    Content = model
                };
                JsonSerializerSettings settings = new JsonSerializerSettings
                {
                    ContractResolver = new CamelCasePropertyNamesContractResolver()
                };
                string request = JsonConvert.SerializeObject(root, settings);
                string response = HttpMesHelper.Post(apiInfo.ApiAddress, request);
                MesResponseContent mesResponseContent = response.DeserializeObject<MesResponseContent>();
                //调用接口
                if (mesResponseContent.BSucc == true)
                {
                    content.OK(mesResponseContent.StrMsg);
                }
                else
                {
                    content.Error(mesResponseContent.StrMsg);
                }
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -50,6 +50,7 @@
using WIDESEA_ITaskInfoRepository;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;
using WIDESEA_OutboundRepository;
using WIDESEA_TaskInfoRepository;

namespace WIDESEA_TaskInfoService
@@ -69,7 +70,8 @@
        private readonly IInboundRepository _inboundRepository;
        private readonly IInboundOrderService _inboundOrderService;
        private readonly IPalletTypeInfoRepository _palletTypeInfoRepository;

        private readonly IOutProStockInfoRepository _outProStockInfoRepository;
        private readonly IOutboundRepository _outboundRepository;
        public ITaskRepository Repository => BaseDal;

        private Dictionary<string, OrderByType> _taskOrderBy = new()
@@ -82,7 +84,7 @@

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

        public TaskService(ITaskRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IStockRepository stockRepository, IBasicService basicService, IRecordService recordService, IOutboundService outboundService, IStockService stockService, IBasicRepository basicRepository, IApiInfoRepository apiInfoRepository, IInvokeERPService invokeERPService, IInboundRepository inboundRepository, IInboundOrderService inboundOrderService, IPalletTypeInfoRepository palletTypeInfoRepository) : base(BaseDal)
        public TaskService(ITaskRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IStockRepository stockRepository, IBasicService basicService, IRecordService recordService, IOutboundService outboundService, IStockService stockService, IBasicRepository basicRepository, IApiInfoRepository apiInfoRepository, IInvokeERPService invokeERPService, IInboundRepository inboundRepository, IInboundOrderService inboundOrderService, IPalletTypeInfoRepository palletTypeInfoRepository, IOutProStockInfoRepository outProStockInfoRepository, IOutboundRepository outboundRepository) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
@@ -97,6 +99,8 @@
            _inboundRepository = inboundRepository;
            _inboundOrderService = inboundOrderService;
            _palletTypeInfoRepository = palletTypeInfoRepository;
            _outProStockInfoRepository = outProStockInfoRepository;
            _outboundRepository = outboundRepository;
        }

        /// <summary>
@@ -403,7 +407,7 @@
            }
        }
        /// <summary>
        /// æˆå“ä»“任务完成
        /// æˆå“ä»“入库任务完成
        /// </summary>
        public WebResponseContent InProductCompleted(Dt_Task task)
        {
@@ -480,7 +484,12 @@
                {
                    return WebResponseContent.Instance.Error($"未找到任务信息");
                }

                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseId == task.WarehouseId);
                //成品出库任务完成
                if (warehouse.WarehouseCode==WarehouseEnum.HA71.ToString())
                {
                    return OutProCompleted(task);
                }
                Dt_StockInfo stockInfo = _stockService.StockInfoService.Repository.GetStockInfo(task.PalletCode);

                Dt_LocationInfo locationInfo = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.SourceAddress);
@@ -492,7 +501,6 @@
                {
                    return WebResponseContent.Instance.Error($"未找到货位信息");
                }
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseId == task.WarehouseId);
                List<Dt_OutStockLockInfo> outStockLockInfos = _outboundService.OutboundStockLockInfoService.Repository.QueryData(x => x.TaskNum == taskNum);
                List<Dt_OutboundOrderDetail> outboundOrderDetails = new List<Dt_OutboundOrderDetail>();
                List<Dt_MesOutboundOrder> mesOutboundOrders = new List<Dt_MesOutboundOrder>();
@@ -611,6 +619,109 @@
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        //成品出库任务完成
        public WebResponseContent OutProCompleted(Dt_Task task)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                //获取货位
                Dt_LocationInfo locationInfo = _basicRepository.LocationInfoRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
                if (locationInfo==null)
                {
                    return content.Error("未找到货位信息");
                }
                //根据任务获取成品出库详情任务及物料信息
                Dt_OutProStockInfo outProStockInfo = _outProStockInfoRepository.QueryFirst(x=>x.TaskNum==task.TaskNum);
                if (outProStockInfo == null)
                {
                    return content.Error("未找到成品出库详情");
                }
                //获取成品出库订单
                Dt_ProOutOrder proOutOrder = _outboundService.ProOutOrderService.Repository.Db.Queryable<Dt_ProOutOrder>().Where(x => x.ProOutOrderNo == outProStockInfo.OrderNo).Includes(x => x.Details).First();
                if (proOutOrder==null)
                {
                    return content.Error("未找到成品出库订单");
                }
                //获取成品库存
                Dt_ProStockInfo proStockInfo = _stockRepository.ProStockInfoRepository.Db.Queryable<Dt_ProStockInfo>().Where(x=>x.PalletCode==task.PalletCode).Includes(x=>x.proStockInfoDetails).First();
                if (proStockInfo==null)
                {
                    return content.Error("未找到成品库存信息");
                }
                List<Dt_ProStockInfoDetail> proStockInfoDetails = proStockInfo.proStockInfoDetails;
                if (proStockInfoDetails.Count<=0)
                {
                    return content.Error("成品库存明细");
                }
                proStockInfoDetails.ForEach(x =>
                {
                    x.OutboundQuantity = 0;
                    x.ProOutDetailStatus = StockStatusEmun.出库完成.ObjToInt();
                });
                //处理库存数据
                //List<Dt_ProStockInfoDetail>? deleteStockDetails = null;
                //List<Dt_ProStockInfoDetail>? updateStockDetails = null;
                //(List<Dt_ProStockInfoDetail>?, List<Dt_ProStockInfoDetail>?) result = _stockService.ProStockInfoService.HandleOutProStock(proStockInfo);
                //if (result.Item1!=null && result.Item1.Count>0)
                //{
                //    deleteStockDetails.AddRange(result.Item1);
                //}
                //if (result.Item1 != null && result.Item1.Count > 0)
                //{
                //    updateStockDetails.AddRange(updateStockDetails);
                //}
                //获取成品出库单明细
                Dt_ProOutOrderDetail? proOutOrderDetail = proOutOrder.Details.FirstOrDefault(x=>x.Id== outProStockInfo.OrderDetailId);
                if (proOutOrderDetail==null)
                {
                    return content.Error("未找到对应任务成品订单明细");
                }
                //if (deleteStockDetails?.Sum(x=>x.StockPcsQty)== proStockInfo.proStockInfoDetails.Sum(x=>x.StockPcsQty))
                //{
                proStockInfo.StockStatus = StockStatusEmun.出库完成.ObjToInt();
                proStockInfo.LocationCode = "出至成品待发货区";
                //}
                task.TaskStatus = TaskStatusEnum.Finish.ObjToInt();
                outProStockInfo.Status = OutLockStockStatusEnum.出库完成.ObjToInt();
                _unitOfWorkManage.BeginTran();
                //货位变动记录
                int beforeStatus = locationInfo.LocationStatus;
                locationInfo.LocationStatus = LocationStatusEnum.Free.ObjToInt();
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, proStockInfo.PalletType, LocationStatusEnum.Free, proStockInfo.WarehouseId);
                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, (LocationStatusEnum)beforeStatus, LocationStatusEnum.Free, LocationChangeType.OutboundCompleted, proOutOrder?.ProOutOrderNo ?? "", task.TaskNum);
                if (proOutOrder.ProOrderStatus == OutOrderStatusEnum.未开始.ObjToInt())
                {
                    proOutOrder.ProOrderStatus = OutOrderStatusEnum.出库中.ObjToInt();
                    _outboundService.ProOutOrderService.UpdateData(proOutOrder);
                }

                //if (deleteStockDetails!=null && deleteStockDetails.Count>0)
                //{
                //    _stockRepository.ProStockInfoDetailRepository.DeleteAndMoveIntoHty(deleteStockDetails, OperateTypeEnum.自动完成);
                //}
                //if (updateStockDetails!=null && updateStockDetails.Count>0)
                //{
                _stockRepository.ProStockInfoRepository.UpdateData(proStockInfo);
                _stockRepository.ProStockInfoDetailRepository.UpdateData(proStockInfoDetails);
                _outProStockInfoRepository.UpdateData(outProStockInfo);
                //}
                //else
                //{
                //_stockRepository.ProStockInfoRepository.DeleteAndMoveIntoHty(proStockInfo, OperateTypeEnum.自动完成);
                //}
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                _unitOfWorkManage.CommitTran();
                //MES成品出库同步
                ShipmentOrderSync(MesOutSync(outProStockInfo, proOutOrderDetail));
                content.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                content.Error(ex.Message);
            }
            return content;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService_Outbound.cs

@@ -18,6 +18,7 @@
using MailKit.Search;
using WIDESEA_External.Model;
using WIDESEA_Core.CodeConfigEnum;
using Microsoft.AspNetCore.Mvc;

namespace WIDESEA_TaskInfoService
{
@@ -81,16 +82,16 @@
        /// <param name="ProOutNo">出库订单号</param>
        /// <param name="StationCode">站台地址</param>
        /// <returns></returns>
        public WebResponseContent OutProductTask(string ProOutNo, string StationCode)
        public WebResponseContent OutProductTask(int[] keys, string StationCode)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                //获取成品出库订单
                Dt_ProOutOrder proOutOrder = _outboundService.ProOutOrderService.Repository.Db.Queryable<Dt_ProOutOrder>().Where(x => x.ProOutOrderNo == ProOutNo).Includes(x => x.Details).First();
                if (proOutOrder==null)
                List<Dt_ProOutOrderDetail> _ProOutOrderDetails = _outboundRepository.ProOutOrderDetailRepository.QueryData(x => keys.Contains(x.Id));
                if (_ProOutOrderDetails.Count<=0)
                {
                    return content.Error("出库订单不存在");
                    return content.Error("勾选订单明细不存在");
                }
                List<Dt_Task> tasks = new List<Dt_Task>();
                List<StockSelectViewDTO> stockSelectViews = new List<StockSelectViewDTO>();
@@ -99,7 +100,7 @@
                List<Dt_OutProStockInfo> outProStockInfos = new List<Dt_OutProStockInfo>();
                List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
                (List<Dt_Task>, List<Dt_ProStockInfo>?, List<Dt_ProOutOrderDetail>?, List<Dt_OutProStockInfo>?, List<Dt_LocationInfo>?) result =
                OutProductTaskDataHandle(proOutOrder);
                OutProductTaskDataHandle(_ProOutOrderDetails);
                if (result.Item2 != null && result.Item2.Count > 0)
                {
                    proStockInfos.AddRange(result.Item2);
@@ -180,17 +181,23 @@
        /// å¤„理成品出库数据
        /// </summary>
        /// <returns></returns>
        public (List<Dt_Task>, List<Dt_ProStockInfo>?, List<Dt_ProOutOrderDetail>?, List<Dt_OutProStockInfo>?, List<Dt_LocationInfo>?) OutProductTaskDataHandle(Dt_ProOutOrder proOutOrder)
        public (List<Dt_Task>, List<Dt_ProStockInfo>?, List<Dt_ProOutOrderDetail>?, List<Dt_OutProStockInfo>?, List<Dt_LocationInfo>?) OutProductTaskDataHandle(List<Dt_ProOutOrderDetail> proOutOrderDetails)
        {
            List<Dt_Task> tasks = new List<Dt_Task>();
            List<Dt_ProStockInfo> proStockInfos = new List<Dt_ProStockInfo>();
            List<Dt_ProOutOrderDetail> proOutOrderDetails = new List<Dt_ProOutOrderDetail>();
            List<Dt_ProOutOrderDetail> assignOutOrderDetails = new List<Dt_ProOutOrderDetail>();
            List<Dt_OutProStockInfo> outProStockInfos=new List<Dt_OutProStockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
            //分配库存
            (List<Dt_ProStockInfo>, List<Dt_ProOutOrderDetail>, List<Dt_OutProStockInfo>, List<Dt_LocationInfo>) result = _outboundService.ProOutOrderDetailService.AssignProStockOut(proOutOrder.WarehouseId, proOutOrder);
            (List<Dt_ProStockInfo>, List<Dt_ProOutOrderDetail>, List<Dt_OutProStockInfo>, List<Dt_LocationInfo>) result = _outboundService.ProOutOrderDetailService.AssignProStockOut(proOutOrderDetails);
            if (result.Item1!=null&&result.Item1.Count>0)
            {
                //获取成品单
                Dt_ProOutOrder proOutOrder = _outboundRepository.ProOutOrderRepository.QueryFirst(x => x.Id == proOutOrderDetails.FirstOrDefault().ProOrderId);
                if (proOutOrder==null)
                {
                    throw new Exception("未找到成品订单");
                }
                TaskTypeEnum typeEnum = proOutOrder.ProOrderType switch
                {
                    (int)OutProTypeEnum.ProOut => TaskTypeEnum.OutProduct,

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/ERP/ErpController.cs

@@ -125,7 +125,7 @@
            else return Instance.Error(content.Message);
        }
        /// <summary>
        /// æŽ¥æ”¶ERP成品出库单信息
        /// æŽ¥æ”¶ERP成品出库单信息(订单出库/寄售出库)
        /// </summary>
        /// <returns></returns>
        [HttpPost, Route("ProductDeliveryOrder"), AllowAnonymous, MethodParamsValidate]
@@ -134,6 +134,54 @@
            WebResponseContent content = _outboundService.ProOutOrderService.ProductDeliveryOrder(erpProOutOrder.Content);
            if (content.Status) return Instance.OK();
            else return Instance.Error(content.Message);
        }
        /// <summary>
        /// æˆå“å¯„售转入/调拨入库
        /// </summary>
        /// <param name="root"></param>
        /// <returns></returns>
        [HttpPost, Route("ProductWarehousingOrder"), AllowAnonymous, MethodParamsValidate]
        public ErpResponseContent ProductWarehousingOrder([FromBody] Root<ErpProductWarehousingOrderDTO> root)
        {
            return Instance.OK();
        }
        /// <summary>
        /// æˆå“è°ƒæ‹¨å‡ºï¼ˆç ”发）
        /// </summary>
        /// <param name="root"></param>
        /// <returns></returns>
        [HttpPost, Route("ProductTransferOrder"), AllowAnonymous, MethodParamsValidate]
        public ErpResponseContent ProductTransferOrder([FromBody] Root<ErpProductTransferOrder> root)
        {
            return Instance.OK();
        }
        /// <summary>
        /// æˆå“æŠ¥åºŸå‡ºåº“单接收
        /// </summary>
        /// <param name="root"></param>
        /// <returns></returns>
        [HttpPost, Route("ProductScrappedOrder"), AllowAnonymous, MethodParamsValidate]
        public ErpResponseContent ProductScrappedOrder([FromBody] Root<ErpProductScrappedOrderDTO> root)
        {
            return Instance.OK();
        }
        /// <summary>
        /// æˆå“é¢†æ–™å‡ºåº“单接收
        /// </summary>
        /// <param name="root"></param>
        /// <returns></returns>
        [HttpPost, Route("ProductOutOrder"), AllowAnonymous, MethodParamsValidate]
        public ErpResponseContent ProductOutOrder([FromBody] Root<ErpProOutLingOrder> root)
        {
            return Instance.OK();
        }
        /// <summary>
        /// é”€å”®æŒ‡æ´¾å•æŽ¥æ”¶
        /// </summary>
        [HttpPost, Route("ProductSpecifyVer"), AllowAnonymous, MethodParamsValidate]
        public ErpResponseContent ProductSpecifyVer([FromBody] Root<ErpProductSpecifyVerDTO> root)
        {
            return Instance.OK();
        }
        /// <summary>
        /// æŽ¥æ”¶ERP退料单信息
@@ -216,5 +264,35 @@
        {
            return _invokeERPService.InvokeProOutApi(outOrderModel);
        }
        /// <summary>
        /// æˆå“ä»“检报废出库推送ERP
        /// </summary>
        /// <param name="checkModel"></param>
        /// <returns></returns>
        [HttpPost, Route("InvokeProCheckApi"), AllowAnonymous]
        public string InvokeProCheckApi([FromBody] ERPProductCheckModel checkModel)
        {
            return _invokeERPService.InvokeProCheckApi(checkModel);
        }
        /// <summary>
        /// æˆå“è¶…周期报废推送ERp
        /// </summary>
        /// <param name="sheetModel"></param>
        /// <returns></returns>
        [HttpPost, Route("InvokeProScrapSheetApi"), AllowAnonymous]
        public string InvokeProScrapSheetApi([FromBody] ERPScrapSheetModel sheetModel)
        {
            return _invokeERPService.InvokeProScrapSheetApi(sheetModel);
        }
        /// <summary>
        /// æˆå“ç›˜ç‚¹ç›˜èµ¢/盘亏
        /// </summary>
        /// <param name="stockCheckModel"></param>
        /// <returns></returns>
        [HttpPost, Route("InvokeProStockCheckApi"), AllowAnonymous]
        public string InvokeProStockCheckApi([FromBody] ERPProStockCheckModel stockCheckModel)
        {
            return _invokeERPService.InvokeProStockCheckApi(stockCheckModel);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/MES/MesController.cs

@@ -186,9 +186,19 @@
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost,Route("RworkTask"),AllowAnonymous]
        public MesResponseContent RworkTask([FromBody] RworkTaskModel model)
        public MesResponseContent RworkTask([FromBody] Root<RworkTaskModel> model)
        {
            return _taskService.RworkTask(model);
            return _taskService.RworkTask(model.Content);
        }
        /// <summary>
        /// åº“存板出库同步接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost, Route("ProductOutBoundSync"), AllowAnonymous]
        public WebResponseContent ProductOutBoundSync([FromBody] MesProductOutBound model)
        {
            return _taskService.ProductOutBoundSync(model);
        }
        /// <summary>
        /// ç”ŸæˆMESPP仓大卷出库任务

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Outbound/ProOutOrderController.cs

@@ -1,4 +1,6 @@
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using WIDESEA_Core;
using WIDESEA_Core.BaseController;
using WIDESEA_IOutboundService;
using WIDESEA_Model.Models;
@@ -15,5 +17,14 @@
        public ProOutOrderController(IProOutOrderService service) : base(service)
        {
        }
        /// <summary>
        /// æˆå“å‡ºå¾…发货区(平库)+同步ERP出库
        /// </summary>
        /// <returns></returns>
        [HttpPost, Route("OutProductPK"), AllowAnonymous]
        public WebResponseContent OutProductPK([FromBody] string[] OutPKCodes, string ProOutNo)
        {
            return Service.OutProductPK(OutPKCodes, ProOutNo);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/TaskInfo/TaskController.cs

@@ -183,9 +183,18 @@
        /// <param name="StationCode">站台地址</param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("OutProductTask"), AllowAnonymous]
        public WebResponseContent OutProductTask(string ProOutNo, string StationCode)
        public WebResponseContent OutProductTask([FromBody] int[] keys, string StationCode)
        {
            return Service.OutProductTask(ProOutNo, StationCode);
            return Service.OutProductTask(keys, StationCode);
        }

        /// <summary>
        /// ç”Ÿæˆæˆå“æåº“任务
        /// </summary>
        [HttpPost, HttpGet, Route("OutProRworkTask"), AllowAnonymous]
        public WebResponseContent OutProRworkTask([FromBody] int[] keys, string StationCode)
        {
            return Service.OutProductTask(keys, StationCode);
        }
        ///// <summary>
        ///// ç”ŸæˆMESPP仓大卷出库任务