using DevComponents.DotNetBar.Controls;
using HH.WMS.Entitys;
using HH.WMS.Client.bll;
using HH.WMS.Client.Common;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using HH.WMS.Entitys.Entitys;
using DevComponents.DotNetBar;
using Newtonsoft.Json.Linq;
using HH.WMS.Common;
using HH.WMS.Entitys.Basic;
using HH.WMS.Client.CustomControl;

namespace HH.WMS.Client.frm
{
    public partial class frmUpShelves : frmTemplet
    {
        /// <summary>
        /// 当前物料PAK码
        /// </summary>
        private string currentPak;
        /// <summary>
        /// 已扫唯一码(判断是否重复扫描)
        /// </summary>
        private List<string> haveAlreadyScan = new List<string>();
        /// <summary>
        /// 当前容器实体
        /// </summary>
        private TN_WM_B_TRAY_INFOEntity trayInfoModel = new TN_WM_B_TRAY_INFOEntity();
        /// <summary>
        /// 当前容器内原有物料实体
        /// </summary>
        private List<TN_WM_B_TRAY_ITEM_MSTEntity> originalTrayItemList = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
        /// <summary>
        /// 当前扫描物料实体
        /// </summary>
        private AutoBomItemEntity itemTempModel = new AutoBomItemEntity();
        /// <summary>
        /// 物料缓存实体
        /// </summary>
        private List<AutoBomItemEntity> itemModelCacheList = new List<AutoBomItemEntity>();
        /// <summary>
        /// 是否允许混放
        /// </summary>
        private bool isAllowMixing = true;
        /// <summary>
        /// 物料混放上限
        /// </summary>
        private int limitQty = 0;
        /// <summary>
        /// 等待入容器的重量
        /// </summary>
        private decimal allAddInWeight = 0;
        #region 等待容器
        private List<string> _waitTray = new List<string>();
        /// <summary>
        /// 等待容器
        /// </summary>
        public List<string> WaitTray
        {
            get { return _waitTray; }
            set
            {
                _waitTray = value;
                lblWaitTray.Text = string.Join(",", _waitTray.ToArray());
                if (lblWaitTray.Text != "等待容器..........")
                {
                    lblWaitTray.ForeColor = Color.Red;
                }
            }
        }
        #endregion

        public CusTray tray = new CusTray(1, 1);
        /// <summary>
        /// 已扫描未处理的物料(码盘物料/移除物料)
        /// </summary>
        private List<TN_WM_B_TRAY_ITEM_MSTEntity> scanedWaitExecuteItems = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();

        public frmUpShelves()
        {
            InitializeComponent();

            this.ScanTrayEvent += frmUpShelves_ScanTrayEvent;
            this.ScanItemEvent += frmUpShelves_ScanItemEvent;
            this.ScanEnterEvent += frmUpShelves_ScanEnterEvent;
            this.ScanItemUniqueCodeEvent += frmUpShelves_ScanItemUniqueCodeEvent;
            this.dgvData.DataError += delegate (object sender, DataGridViewDataErrorEventArgs e) { };
            this.dgvThisUp.DataError += delegate (object sender, DataGridViewDataErrorEventArgs e) { };
            this.dgvWaitUp.DataError += delegate (object sender, DataGridViewDataErrorEventArgs e) { };
            this.KeyDown += frmTemplet_KeyDown;
            this.dgvData.AutoGenerateColumns = false;
            this.dgvThisUp.AutoGenerateColumns = false;
            this.dgvWaitUp.AutoGenerateColumns = false;
        }

        /// <summary>
        /// 扫描唯一码
        /// </summary>
        void frmUpShelves_ScanItemUniqueCodeEvent(object sender, frmTemplet.ScanItemUniqueCodeEventArgs e)
        {
            #region  是否重复扫码判断
            var scanCode = e.itemInfo.CN_S_UNIQUE_CODE;
            if (haveAlreadyScan != null && haveAlreadyScan.Contains(scanCode))
            {
                //该唯一码已被扫过，请勿重复扫码       ***********无法判断此编码是否已存在于原容器中
                MessageBoxEx.Show("该唯一码已被扫过，请勿重复扫码！");
                return;
            }
            #endregion

            if (lblItemTray.Text.Trim() == "_______________")
            {
                //判断待上架区是否存在物料
                List<TN_WM_B_TRAY_ITEM_MSTEntity> CheckWaitUpData = (List<TN_WM_B_TRAY_ITEM_MSTEntity>)dgvWaitUp.DataSource;
                if (CheckWaitUpData != null)
                {
                    //该物料不存在待上架的信息
                    MessageBoxEx.Show("待上架列表中已存在物料数据，请先指引！");
                    return;
                }
                //不存在容器码，指引物料
                //获取待上架的所有物料
                string str = WebApiManager.HttpWMS_Get("/api/Up/GetWaitUpShelvesItems?itemCode=" + e.itemInfo.CN_S_ITEM_CODE);
                OperateResult or = JsonConvert.DeserializeObject<OperateResult>(str);
                if (or.Status == ResultStatus.Success)
                {
                    List<TN_WM_B_TRAY_ITEM_MSTEntity> waitList = JsonConvert.DeserializeObject<List<TN_WM_B_TRAY_ITEM_MSTEntity>>(or.Data.ToString());
                    //绑定待上架的物料
                    if (waitList.Count > 0)
                    {
                        //dgvWaitUp.AutoGenerateColumns = false;
                        dgvWaitUp.DataSource = waitList;
                        btnEnter.Text = "确认指引";
                    }
                    else
                    {
                        //该物料不存在待上架的信息
                        MessageBoxEx.Show("暂存区未找到该物料待上架的信息！");
                        return;
                    }
                }
            }
            else
            {
                //存储类别、物料毛重、最大承受重量判断
                var endAreaCode = StaticUtil.WorkArea;

                //获取物料实体
                itemTempModel = GetItemEntity(e.itemInfo.CN_S_ITEM_CODE);


                if (itemTempModel == null)
                {
                    MessageBoxEx.Show("未获取到物料 " + e.itemInfo.CN_S_ITEM_CODE + " 的实体！");
                    return;
                }

                //当待上架区有物料时，需要用户扫描待上架物料，不准扫其他物料
                List<TN_WM_B_TRAY_ITEM_MSTEntity> CheckWaitUpData = (List<TN_WM_B_TRAY_ITEM_MSTEntity>)dgvWaitUp.DataSource;
                if (CheckWaitUpData.Count > 0)
                {
                    var hasWaitData = CheckWaitUpData.Where(x => x.CN_S_ITEM_CODE == itemTempModel.CN_S_ITEM_CODE).ToList();
                    if (hasWaitData.Count == 0)
                    {
                        MessageBoxEx.Show("请扫描待上架区物料！");
                        return;
                    }
                }

                if (itemTempModel.CN_S_STORE_TYPE != endAreaCode)
                {
                    MessageBoxEx.Show("物料存储类别与目的库区不符！");
                    return;
                }

                if (itemTempModel.CN_F_TW == 0)
                {
                    MessageBoxEx.Show("物料" + e.itemInfo.CN_S_ITEM_CODE + "没维护毛重！");
                    return;
                }

                var packNum = e.itemInfo.CN_F_PACKING_QTY;
                if (packNum * itemTempModel.CN_F_TW > trayInfoModel.CN_F_LOADBEARING)
                {
                    MessageBoxEx.Show("物料" + e.itemInfo.CN_S_ITEM_CODE + "已超出容器最大承受重量！");
                    return;
                }

                #region 物料混放上限判断
                if (trayInfoModel.CN_N_GOODUPLINE != 0)
                {
                    //原始容器物料个数汇总
                    var haveOld = originalTrayItemList.GroupBy(x => x.CN_S_ITEM_CODE).Select(g => new TN_WM_B_TRAY_ITEM_MSTEntity
                    {
                        CN_S_ITEM_CODE = g.FirstOrDefault().CN_S_ITEM_CODE.Trim()
                    }).ToList();

                    //刚扫物料集合内物料个数汇总
                    var haveNew = scanedWaitExecuteItems.GroupBy(x => x.CN_S_ITEM_CODE).Select(g => new TN_WM_B_TRAY_ITEM_MSTEntity
                    {
                        CN_S_ITEM_CODE = g.FirstOrDefault().CN_S_ITEM_CODE.Trim()
                    }).ToList();

                    haveOld.AddRange(haveNew);
                    var distinctEntity = haveOld.Distinct().ToList();
                    if (distinctEntity.Where(x => x.CN_S_ITEM_CODE == e.itemInfo.CN_S_ITEM_CODE).ToList().Count == 0)
                    {
                        if (distinctEntity.Count + 1 > trayInfoModel.CN_N_GOODUPLINE)
                        {
                            MessageBoxEx.Show("已超出物料混放上限 " + trayInfoModel.CN_N_GOODUPLINE + " ！");
                            return;
                        }
                    }
                }
                #endregion

                //存放规格判断
                OperateResult resultTrayInfo = new TrayBll().GetTrayCapacityInfo(e.itemInfo.CN_S_ITEM_CODE);
                if (resultTrayInfo.Success)
                {
                    TN_WM_B_TRAY_CAPACITYEntity itemCapacityModel = JsonConvert.DeserializeObject<TN_WM_B_TRAY_CAPACITYEntity>(resultTrayInfo.Data.ToString());
                    var trayGrid = trayInfoModel.CN_N_ROW_NUM * trayInfoModel.CN_N_COLUMN_NUM;
                    if (!(itemCapacityModel.CN_S_SPEC == trayInfoModel.CN_S_SPEC && (trayGrid != 1 ? itemCapacityModel.CN_S_STORE_UNIT == trayGrid.ToString() : true)))
                    {
                        MessageBoxEx.Show("物料" + e.itemInfo.CN_S_ITEM_CODE + "设置存放规格与当前容器规格不符！");
                        return;
                    }
                }

                int PutInGrid = DoPutItemInTray(e.itemInfo.CN_S_ITEM_CODE, e.itemInfo); //返回True或者False
                if (PutInGrid != 0)
                {
                    #region 表格联动
                    //如果待上架预分配有数据，那就是指引出来的容器补料上架
                    //联动待上架减物料
                    List<TN_WM_B_TRAY_ITEM_MSTEntity> waitUpData = (List<TN_WM_B_TRAY_ITEM_MSTEntity>)dgvWaitUp.DataSource;

                    if (waitUpData.Count > 0)
                    {
                        foreach (var item in waitUpData)
                        {
                            if (item.CN_S_ITEM_CODE == e.itemInfo.CN_S_ITEM_CODE)
                            {
                                item.CN_F_QUANTITY = item.CN_F_QUANTITY - e.itemInfo.CN_F_PACKING_QTY;
                            }
                        }
                        waitUpData = waitUpData.Where(x => x.CN_F_QUANTITY > 0).ToList();
                        dgvWaitUp.DataSource = waitUpData;
                    }
                    //联动已扫描加物料 
                    List<TN_WM_B_TRAY_ITEM_MSTEntity> ThisUpData = (List<TN_WM_B_TRAY_ITEM_MSTEntity>)dgvThisUp.DataSource;

                    //如果已存在于已扫描物料区，则直接加数量
                    if (ThisUpData != null && ThisUpData.Where(x => x.CN_S_ITEM_CODE == e.itemInfo.CN_S_ITEM_CODE).ToList().Count > 0)
                    {
                        foreach (var item in ThisUpData)
                        {
                            if (item.CN_S_ITEM_CODE == e.itemInfo.CN_S_ITEM_CODE)
                            {
                                item.CN_F_QUANTITY = item.CN_F_QUANTITY + e.itemInfo.CN_F_PACKING_QTY;
                            }
                        }
                        dgvThisUp.DataSource = ThisUpData;
                        dgvThisUp.Refresh();
                    }
                    //如果不存在于已扫描物料区，则直接加一行
                    else
                    {
                        List<TN_WM_B_TRAY_ITEM_MSTEntity> newRowList = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
                        newRowList.Add(new TN_WM_B_TRAY_ITEM_MSTEntity()
                        {
                            TokenId = StaticUtil.TokenId,
                            CN_GUID = Guid.NewGuid().ToString(),
                            CN_S_TRAY_CODE = trayInfoModel.CN_S_TRAY_CODE,
                            CN_S_TRAY_GRID = PutInGrid.ToString(),
                            CN_S_ITEM_CODE = e.itemInfo.CN_S_ITEM_CODE,
                            CN_S_ITEM_NAME = e.itemInfo.CN_S_ITEM_NAME,
                            CN_S_FIGURE_NO = e.itemInfo.CN_S_FIGURE_NO,
                            CN_F_QUANTITY = e.itemInfo.CN_F_PACKING_QTY,
                            CN_S_ITEM_STATE = Constants.ItemState_Qualified,//默认
                            CN_S_MEASURE_UNIT = e.itemInfo.CN_S_PACKING_UNIT,
                            CN_S_MODEL = e.itemInfo.CN_S_MODEL,
                            CN_S_OWNER = e.itemInfo.CN_S_OWNER
                        });
                        dgvThisUp.DataSource = newRowList;
                    }
                    #endregion

                    #region 容器样式联动
                    tray.SetNumByTrayGrid(PutInGrid, allAddInWeight, trayInfoModel.CN_F_LOADBEARING.HasValue ? trayInfoModel.CN_F_LOADBEARING.Value : 1);
                    //tray.Refresh();

                    #endregion

                    //存在容器码，扫描物料则是需要码盘
                    TN_WM_B_TRAY_ITEM_MSTEntity mst = new TN_WM_B_TRAY_ITEM_MSTEntity()
                    {
                        TokenId = StaticUtil.TokenId,
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_S_UNIQUE_CODE = e.itemInfo.CN_S_UNIQUE_CODE,
                        CN_S_TRAY_CODE = trayInfoModel.CN_S_TRAY_CODE,
                        CN_S_TRAY_GRID = PutInGrid.ToString(),
                        CN_S_ITEM_CODE = e.itemInfo.CN_S_ITEM_CODE,
                        CN_S_LOT_NO = e.itemInfo.CN_S_LOT_NO,
                        CN_S_ITEM_NAME = e.itemInfo.CN_S_ITEM_NAME,
                        CN_S_FIGURE_NO = e.itemInfo.CN_S_FIGURE_NO,
                        CN_F_QUANTITY = e.itemInfo.CN_F_PACKING_QTY,
                        CN_S_ITEM_STATE = Constants.ItemState_Qualified,//默认
                        CN_S_MEASURE_UNIT = string.IsNullOrEmpty(e.itemInfo.CN_S_PACKING_UNIT) ? GetItemEntity(e.itemInfo.CN_S_ITEM_CODE.ToString()).CN_S_MEASURE_UNIT : e.itemInfo.CN_S_PACKING_UNIT,
                        CN_S_MODEL = e.itemInfo.CN_S_MODEL,
                        CN_S_OWNER = e.itemInfo.CN_S_OWNER
                    };
                    List<TN_WM_B_TRAY_ITEM_DTLEntity> trayitemrelDtl = new List<TN_WM_B_TRAY_ITEM_DTLEntity>();
                    trayitemrelDtl.Add(new TN_WM_B_TRAY_ITEM_DTLEntity()
                    {
                        CN_PARENT_GUID = mst.CN_GUID,
                        CN_S_PACKING_UNIT = e.itemInfo.CN_S_PACKING_UNIT,
                        CN_F_PACKING_QTY = e.itemInfo.CN_F_PACKING_QTY,
                        CN_S_LOT_NO = e.itemInfo.CN_S_LOT_NO,
                        CN_S_PRODUCTION_BATCH = e.itemInfo.CN_S_PRODUCTION_BATCH
                    });
                    mst.TrayItemDtlList = trayitemrelDtl;

                    scanedWaitExecuteItems.Add(mst);
                    haveAlreadyScan.Add(e.itemInfo.CN_S_UNIQUE_CODE);
                }
                else
                {
                    MessageBoxEx.Show("未找到有效位置！");
                    return;
                }


            }
        }

        /// <summary>
        /// 判断物料是否可以放到容器上
        /// </summary>
        /// <param name="itemCode">物料编码</param>
        /// <param name="scanItemModel">扫描物料唯一码返回的实体，如果扫描的是物料编码，则此值为null</param>
        /// <returns></returns>
        private int DoPutItemInTray(string itemCode, MONGO_PRINT_BARCODE scanItemModel)
        {
            //循环容器分格
            for (var a = 1; a <= trayInfoModel.CN_N_COLUMN_NUM * trayInfoModel.CN_N_ROW_NUM; a++)
            {
                #region 判断重量是否超标
                var trayGrid = a;
                var groupList_1 = originalTrayItemList.GroupBy(x => new
                {
                    x.CN_S_TRAY_GRID,
                    x.CN_S_ITEM_CODE,
                    x.CN_S_WEIGHT
                }).Select(g => new TN_WM_B_TRAY_ITEM_MSTEntity
                {
                    CN_S_TRAY_GRID = g.FirstOrDefault().CN_S_TRAY_GRID.Trim(),
                    CN_S_ITEM_CODE = g.FirstOrDefault().CN_S_ITEM_CODE.Trim(),
                    CN_S_WEIGHT = g.Sum(p => p.CN_F_QUANTITY) * (GetItemEntity(g.FirstOrDefault().CN_S_ITEM_CODE.Trim())).CN_F_TW
                }).ToList();

                var groupList_2 = groupList_1.GroupBy(x => new
                {
                    x.CN_S_TRAY_GRID,
                    x.CN_S_WEIGHT
                }).Select(g => new TN_WM_B_TRAY_ITEM_MSTEntity
                {
                    CN_S_TRAY_GRID = g.FirstOrDefault().CN_S_TRAY_GRID.Trim(),
                    CN_S_WEIGHT = g.Sum(p => p.CN_S_WEIGHT)
                }).ToList();

                var selectItem = groupList_2.Where(x => x.CN_S_TRAY_GRID == trayGrid.ToString()).ToList();
                decimal haveWeight = 0;//容器分格内原有物料重量（已汇总）
                if (selectItem.Count != 0)
                {
                    haveWeight = selectItem[0].CN_S_WEIGHT;
                }
                //**************************************************************
                var groupList_3 = scanedWaitExecuteItems.GroupBy(x => new
                {
                    x.CN_S_TRAY_GRID,
                    x.CN_S_ITEM_CODE,
                    x.CN_S_WEIGHT
                }).Select(g => new TN_WM_B_TRAY_ITEM_MSTEntity
                {
                    CN_S_TRAY_GRID = g.FirstOrDefault().CN_S_TRAY_GRID.Trim(),
                    CN_S_ITEM_CODE = g.FirstOrDefault().CN_S_ITEM_CODE.Trim(),
                    CN_S_WEIGHT = g.Sum(p => p.CN_F_QUANTITY) * (GetItemEntity(g.FirstOrDefault().CN_S_ITEM_CODE.Trim())).CN_F_TW
                }).ToList();

                var groupList_4 = groupList_3.GroupBy(x => new
                {
                    x.CN_S_TRAY_GRID,
                    x.CN_S_WEIGHT
                }).Select(g => new TN_WM_B_TRAY_ITEM_MSTEntity
                {
                    CN_S_TRAY_GRID = g.FirstOrDefault().CN_S_TRAY_GRID.Trim(),
                    CN_S_WEIGHT = g.Sum(p => p.CN_S_WEIGHT)
                }).ToList();

                var scanItem = groupList_4.Where(x => x.CN_S_TRAY_GRID == trayGrid.ToString()).ToList();
                decimal scanWeight = 0;//容器分格本次已经放置物料重量（已汇总）
                if (scanItem.Count != 0)
                {
                    scanWeight = scanItem[0].CN_S_WEIGHT;
                }

                //**************************************************************

                //准备入容器分格的重量
                decimal PrepareWeight = (itemTempModel.CN_F_TW) * (scanItemModel == null ? itemTempModel.CN_F_MIN_PACK_QTY : scanItemModel.CN_F_PACKING_QTY);

                //容器内原有重量+已扫描放置重量+本次待放置重量+实际重量
                allAddInWeight = haveWeight + scanWeight + PrepareWeight + Convert.ToDecimal(trayInfoModel.CN_F_WEIGHT);

                #endregion

                if (allAddInWeight <= Convert.ToDecimal(trayInfoModel.CN_F_LOADBEARING))
                {
                    //物料是否存在于原始容器中
                    var haveOld = originalTrayItemList.Where(x => x.CN_S_ITEM_CODE == itemCode).ToList();
                    //物料是否存在于刚扫物料集合内
                    var haveNew = scanedWaitExecuteItems.Where(x => x.CN_S_ITEM_CODE == itemCode).ToList();

                    if (haveOld.Count == 0 && haveNew.Count == 0)
                    {
                        //新物料，直接放
                        return trayGrid;
                    }
                    else
                    {
                        //判断批次是否允许混放
                        if (isAllowMixing)
                        {
                            //判断是否质保件
                            if (itemTempModel.CN_C_IS_WARRNTY_PARTS == "Y")
                            {
                                if (scanItemModel.CN_S_LOT_NO == originalTrayItemList[0].CN_S_LOT_NO)//批次相同
                                {
                                    return trayGrid;
                                }
                            }
                            else
                            {
                                return trayGrid;
                            }
                        }
                        else
                        {
                            if (originalTrayItemList.Count > 0)
                            {
                                if (scanItemModel.CN_S_LOT_NO == originalTrayItemList[0].CN_S_LOT_NO)//批次相同
                                {
                                    return trayGrid;
                                }
                            }
                            if (scanedWaitExecuteItems.Count > 0)
                            {
                                if (scanItemModel.CN_S_LOT_NO == scanedWaitExecuteItems[0].CN_S_LOT_NO)//批次相同
                                {
                                    return trayGrid;
                                }
                            }
                        }
                    }
                }
            }
            return 0;
        }

        /// <summary>
        /// 获取物料实体，并加页面缓存
        /// </summary>
        /// <param name="itemCode">物料编码</param>
        /// <returns></returns>
        public AutoBomItemEntity GetItemEntity(string itemCode)
        {
            AutoBomItemEntity itemMode = new AutoBomItemEntity();
            if (itemModelCacheList != null)
            {
                foreach (var item in itemModelCacheList)
                {
                    if (item.CN_S_ITEM_CODE == itemCode)
                    {
                        itemMode = item;
                        break;
                    }
                }
            }
            if (string.IsNullOrEmpty(itemMode.CN_S_ITEM_CODE))
            {
                string itemStr = WebApiManager.HttpWMS_Get("/api/Item/GetItemModel?itemCode=" + itemCode);
                OperateResult results = JsonConvert.DeserializeObject<OperateResult>(itemStr);
                if (results.Success)
                {
                    itemTempModel = JsonConvert.DeserializeObject<AutoBomItemEntity>(results.Data.ToString());
                    itemMode = itemTempModel;
                    itemModelCacheList.Add(itemTempModel);
                }
            }
            if (string.IsNullOrEmpty(itemMode.CN_S_ITEM_CODE))
            {
                MessageBoxEx.Show("物料 " + itemCode + " 不存在！");
            }
            return itemMode;
        }
        /// <summary>
        /// 扫描物料
        /// </summary>
        void frmUpShelves_ScanItemEvent(object sender, frmTemplet.ScanItemEventArgs e)
        {
            if (lblItemTray.Text.Trim() == "_______________")
            {
                //不存在容器码，指引物料
                //获取待上架的所有物料
                string str = WebApiManager.HttpWMS_Get("/api/Up/GetWaitUpShelvesItems?itemCode=" + e.itemInfo.CN_S_ITEM_CODE);
                OperateResult or = JsonConvert.DeserializeObject<OperateResult>(str);
                if (or.Status == ResultStatus.Success)
                {
                    if (((JArray)or.Data).Count > 0)
                    {
                        //绑定待上架的物料
                        dgvWaitUp.AutoGenerateColumns = false;
                        dgvWaitUp.DataSource = or.Data;
                        btnEnter.Text = "确认指引";
                    }
                    else
                    {
                        MessageBoxEx.Show("无待上架的物料");
                    }
                }
            }
            else
            {
                // 存在容器码，扫描物料则是需要码盘
                TN_WM_B_TRAY_ITEM_MSTEntity mst = new TN_WM_B_TRAY_ITEM_MSTEntity()
                {
                    TokenId = StaticUtil.TokenId,
                    CN_S_ITEM_CODE = e.itemInfo.CN_S_ITEM_CODE,
                    CN_S_ITEM_NAME = e.itemInfo.CN_S_ITEM_NAME,
                    CN_S_FIGURE_NO = e.itemInfo.CN_S_FIGURE_NO,
                    CN_S_MEASURE_UNIT = e.itemInfo.CN_S_MEASURE_UNIT,
                    CN_F_QUANTITY = e.itemInfo.CN_F_MIN_PACK_QTY,
                    CN_S_ITEM_STATE = Constants.ItemState_Qualified,//默认
                    CN_S_OWNER = Constants.DefaultOwner
                };
                mst.TrayItemDtlList.Add(new TN_WM_B_TRAY_ITEM_DTLEntity()
                {
                    CN_PARENT_GUID = mst.CN_GUID,
                    CN_S_PACKING_UNIT = e.itemInfo.CN_S_PACK_UNIT,
                    CN_F_PACKING_QTY = e.itemInfo.CN_F_MIN_PACK_QTY
                });
                scanedWaitExecuteItems.Add(mst);
            }
            txtCode.Clear();
        }

        /// <summary>
        /// 扫描容器号
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void frmUpShelves_ScanTrayEvent(object sender, frmTemplet.ScanTrayEventArgs e)
        {
            if (lblItemTray.Text.Trim() != "_______________")
            {
                MessageBoxEx.Show("请把当前容器 " + lblItemTray.Text.Trim() + " 处理完成后再切换容器！");
                return;
            }

            #region 判断：根据容器找所在货位信息
            OperateResult resultLocation = new TrayBll().GetLocationByTray(e.trayInfo.CN_S_TRAY_CODE);
            if (resultLocation.Success)
            {
                if (resultLocation.Data != null)
                {
                    TN_WM_B_TRAY_LOCATIONEntity items = JsonConvert.DeserializeObject<TN_WM_B_TRAY_LOCATIONEntity>(resultLocation.Data.ToString());
                    if (!string.IsNullOrEmpty(items.CN_S_LOCATION_CODE))
                    {
                        MessageBoxEx.Show("容器 " + e.trayInfo.CN_S_TRAY_CODE + " 已在货位 " + items.CN_S_LOCATION_CODE + " 上，禁止扫码！");
                        return;
                    }
                }
            }
            #endregion

            #region 判断：根据容器找所在任务信息
            OperateResult resultTask = new TrayBll().GetTaskByTray(e.trayInfo.CN_S_TRAY_CODE);
            if (resultTask.Success)
            {
                List<TN_WM_TASKEntity> items = JsonConvert.DeserializeObject<List<TN_WM_TASKEntity>>(resultTask.Data.ToString());
                if (items.Any())
                {
                    MessageBoxEx.Show("容器 " + e.trayInfo.CN_S_TRAY_CODE + " 已在任务 " + items[0].CN_S_TASK_NO + " 中，禁止扫码！");
                    return;
                }
            }
            #endregion

            if (lblWaitTray.Text != "等待容器..........")
            {
                if (_waitTray.Contains(e.trayInfo.CN_S_TRAY_CODE))
                {
                    lblWaitTray.Text = "容器 " + e.trayInfo.CN_S_TRAY_CODE + " 正在执行";
                }
                else
                {
                    MessageBoxEx.Show("请扫描等待容器！");
                    return;
                }
            }

            lblItemTray.Text = e.trayInfo.CN_S_TRAY_CODE;
            txtCode.Clear();

            //加载容器信息
            OperateResult resultTrayInfo = new TrayBll().GetTrayInfo(e.trayInfo.CN_S_TRAY_CODE);
            if (resultTrayInfo.Success)
            {
                trayInfoModel = JsonConvert.DeserializeObject<TN_WM_B_TRAY_INFOEntity>(resultTrayInfo.Data.ToString());

                tray = new CusTray(trayInfoModel.CN_N_ROW_NUM, trayInfoModel.CN_N_COLUMN_NUM);
                tray.Dock = DockStyle.Fill;
                panelCurrentTray.Controls.Add(tray);
            }

            //加载容器中的物料信息
            OperateResult result = new TrayBll().GetItems(e.trayInfo.CN_S_TRAY_CODE);
            if (result.Success)
            {
                List<TN_WM_B_TRAY_ITEM_MSTEntity> items = JsonConvert.DeserializeObject<List<TN_WM_B_TRAY_ITEM_MSTEntity>>(result.Data.ToString());
                originalTrayItemList = items;
                dgvData.DataSource = items;
            }
            //加载容器的预预分配信息
            result = new TrayBll().GetTrayAlloc(e.trayInfo.CN_S_TRAY_CODE);
            if (result.Status == ResultStatus.Success)
            {
                List<TN_WM_TRAY_ALLOCEntity> allocs = JsonConvert.DeserializeObject<List<TN_WM_TRAY_ALLOCEntity>>(result.Data.ToString());
                List<TN_WM_B_TRAY_ITEM_MSTEntity> itemMstList = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();

                foreach (var item in allocs)
                {
                    itemMstList.Add(new TN_WM_B_TRAY_ITEM_MSTEntity
                    {
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_S_TRAY_GRID = item.CN_S_TRAY_GRID,
                        CN_S_TRAY_CODE = item.CN_S_TRAY_CODE,
                        CN_S_ITEM_CODE = item.CN_S_ITEM_CODE,
                        CN_S_ITEM_NAME = item.CN_S_ITEM_NAME,
                        CN_S_FIGURE_NO = item.CN_S_FIGURE_NO,
                        CN_F_QUANTITY = item.CN_F_QUANTITY.HasValue ? item.CN_F_QUANTITY.Value : 0,
                        CN_S_ITEM_STATE = Constants.ItemState_Qualified,//默认
                        CN_S_MEASURE_UNIT = GetItemEntity(item.CN_S_ITEM_CODE.ToString()).CN_S_MEASURE_UNIT,
                        CN_S_MODEL = item.CN_S_MODEL
                    });
                }
                dgvWaitUp.DataSource = itemMstList;
            }

            //扫描容器后，可以直接“回库”或“入库”
            btnEnter.Text = "入库";

        }

        private void frmUpShelves_Load(object sender, EventArgs e)
        {
            this.txtCode.Focus();
            //获取物料是否允许混放
            GetAllowMixing();
        }

        #region 获取策略：物料不同批次是否允许混放
        private void GetAllowMixing()
        {
            string str = WebApiManager.HttpWMS_Get("/api/TrayItemRel/GetStrategyListByAreaCode?areaCode=" + StaticUtil.WorkArea);
            OperateResult or = JsonConvert.DeserializeObject<OperateResult>(str);
            if (or.Status == ResultStatus.Success)
            {
                List<STRATEGYALGOREntity> lstStrategy = JsonConvert.DeserializeObject<List<STRATEGYALGOREntity>>(or.Data.ToString());

                var returnList = lstStrategy.Where(x => x.CN_S_CODE == StrategyKey.MixedBatchesOrNot).ToList();
                if (returnList.Count > 0)
                {
                    isAllowMixing = true;
                }
                else
                {
                    isAllowMixing = false;
                }
            }
        }
        #endregion

        void frmUpShelves_ScanEnterEvent(object sender, EventArgs e)
        {
            btnEnter_Click(sender, e);
        }

        //提交操作
        private void btnEnter_Click(object sender, EventArgs e)
        {
            switch (btnEnter.Text)
            {
                case "入库":
                    #region 入库功能
                    List<TN_WM_B_TRAY_ITEM_MSTEntity> waitUpData = (List<TN_WM_B_TRAY_ITEM_MSTEntity>)dgvWaitUp.DataSource;

                    //是否继续指引
                    bool isContinueAlloc = false;
                    if (waitUpData.Count > 0)
                    {
                        DialogResult dr = MessageBoxEx.Show("待上架区剩余物料是否继续指引容器？", "", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2);

                        if (dr == DialogResult.Yes)
                        {
                            //点确定的代码
                            // MessageBoxEx.Show("点确定");
                            isContinueAlloc = true;
                        }
                        else
                        { //点取消的代码 //继续放物料
                            return;
                        }
                    }

                    TN_WM_TASKEntity task = new TN_WM_TASKEntity()
                    {
                        CN_N_PRIORITY = 1,
                        CN_S_END_AREA = StaticUtil.WorkArea,
                        CN_S_FROM_OP = "",
                        CN_S_FROM_NO = "",
                        CN_S_START_AREA = StaticUtil.WorkBench,
                        CN_S_START_BIT = StaticUtil.WorkBenchTrayBit,
                        CN_S_STOCK_CODE = StaticUtil.StockCode,
                        CN_S_TASK_TYPE = "上架",
                        CN_S_TRAY_CODE = lblItemTray.Text.Trim(),
                        TokenId = StaticUtil.TokenId
                    };
                    OperateResult orTrayItem = new OperateResult();

                    if (scanedWaitExecuteItems.Any())
                    {
                        #region 拼接最终提交数据
                        List<TN_WM_B_TRAY_ITEM_MSTEntity> mstNewList = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
                        //批量克隆
                        scanedWaitExecuteItems.ForEach(x =>
                        {
                            mstNewList.Add(TransExpV2<TN_WM_B_TRAY_ITEM_MSTEntity, TN_WM_B_TRAY_ITEM_MSTEntity>.Trans(x));
                        });

                        var mstNewList_GroupList = mstNewList.GroupBy(x => new
                        {
                            x.CN_S_ITEM_CODE,
                            x.CN_S_ITEM_STATE,
                            x.CN_S_OWNER,
                            x.CN_S_TRAY_GRID
                        }).Select(g => new TN_WM_B_TRAY_ITEM_MSTEntity
                        {
                            CN_S_TRAY_CODE = g.FirstOrDefault().CN_S_TRAY_CODE.Trim(),
                            CN_S_TRAY_GRID = g.FirstOrDefault().CN_S_TRAY_GRID.Trim(),
                            CN_S_ITEM_CODE = g.FirstOrDefault().CN_S_ITEM_CODE.Trim(),
                            CN_S_ITEM_NAME = g.FirstOrDefault().CN_S_ITEM_NAME.Trim(),
                            CN_S_FIGURE_NO = g.FirstOrDefault().CN_S_FIGURE_NO.Trim(),
                            CN_S_ITEM_STATE = g.FirstOrDefault().CN_S_ITEM_STATE.Trim(),
                            CN_S_MEASURE_UNIT = g.FirstOrDefault().CN_S_MEASURE_UNIT.Trim(),
                            CN_S_MODEL = g.FirstOrDefault().CN_S_MODEL.Trim(),
                            CN_S_OWNER = g.FirstOrDefault().CN_S_OWNER.Trim(),
                            CN_F_QUANTITY = g.Sum(p => p.CN_F_QUANTITY)
                        }).ToList();

                        List<TN_WM_B_TRAY_ITEM_MSTEntity> _FinallyScanData = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
                        foreach (var item in mstNewList_GroupList)
                        {
                            var itemCode = item.CN_S_ITEM_CODE;
                            var trayGrid = item.CN_S_TRAY_GRID;
                            var itemState = item.CN_S_ITEM_STATE;
                            var owner = item.CN_S_OWNER;
                            TN_WM_B_TRAY_ITEM_MSTEntity mstData = new TN_WM_B_TRAY_ITEM_MSTEntity();
                            mstData = item;
                            mstData.CN_GUID = System.Guid.NewGuid().ToString().ToUpper();
                            mstData.TokenId = scanedWaitExecuteItems[0].TokenId;

                            List<TN_WM_B_TRAY_ITEM_DTLEntity> dtlList = new List<TN_WM_B_TRAY_ITEM_DTLEntity>();
                            var _findDtlList = mstNewList.Where(x => x.CN_S_ITEM_CODE == itemCode && x.CN_S_TRAY_GRID == trayGrid && x.CN_S_OWNER == owner && x.CN_S_ITEM_STATE == itemState).ToList();
                            if (_findDtlList.Count > 0)
                            {
                                foreach (var itemDtl in _findDtlList)
                                {
                                    dtlList.AddRange(itemDtl.TrayItemDtlList);
                                }
                            }

                            List<TN_WM_B_TRAY_ITEM_DTLEntity> dtlResultList = new List<TN_WM_B_TRAY_ITEM_DTLEntity>();

                            dtlResultList = dtlList.GroupBy(x => new
                            {
                                x.CN_S_LOT_NO,
                                x.CN_S_PRODUCTION_BATCH,
                                x.CN_S_PACKING_UNIT
                            }).Select(g => new TN_WM_B_TRAY_ITEM_DTLEntity
                            {
                                CN_F_PURCHASE_PRICE = g.FirstOrDefault().CN_F_PURCHASE_PRICE,
                                CN_F_RETAIL_PRICE = g.FirstOrDefault().CN_F_PURCHASE_PRICE,
                                CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                                CN_F_QUANTITY = g.FirstOrDefault().CN_F_QUANTITY,
                                CN_S_CREATOR = g.FirstOrDefault().CN_S_CREATOR,
                                CN_S_CREATOR_BY = g.FirstOrDefault().CN_S_CREATOR_BY,
                                CN_T_CREATE = g.FirstOrDefault().CN_T_CREATE,
                                CN_S_MODIFY = g.FirstOrDefault().CN_S_MODIFY,
                                CN_S_MODIFY_BY = g.FirstOrDefault().CN_S_MODIFY_BY,
                                CN_T_MODIFY = g.FirstOrDefault().CN_T_MODIFY,
                                CN_S_LOT_NO = g.FirstOrDefault().CN_S_LOT_NO,
                                CN_S_PRODUCTION_BATCH = g.FirstOrDefault().CN_S_PRODUCTION_BATCH,
                                CN_S_SERIAL_NO = g.FirstOrDefault().CN_S_SERIAL_NO,
                                CN_S_NOTE = g.FirstOrDefault().CN_S_NOTE,
                                CN_S_PACKING_UNIT = g.FirstOrDefault().CN_S_PACKING_UNIT,
                                CN_S_VENDOR_NO = g.FirstOrDefault().CN_S_VENDOR_NO,
                                CN_S_VENDOR_NAME = g.FirstOrDefault().CN_S_VENDOR_NAME,
                                CN_T_EXPIRATION = g.FirstOrDefault().CN_T_EXPIRATION,
                                CN_T_PRODUCTION = g.FirstOrDefault().CN_T_PRODUCTION,
                                CN_S_UNIQUE_CODE = g.FirstOrDefault().CN_S_UNIQUE_CODE,
                                CN_PARENT_GUID = mstData.CN_GUID,
                                CN_F_PACKING_QTY = g.Sum(p => p.CN_F_PACKING_QTY)
                            }).ToList();

                            mstData.TrayItemDtlList = dtlResultList;
                            _FinallyScanData.Add(mstData);
                        }
                        #endregion

                        string strTrayItem = WebApiManager.HttpWMS_Post("/api/Up/CommitTrayItem", JsonConvert.SerializeObject(_FinallyScanData));
                        orTrayItem = JsonConvert.DeserializeObject<OperateResult>(strTrayItem);
                        if (orTrayItem.Status == ResultStatus.Success)
                        {
                            scanedWaitExecuteItems = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
                        }
                        else
                        {
                            MessageBoxEx.Show(orTrayItem.Msg);
                        }
                    }
                    else { orTrayItem.Success = true; }

                    if (orTrayItem.Success)
                    {
                        string strup = WebApiManager.HttpWMS_Post("/api/Up/CommitUp", JsonConvert.SerializeObject(task));
                        OperateResult orup = JsonConvert.DeserializeObject<OperateResult>(strup);
                        if (orup.Status == ResultStatus.Success)
                        {
                            MessageBoxEx.Show("入库成功！");

                            //继续指引托盘出库

                            #region 指引托盘出库
                            if (isContinueAlloc)
                            {
                                List<object> oCon = new List<object>();
                                foreach (DataGridViewRow r in dgvWaitUp.Rows)
                                {
                                    oCon.Add(new
                                    {
                                        item = r.Cells["CN_S_ITEM_CODE"].Value.ToString(),
                                        qty = r.Cells["CN_F_QUANTITY"].Value.ToString(),
                                        sortingPlatfrom = StaticUtil.WorkBench,
                                        trayEndBit = StaticUtil.WorkBenchTrayBit,
                                        workAreaCode = StaticUtil.WorkArea,
                                        tokenId = StaticUtil.TokenId
                                    });
                                }
                                string strCon = WebApiManager.HttpWMS_Post("/api/Up/CommitUpGuide", JsonConvert.SerializeObject(oCon));
                                OperateResult orCon = JsonConvert.DeserializeObject<OperateResult>(strCon);
                                if (orCon.Status != ResultStatus.Success)
                                {
                                    MessageBoxEx.Show(orCon.Msg);
                                }
                                else
                                {
                                    //等待容器
                                    List<string> returnWt = JsonConvert.DeserializeObject<List<string>>(orCon.Data.ToString());
                                    WaitTray.AddRange(returnWt);
                                }
                            }
                            #endregion

                            //上架完成后
                            if (lblWaitTray.Text != "等待容器..........")
                            {
                                _waitTray.Remove(lblItemTray.Text);
                                WaitTray = _waitTray;
                            }
                            UpClearForm();
                            return;
                        }
                        else
                        {
                            MessageBoxEx.Show(orup.Msg);
                        }
                    }
                    #endregion
                    break;
                case "确认指引":
                    #region 指引功能
                    if (dgvWaitUp.Rows.Count == 0)
                    {
                        MessageBoxEx.Show("无待上架物料可供指引！");
                        return;
                    }
                    List<object> o = new List<object>();
                    foreach (DataGridViewRow r in dgvWaitUp.Rows)
                    {
                        o.Add(new
                        {
                            item = r.Cells["CN_S_ITEM_CODE"].Value.ToString(),
                            qty = r.Cells["CN_F_QUANTITY"].Value.ToString(),
                            sortingPlatfrom = StaticUtil.WorkBench,
                            trayEndBit = StaticUtil.WorkBenchTrayBit,
                            workAreaCode = StaticUtil.WorkArea,
                            tokenId = StaticUtil.TokenId
                        });
                    }

                    string str = WebApiManager.HttpWMS_Post("/api/Up/CommitUpGuide", JsonConvert.SerializeObject(o));
                    OperateResult or = JsonConvert.DeserializeObject<OperateResult>(str);
                    if (or.Status != ResultStatus.Success)
                    {
                        MessageBoxEx.Show(or.Msg);
                    }
                    else
                    {
                        //等待容器
                        MessageBoxEx.Show("指引成功！");
                        UpClearForm();
                        List<string> returnWt = JsonConvert.DeserializeObject<List<string>>(or.Data.ToString());
                        WaitTray = returnWt;
                    }
                    #endregion
                    break;
            }
        }

        /// <summary>
        /// 初始化控件
        /// </summary>
        private void UpClearForm()
        {
            lblItemTray.Text = "_______________";
            btnEnter.Text = "Enter";
            panelCurrentTray.Controls.Clear();
            dgvData.DataSource = null;
            dgvThisUp.DataSource = null;
            dgvWaitUp.DataSource = null;
        }

        /// <summary>
        /// 物料移除
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_ItemRemove_Click(object sender, EventArgs e)
        {
            if (scanedWaitExecuteItems.Any())
            {
                List<TN_WM_B_TRAY_ITEM_MSTEntity> scanedWaitExecuteItems_New = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
                frmItemRemove frm = new frmItemRemove(scanedWaitExecuteItems);
                if (frm.ShowDialog() == DialogResult.OK)
                {
                    scanedWaitExecuteItems_New = frm.RemoveList;

                    //批量克隆
                    //frm.RemoveList.ForEach(x =>
                    //{
                    //    scanedWaitExecuteItems_New.Add(TransExpV2<TN_WM_B_TRAY_ITEM_MSTEntity, TN_WM_B_TRAY_ITEM_MSTEntity>.Trans(x));
                    //});

                    if (scanedWaitExecuteItems_New.Count > 0)
                    {
                        List<TN_WM_B_TRAY_ITEM_MSTEntity> _groupList = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
                        _groupList = scanedWaitExecuteItems_New.GroupBy(x => new
                        {
                            x.CN_S_TRAY_GRID,
                            x.CN_S_ITEM_CODE,
                        }).Select(g => new TN_WM_B_TRAY_ITEM_MSTEntity
                        {
                            CN_S_ITEM_CODE = g.FirstOrDefault().CN_S_ITEM_CODE.Trim(),
                            CN_F_QUANTITY = g.Sum(p => p.CN_F_QUANTITY)
                        }).ToList();

                        #region 表格联动
                        //联动待上架加物料
                        List<TN_WM_B_TRAY_ITEM_MSTEntity> waitUpData = (List<TN_WM_B_TRAY_ITEM_MSTEntity>)dgvWaitUp.DataSource;

                        List<TN_WM_B_TRAY_ITEM_MSTEntity> waitNewRow = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
                        foreach (var itemWait in scanedWaitExecuteItems_New)
                        {
                            if (waitUpData.Count > 0)
                            {
                                foreach (var itemNew in waitUpData)
                                {
                                    if (itemNew.CN_S_ITEM_CODE == itemWait.CN_S_ITEM_CODE)
                                    {
                                        itemNew.CN_F_QUANTITY = itemNew.CN_F_QUANTITY + itemWait.CN_F_QUANTITY;
                                    }
                                    else
                                    {
                                        foreach (var itemExist in waitNewRow)
                                        {
                                            if (itemExist.CN_S_ITEM_CODE == itemWait.CN_S_ITEM_CODE)
                                            {
                                                itemExist.CN_F_QUANTITY = itemExist.CN_F_QUANTITY + itemWait.CN_F_QUANTITY;
                                            }
                                            else
                                            {
                                                TN_WM_B_TRAY_ITEM_MSTEntity add = TransExpV2<TN_WM_B_TRAY_ITEM_MSTEntity, TN_WM_B_TRAY_ITEM_MSTEntity>.Trans(itemWait);
                                                waitNewRow.Add(add);
                                            }
                                        }
                                    }
                                }
                            }
                            else
                            {
                                if (waitNewRow.Count > 0)
                                {
                                    foreach (var itemExist in waitNewRow)
                                    {
                                        if (itemExist.CN_S_ITEM_CODE == itemWait.CN_S_ITEM_CODE)
                                        {
                                            itemExist.CN_F_QUANTITY = itemExist.CN_F_QUANTITY + itemWait.CN_F_QUANTITY;
                                        }
                                        else
                                        {
                                            TN_WM_B_TRAY_ITEM_MSTEntity add = TransExpV2<TN_WM_B_TRAY_ITEM_MSTEntity, TN_WM_B_TRAY_ITEM_MSTEntity>.Trans(itemWait);
                                            waitNewRow.Add(add);
                                        }
                                    }
                                }
                                else
                                {
                                    TN_WM_B_TRAY_ITEM_MSTEntity add = TransExpV2<TN_WM_B_TRAY_ITEM_MSTEntity, TN_WM_B_TRAY_ITEM_MSTEntity>.Trans(itemWait);
                                    waitNewRow.Add(add);
                                }
                            }
                        }
                        if (waitNewRow.Count > 0)
                        {
                            waitUpData.AddRange(waitNewRow);
                        }
                        dgvWaitUp.DataSource = null;
                        dgvWaitUp.DataSource = waitUpData;
                        dgvWaitUp.Refresh();

                        //联动已扫描减物料 
                        List<TN_WM_B_TRAY_ITEM_MSTEntity> ThisUpData = (List<TN_WM_B_TRAY_ITEM_MSTEntity>)dgvThisUp.DataSource;
                        foreach (var itemThis in ThisUpData)
                        {
                            foreach (var itemNew in scanedWaitExecuteItems_New)
                            {
                                if (itemNew.CN_S_ITEM_CODE == itemThis.CN_S_ITEM_CODE)
                                {
                                    itemThis.CN_F_QUANTITY = itemThis.CN_F_QUANTITY - itemNew.CN_F_QUANTITY;
                                }
                            }
                        }
                        ThisUpData = ThisUpData.Where(x => x.CN_F_QUANTITY > 0).ToList();
                        dgvThisUp.DataSource = ThisUpData;
                        dgvThisUp.Refresh();
                        #endregion

                        #region 已扫描剔除
                        List<string> haveAlreadyScan_New = new List<string>();
                        foreach (var item in haveAlreadyScan)
                        {
                            var isre = scanedWaitExecuteItems_New.Where(x => x.CN_S_UNIQUE_CODE == item).ToList();
                            if (isre.Count == 0)
                            {
                                haveAlreadyScan_New.Add(item);
                            }
                        }
                        haveAlreadyScan = haveAlreadyScan_New;
                        #endregion

                        #region 初始化托盘 
                        panelCurrentTray.Controls.Clear();
                        tray = new CusTray(trayInfoModel.CN_N_ROW_NUM, trayInfoModel.CN_N_COLUMN_NUM);
                        tray.Dock = DockStyle.Fill;
                        panelCurrentTray.Controls.Add(tray);
                        #endregion

                        #region 最终提交数据
                        foreach (var itemThis in scanedWaitExecuteItems)
                        {
                            foreach (var itemNew in scanedWaitExecuteItems_New)
                            {
                                if (itemNew.CN_S_UNIQUE_CODE == itemThis.CN_S_UNIQUE_CODE && itemNew.CN_S_ITEM_CODE == itemThis.CN_S_ITEM_CODE)
                                {
                                    itemThis.CN_F_QUANTITY = itemThis.CN_F_QUANTITY - itemNew.CN_F_QUANTITY;
                                }
                            }
                        }
                        //处理子表数量-基本单条子表
                        foreach (var item in scanedWaitExecuteItems)
                        {
                            foreach (var itemDtl in item.TrayItemDtlList)
                            {
                                itemDtl.CN_F_QUANTITY = item.CN_F_QUANTITY;
                            }
                        }
                        scanedWaitExecuteItems = scanedWaitExecuteItems.Where(x => x.CN_F_QUANTITY > 0).ToList();
                        #endregion

                    }

                }
            }
            else
            {
                MessageBoxEx.Show("当前无可移除物料！");
            }
        }

    }
}