using HH.WMS.BLL.OutStock;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Entitys;
using HH.WMS.WebApi.Areas.Common.Controllers;
using System.Configuration;
using HH.WMS.BLL;
using HH.WMS.BLL.Algorithm;
using HH.WMS.BLL.Basic;
using HH.WMS.BLL.Common;
using HH.WMS.BLL.InStock;
using HH.WMS.BLL.Pda;
using HH.WMS.BLL.SysMgr;
using HH.WMS.Common;
using HH.WMS.Common.Algorithm;
using HH.WMS.Common.External;
using HH.WMS.DAL;
using HH.WMS.DAL.InStock;
using HH.WMS.Entitys.Common;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Web.Http;

namespace HH.WMS.WebApi.Areas.Pda.Controllers
{
    public class HKController : BaseController
    {
        #region 分拣单列表
        /// <summary>
        /// 分拣单列表
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetSortings(string tokenId, string key = "")
        {
            return ValidateToken(tokenId, t =>
            {
                if (String.IsNullOrEmpty(key))
                {
                    var sortingList = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetList(new
                    {
                        CN_S_STATE = new List<string> { Constants.Sorting_Stay, Constants.Sorting_Being },
                    });
                    return OperateResult.Succeed(null,
                   sortingList.Select(x => new
                   {
                       SortingNo = x.CN_S_SORTING_NO,
                       //AreaCode = (allAreas.Find(f => f.CN_S_AREA_CODE.Equals(x.CN_S_STOCK_AREA)) ?? new AutoBomStockAreaEntity()).CN_S_AREA_NAME,
                       AreaCode = x.CN_S_FROM_NO,
                       CreateTime = x.CN_T_CREATE.ToString(),
                       Creator = x.CN_S_CREATOR_BY,
                       FromNo = x.CN_S_FROM_NO,
                       SortingState = x.CN_S_STATE
                   }));
                }
                else
                {
                    var sortingList = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetList(new
                    {
                        CN_S_STATE = new List<string> { Constants.Sorting_Stay, Constants.Sorting_Being },
                        CN_S_SORTING_NO = Util.ToLike(key),
                    });
                    return OperateResult.Succeed(null,
                   sortingList.Select(x => new
                   {
                       SortingNo = x.CN_S_SORTING_NO,
                       //AreaCode = (allAreas.Find(f => f.CN_S_AREA_CODE.Equals(x.CN_S_STOCK_AREA)) ?? new AutoBomStockAreaEntity()).CN_S_AREA_NAME,
                       AreaCode = x.CN_S_FROM_NO,
                       CreateTime = x.CN_T_CREATE.ToString(),
                       Creator = x.CN_S_CREATOR_BY,
                       FromNo = x.CN_S_FROM_NO,
                       SortingState = x.CN_S_STATE
                   }));
                }
            });
        }
        #endregion

        #region 执行分拣单
        /// <summary>
        /// 执行分拣单
        /// </summary>
        /// <param name="sortingNo"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult ExecuteSorting(string sortingNo)
        {
            return ValidateToken(t =>
            {
                if (string.IsNullOrEmpty(sortingNo))
                    return OperateResult.Error("分拣单不可为空");

                var sortingBeingEntity = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetSingleEntity(new
                {
                    CN_S_STATE = Constants.Sorting_Being
                });

                if (sortingBeingEntity != null)
                {
                    if (sortingBeingEntity.CN_S_SORTING_NO != sortingNo)
                    {
                        return OperateResult.Error("执行失败，请先完成分拣单：" + sortingBeingEntity.CN_S_SORTING_NO + "的分拣");
                    }
                }

                var sortingEntity = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetSingleEntity(new
                {
                    CN_S_SORTING_NO = sortingNo
                });
                if (sortingEntity == null)
                    return OperateResult.Error("未找到分拣单：" + sortingNo);

                if (sortingEntity.CN_S_STATE == Constants.Sorting_Being)
                    return OperateResult.Error("当前分拣单已执行");

                if (sortingEntity.CN_S_STATE == Constants.Sorting_Sorted)
                    return OperateResult.Error("当前分拣单已分拣");

                return BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().Update(new
                {
                    CN_S_STATE = Constants.Sorting_Being
                }, new
                {
                    CN_S_SORTING_NO = sortingNo
                });
            });
        }
        #endregion

        #region 取分拣单的物料
        /// <summary>
        /// 取分拣单的物料
        /// </summary>
        /// <param name="sortingNo"></param>
        /// <returns></returns>
        public OperateResult GetSortingItems(string sortingNo)
        {
            return ValidateToken(t =>
            {
                var sortingEntity = new TN_WM_SORTING_LISTEntity();
                if (string.IsNullOrEmpty(sortingNo))
                {
                    var sortingList = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetList(new
                    {
                        CN_S_STATE = new List<string> { Constants.Sorting_Stay, Constants.Sorting_Being },
                    }).OrderBy(o => o.CN_T_CREATE);
                    sortingEntity = sortingList.FirstOrDefault(f => f.CN_S_STATE == Constants.Sorting_Being);
                    if (sortingEntity == null)
                    {
                        sortingEntity = sortingList.FirstOrDefault(f => f.CN_S_STATE == Constants.Sorting_Stay);
                        if (sortingEntity == null)
                            return OperateResult.Error("当前未找到可执行的分拣单");
                    }
                }
                else
                {
                    sortingEntity = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetSingleEntity(new
                    {
                        CN_S_SORTING_NO = sortingNo
                    });
                    if (sortingEntity == null)
                        return OperateResult.Error("未找到分拣单：" + sortingNo);
                }

                var sortingLocation = BLLCreator.CreateDapper<TN_WM_SORTING_LOCATIONEntity>()
                .GetList(new
                {
                    CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO
                });
                var items = sortingLocation.GroupBy(g => new
                {
                    g.CN_S_ITEM_CODE,
                    g.CN_S_ITEM_NAME
                }).Select(s => new
                {
                    ItemName = s.Key.CN_S_ITEM_NAME,
                    PickedNum = s.Sum(m => m.CN_F_PICKED_QTY),
                    PickNum = s.Sum(m => m.CN_F_QUANTITY)
                });
                var res = new
                {
                    SortingNo = sortingEntity.CN_S_SORTING_NO,
                    SortingState = sortingEntity.CN_S_STATE,
                    LocationItems = items
                };

                return OperateResult.Succeed(null, res);
            });
        }
        #endregion

        #region 取货位分拣中的物料
        /// <summary>
        /// 取货位分拣中的物料
        /// </summary>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        public OperateResult GetSortingLocation(string locationCode)
        {
            return ValidateToken(t =>
            {
                var sortingLocations = BLLCreator.Create<OutStockBLL>().GetSortingLocation(locationCode);

                if (!sortingLocations.Any())
                    return OperateResult.Error("未找到该货位需要分拣的物料");

                if (!sortingLocations.FindAll(f => f.CN_F_PICKED_QTY == 0).Any())
                    return OperateResult.Error("该货位已分拣完");

                var trayLocation = BLLCreator.CreateDapper<TN_WM_B_TRAY_LOCATIONEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = locationCode
                });
                if (trayLocation == null)
                    return OperateResult.Error("当前货位不存在物料");
                if (trayLocation.CN_S_TRAY_CODE != sortingLocations[0].CN_S_TRAY_CODE)
                    return OperateResult.Error("当前货位已存在容器：" + trayLocation.CN_S_TRAY_CODE);

                var res = sortingLocations.GroupBy(g => new
                {
                    g.CN_S_ITEM_CODE,
                    g.CN_S_ITEM_NAME,
                    g.CN_S_MEASURE_UNIT,
                }).Select(s => new
                {
                    ItemCode = s.Key.CN_S_ITEM_CODE,
                    ItemName = s.Key.CN_S_ITEM_NAME,
                    ItemUnit = s.Key.CN_S_MEASURE_UNIT,
                    Qty = s.Sum(m => m.CN_F_QUANTITY)
                });

                return OperateResult.Succeed(null, res);
            });
        }
        #endregion

        #region 保存货位分拣
        /// <summary>
        /// 保存货位分拣
        /// </summary>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult SaveSortingLocation(string locationCode)
        {
            return ValidateToken(t =>
            {
                var sortingLocations = BLLCreator.Create<OutStockBLL>().GetSortingLocation(locationCode);

                if (!sortingLocations.Any())
                    return OperateResult.Error("未找到该货位需要分拣的物料");

                if (!sortingLocations.FindAll(f => f.CN_F_PICKED_QTY == 0).Any())
                    return OperateResult.Error("该货位已分拣完");

                return BLLCreator.Create<OutStockBLL>(t).SaveSortingLocation(locationCode, sortingLocations);
            });
        }
        #endregion

        #region 取整托分拣数据
        /// <summary>
        /// 取整托分拣数据
        /// </summary>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        public OperateResult GetSortingFull(string locationCode)
        {
            return ValidateToken(t =>
            {
                string fullArea = Util.ToString(ConfigurationManager.AppSettings["FullArea"]);
                var locations = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetList(new
                {
                    CN_S_AREA_CODE = fullArea,
                });
                if (!locations.Exists(e => e.CN_S_LOCATION_CODE == locationCode))
                    return OperateResult.Error("请扫描整托分拣台的货位");

                var sortingLocations = BLLCreator.Create<OutStockBLL>().GetSortingLocation(locationCode);

                if (!sortingLocations.Any())
                    return OperateResult.Error("未找到该货位需要分拣的物料");

                if (!sortingLocations.FindAll(f => f.CN_F_PICKED_QTY == 0).Any())
                    return OperateResult.Error("该货位已分拣完");

                var trayLocation = BLLCreator.CreateDapper<TN_WM_B_TRAY_LOCATIONEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = locationCode
                });
                if (trayLocation == null)
                    return OperateResult.Error("当前货位不存在物料");
                if (trayLocation.CN_S_TRAY_CODE != sortingLocations[0].CN_S_TRAY_CODE)
                    return OperateResult.Error("当前货位已存在容器：" + trayLocation.CN_S_TRAY_CODE);

                var res = sortingLocations.GroupBy(g => new
                {
                    g.CN_S_ITEM_CODE,
                    g.CN_S_ITEM_NAME,
                    g.CN_S_MEASURE_UNIT,
                }).Select(s => new
                {
                    CN_S_ITEM_CODE = s.Key.CN_S_ITEM_CODE,
                    CN_S_ITEM_NAME = s.Key.CN_S_ITEM_NAME,
                    CN_S_MEASURE_UNIT = s.Key.CN_S_MEASURE_UNIT,
                    CN_F_QUANTITY = s.Sum(m => m.CN_F_QUANTITY)
                });

                return OperateResult.Succeed(null, res);
            });
        }
        #endregion



        #region 公共方法
        /// <summary>
        /// 获取扫描物料实体信息
        /// </summary>
        /// <param name="itemCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetItemDetail(string itemCode)
        {
            try
            {
                AutoBomItemEntity entity = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItem(itemCode);
                if (entity == null)
                {
                    return JsonConvert.SerializeObject(OperateResult.Error("未找到该物料信息"));
                }
                else
                {
                    return JsonConvert.SerializeObject(OperateResult.Succeed(null, entity));
                }
            }
            catch (Exception ex)
            {
                Log.Error("GetItemDetail异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }
        /// <summary>
        /// 根据作业区类型获取库区列表
        /// </summary>
        /// <param name="areaClass">作业区类型</param>
        /// <returns></returns>
        [HttpGet]
        public string GetAreaByAreaClass(string areaClass)
        {
            try
            {
                return ValidateToken(x =>
                {
                    if (string.IsNullOrEmpty(areaClass))
                    {
                        return JsonConvert.SerializeObject(OperateResult.Error("请提供作业区类型！"));
                    }
                    List<AutoBomStockAreaEntity> areaModel = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetAreaByAreaClass(areaClass);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", areaModel));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }

        /// <summary>
        /// 通过多个作业区类型获取库区集合
        /// </summary>
        /// <param name="areaClass"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetAreaByManyClass(string areasClass)
        {
            try
            {
                return ValidateToken(x =>
                {
                    if (string.IsNullOrEmpty(areasClass))
                    {
                        return JsonConvert.SerializeObject(OperateResult.Error("请提供作业区类型！"));
                    }
                    List<AutoBomStockAreaEntity> areaModel = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetAreaByManyClass(areasClass);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", areaModel));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }

        /// <summary>
        /// 获取扫描物料实体信息
        /// </summary>
        /// <param name="itemCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetAllItemList(string itemCode)
        {
            try
            {
                List<AutoBomItemEntity> lstEntity = BLLCreator.Create<TN_WMS_ITEMBLL>().GetAllItem(itemCode);
                return JsonConvert.SerializeObject(OperateResult.Succeed(null, lstEntity));
            }
            catch (Exception ex)
            {
                Log.Error("GetItemList异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }
        /// <summary>
        /// 获取扫描物料实体信息
        /// </summary>
        /// <param name="itemCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetItemList(string itemCode)
        {
            try
            {
                List<string> itemArray = new List<string>();
                if (!string.IsNullOrEmpty(itemCode))
                {
                    itemArray = itemCode.Split(',').ToList();
                }
                var list = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItemList(itemArray);
                return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
            }
            catch (Exception ex)
            {

                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        /// <summary>
        /// 扫描条码 返回条码实体
        /// </summary>
        /// <param name="tokenId">token值</param>
        /// <param name="barCode">扫描条码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        [HttpGet]
        public string AnalysisCode(string barCode)
        {
            try
            {
                ScanCodeClass ScanCodeClass = BLLCreator.Create<MONGO_KEYTYPE_MAPBLL>().AnalysisCode(barCode);
                if (ScanCodeClass == null) return JsonConvert.SerializeObject(OperateResult.Error("找不到物料！请确认MONGO_KEYTYPE_MAP表存在该条码信息"));
                return JsonConvert.SerializeObject(OperateResult.Succeed("", ScanCodeClass));
            }
            catch (Exception ex)
            {
                Log.Error("AnalysisCode异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error("AnalysisCode方法 Exception！" + ex.ToString()));
            }

        }

        #endregion

        #region 码盘相关接口
        /// <summary>
        /// 检查托盘是否可用
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult CheckMpTray(string trayCode)
        {
            try
            {
                OperateResult result = BLLCreator.Create<HkBLL>().CheckMpTray(trayCode);

                return result;

            }
            catch (Exception ex)
            {
                Log.Error("CheckMpTray异常:====>", ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message);
            }
        }
        /// <summary>
        /// 检查货位是否可用
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult CheckMpLocation(string locationCode)
        {
            try
            {
                OperateResult result = BLLCreator.Create<HkBLL>().CheckMpLocation(locationCode);
                return result;

            }
            catch (Exception ex)
            {
                Log.Error("CheckMpLocation异常:====>", ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message);
            }
        }
        /// <summary>
        /// 检查唯一码是否已经码盘
        /// </summary>
        /// <param name="uniCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string CheckMpUniCode(string uniCode)
        {
            try
            {
                List<TN_WM_B_TRAY_ITEM_DTLEntity> lstDTLEntity = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_ITEM_DTLEntity>>().GetList(new { CN_S_UNIQUE_CODE = uniCode });
                if (lstDTLEntity.Any())
                {
                    return JsonConvert.SerializeObject(OperateResult.Error("该唯一码已码盘，不允许重复码盘"));
                }
                else
                {
                    return JsonConvert.SerializeObject(OperateResult.Succeed());
                }
            }
            catch (Exception ex)
            {
                Log.Error("CheckUniCode异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }

        /// <summary>
        /// 获取托盘中的物料信息
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetTrayDetail(string trayCode)
        {
            try
            {
                OperateResult result = new OperateResult();
                DataTable dt = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayDetail(trayCode);
                return JsonConvert.SerializeObject(OperateResult.Succeed("", dt));
            }
            catch (Exception ex)
            {
                Log.Error("GetTrayDetail异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }
        /// <summary>
        /// 获取可码盘入库单列表
        /// </summary>
        /// <param name="CN_S_OP_NO">模糊查询条件：入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-12-5</History>
        [HttpGet]
        public string GetInListWithCodedisc(string opNo)
        {
            try
            {

                List<TN_WM_INCREASE_INVENTORY_MSTEntity> list = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetInListWithCodedisc(opNo);
                return JsonConvert.SerializeObject(OperateResult.Succeed("", list));

            }
            catch (Exception ex)
            {
                Log.Error("GetInListWithCodedisc异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }

        /// <summary>
        /// 根据单号获取主子表信息
        /// </summary>
        /// <param name="opNo">模糊查询条件：入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-19</History>
        [HttpGet]
        public string GetIncreaseDetail(string opNo)
        {
            try
            {
                DataTable dt = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetIncreaseDetail(opNo);
                return JsonConvert.SerializeObject(OperateResult.Succeed("", dt));
            }
            catch (Exception ex)
            {
                Log.Error("GetIncreaseDetail异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        /// <summary>
        /// 码盘
        /// </summary>
        /// <param name="tokenId">token验证值</param>
        /// <param name="jsonData">数据Json</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-17</History>
        [HttpPost]
        public string SaveSimPalletItemRelation(JObject jsonData)
        {
            try
            {
                ItemOnTrayEntity entity = JsonConvert.DeserializeObject<ItemOnTrayEntity>(jsonData.ToString());
                return ValidateToken(entity.TokenId, t =>
                {
                    OperateResult oresult = BLLCreator.Create<HkBLL>(t).SaveSimPalletItemRelation(entity, t);
                    if (oresult.Success)
                    {
                        if (!entity.BIND_TRAY_LOCATION)
                        {
                            if (!string.IsNullOrEmpty(entity.CN_S_LOCATION_CODE))
                            {
                                oresult = BLLCreator.Create<HkBLL>(t).AddTrayLocationRelation(entity.CN_S_TRAY_CODE, entity.CN_S_LOCATION_CODE, t, entity.PROJECT_CODE);
                                if (oresult.Success)
                                {
                                    if (entity.CODE_IN_TASK == "Y")
                                    {
                                        TrayOnShelfEntity trayOnShelf = new TrayOnShelfEntity();
                                        trayOnShelf.CN_S_DEVICE_NO = entity.CN_S_LOCATION_CODE;
                                        trayOnShelf.CN_S_END_AREA_CODE = entity.CN_S_END_AREA_CODE;
                                        trayOnShelf.CN_S_LOCATION_CODE = "";
                                        trayOnShelf.CN_S_TASK_TYPE = entity.CN_S_TASK_TYPE;
                                        trayOnShelf.CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE;
                                        trayOnShelf.projectCode = entity.PROJECT_CODE;
                                        oresult = BLLCreator.Create<HkBLL>().SimZTShelfAuto(trayOnShelf, t);
                                        if (!oresult.Success)
                                        {
                                            oresult.Msg = "码盘成功但入库失败：" + oresult.Msg;
                                        }
                                    }
                                }
                                else
                                {
                                    oresult.Msg = "码盘成功但绑定货位失败：" + oresult.Msg;
                                }
                            }
                        }
                        else
                        {
                            if (entity.CODE_IN_TASK == "Y")
                            {
                                TrayOnShelfEntity trayOnShelf = new TrayOnShelfEntity();
                                trayOnShelf.CN_S_DEVICE_NO = entity.CN_S_LOCATION_CODE;
                                trayOnShelf.CN_S_END_AREA_CODE = entity.CN_S_END_AREA_CODE;
                                trayOnShelf.CN_S_LOCATION_CODE = "";
                                trayOnShelf.CN_S_TASK_TYPE = entity.CN_S_TASK_TYPE;
                                trayOnShelf.CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE;
                                trayOnShelf.projectCode = entity.PROJECT_CODE;
                                oresult = BLLCreator.Create<HkBLL>().SimZTShelfAuto(trayOnShelf, t);
                                if (!oresult.Success)
                                {
                                    oresult.Msg = "码盘成功但入库失败：" + oresult.Msg;
                                }
                            }
                        }
                    }
                    else
                    {
                        oresult.Msg = "码盘失败：" + oresult.Msg;
                    }
                    return JsonConvert.SerializeObject(oresult);

                });
            }
            catch (Exception ex)
            {
                Log.Error("SaveSimPalletItemRelation异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        /// <summary>
        /// 码盘
        /// </summary>
        /// <param name="tokenId">token验证值</param>
        /// <param name="jsonData">数据Json</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-17</History>
        [HttpPost]
        public string SaveUniPalletItemRelation(JObject jsonData)
        {
            try
            {
                ItemOnTrayEntity entity = JsonConvert.DeserializeObject<ItemOnTrayEntity>(jsonData.ToString());
                return ValidateToken(entity.TokenId, t =>
                {
                    OperateResult oresult = BLLCreator.Create<HkBLL>(t).SaveUniPalletItemRelation(entity, t);
                    if (oresult.Success)
                    {
                        if (!entity.BIND_TRAY_LOCATION)
                        {
                            if (!string.IsNullOrEmpty(entity.CN_S_LOCATION_CODE))
                            {
                                oresult = BLLCreator.Create<HkBLL>(t).AddTrayLocationRelation(entity.CN_S_TRAY_CODE, entity.CN_S_LOCATION_CODE, t, entity.PROJECT_CODE);
                                if (oresult.Success)
                                {
                                    if (entity.CODE_IN_TASK == "Y")
                                    {
                                        TrayOnShelfEntity trayOnShelf = new TrayOnShelfEntity();
                                        trayOnShelf.CN_S_DEVICE_NO = entity.CN_S_LOCATION_CODE;
                                        trayOnShelf.CN_S_END_AREA_CODE = entity.CN_S_END_AREA_CODE;
                                        trayOnShelf.CN_S_LOCATION_CODE = "";
                                        trayOnShelf.CN_S_TASK_TYPE = entity.CN_S_TASK_TYPE;
                                        trayOnShelf.CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE;
                                        trayOnShelf.projectCode = entity.PROJECT_CODE;
                                        oresult = BLLCreator.Create<HkBLL>().SimZTShelfAuto(trayOnShelf, t);
                                        if (!oresult.Success)
                                        {
                                            oresult.Msg = "码盘成功但入库失败：" + oresult.Msg;
                                        }
                                    }
                                }
                                else
                                {
                                    oresult.Msg = "码盘成功但绑定货位失败：" + oresult.Msg;
                                }
                            }
                        }
                        else
                        {
                            if (entity.CODE_IN_TASK == "Y")
                            {
                                TrayOnShelfEntity trayOnShelf = new TrayOnShelfEntity();
                                trayOnShelf.CN_S_DEVICE_NO = entity.CN_S_LOCATION_CODE;
                                trayOnShelf.CN_S_END_AREA_CODE = entity.CN_S_END_AREA_CODE;
                                trayOnShelf.CN_S_LOCATION_CODE = "";
                                trayOnShelf.CN_S_TASK_TYPE = entity.CN_S_TASK_TYPE;
                                trayOnShelf.CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE;
                                trayOnShelf.projectCode = entity.PROJECT_CODE;
                                oresult = BLLCreator.Create<HkBLL>().SimZTShelfAuto(trayOnShelf, t);
                                if (!oresult.Success)
                                {
                                    oresult.Msg = "码盘成功但入库失败：" + oresult.Msg;
                                }
                            }
                        }
                    }
                    else
                    {
                        oresult.Msg = "码盘失败：" + oresult.Msg;
                    }
                    return JsonConvert.SerializeObject(oresult);
                });
            }
            catch (Exception ex)
            {
                Log.Error("SaveUniPalletItemRelation异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        /// <summary>
        /// 码盘
        /// </summary>
        /// <param name="tokenId">token验证值</param>
        /// <param name="jsonData">数据Json</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-17</History>
        [HttpPost]
        public string SaveRkdPalletItemRelation(JObject jsonData)
        {
            try
            {
                ItemOnTrayEntity entity = JsonConvert.DeserializeObject<ItemOnTrayEntity>(jsonData.ToString());
                return ValidateToken(entity.TokenId, t =>
                {
                    OperateResult oresult = BLLCreator.Create<HkBLL>(t).SaveRkdPalletItemRelation(entity, t);
                    if (oresult.Success)
                    {
                        if (!entity.BIND_TRAY_LOCATION)
                        {
                            if (!string.IsNullOrEmpty(entity.CN_S_LOCATION_CODE))
                            {
                                oresult = BLLCreator.Create<HkBLL>(t).AddTrayLocationRelation(entity.CN_S_TRAY_CODE, entity.CN_S_LOCATION_CODE, t, entity.PROJECT_CODE);
                                if (oresult.Success)
                                {
                                    if (entity.CODE_IN_TASK == "Y")
                                    {
                                        TrayOnShelfEntity trayOnShelf = new TrayOnShelfEntity();
                                        trayOnShelf.CN_S_DEVICE_NO = entity.CN_S_LOCATION_CODE;
                                        trayOnShelf.CN_S_END_AREA_CODE = entity.CN_S_END_AREA_CODE;
                                        trayOnShelf.CN_S_LOCATION_CODE = "";
                                        trayOnShelf.CN_S_TASK_TYPE = entity.CN_S_TASK_TYPE;
                                        trayOnShelf.CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE;
                                        trayOnShelf.projectCode = entity.PROJECT_CODE;
                                        oresult = BLLCreator.Create<HkBLL>().SimZTShelfAuto(trayOnShelf, t);
                                        if (!oresult.Success)
                                        {
                                            oresult.Msg = "码盘成功但入库失败：" + oresult.Msg;
                                        }
                                    }
                                }
                                else
                                {
                                    oresult.Msg = "码盘成功但绑定货位失败：" + oresult.Msg;
                                }
                            }
                        }
                        else
                        {
                            if (entity.CODE_IN_TASK == "Y")
                            {
                                TrayOnShelfEntity trayOnShelf = new TrayOnShelfEntity();
                                trayOnShelf.CN_S_DEVICE_NO = entity.CN_S_LOCATION_CODE;
                                trayOnShelf.CN_S_END_AREA_CODE = entity.CN_S_END_AREA_CODE;
                                trayOnShelf.CN_S_LOCATION_CODE = "";
                                trayOnShelf.CN_S_TASK_TYPE = entity.CN_S_TASK_TYPE;
                                trayOnShelf.CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE;
                                trayOnShelf.projectCode = entity.PROJECT_CODE;
                                oresult = BLLCreator.Create<HkBLL>().SimZTShelfAuto(trayOnShelf, t);
                                if (!oresult.Success)
                                {
                                    oresult.Msg = "码盘成功但入库失败：" + oresult.Msg;
                                }
                            }
                        }
                    }
                    else
                    {
                        oresult.Msg = "码盘失败：" + oresult.Msg;
                    }
                    return JsonConvert.SerializeObject(oresult);
                });
            }
            catch (Exception ex)
            {
                Log.Error("SavePalletItemRelation异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }


        #endregion

        #region 绑定解绑相关接口
        /// <summary>
        /// 获取托盘中的物料信息
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetBindTrayDetail(string trayCode, string locationCode, string projectCode)
        {
            try
            {
                OperateResult result = new OperateResult();
                string returnJson = string.Empty;
                DataTable dt = new DataTable();
                if (!string.IsNullOrEmpty(trayCode))
                {
                    List<TN_WM_B_TRAY_LOCATIONEntity> lstEntity = DALCreator.Create<TN_WM_B_TRAY_LOCATIONDAL>().GetListByTrayCode(trayCode);
                    dt = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemDetail(trayCode);
                    //判断托盘是否绑定了货位
                    if (lstEntity.Count == 0)
                    {
                        returnJson = JsonConvert.SerializeObject(OperateResult.Succeed("", dt));
                    }
                    else
                    {
                        returnJson = JsonConvert.SerializeObject(OperateResult.Succeed(lstEntity[0].CN_S_LOCATION_CODE, dt));
                    }

                }
                if (!string.IsNullOrEmpty(locationCode))
                {
                    List<TN_WM_B_TRAY_LOCATIONEntity> lstEntity = DALCreator.Create<TN_WM_B_TRAY_LOCATIONDAL>().GetListByLocationCode(locationCode);
                    if (lstEntity.Count == 0)
                    {
                        returnJson = JsonConvert.SerializeObject(OperateResult.Succeed("", dt));
                    }
                    else
                    {
                        dt = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemDetail(lstEntity[0].CN_S_TRAY_CODE);
                        returnJson = JsonConvert.SerializeObject(OperateResult.Succeed(lstEntity[0].CN_S_TRAY_CODE, dt));
                    }
                }
                return returnJson;
            }
            catch (Exception ex)
            {
                Log.Error("GetBindTrayDetail异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }


        /// <summary>
        /// 绑定货位等同入库，增加仓库、库区库存
        /// </summary>
        /// <param name="trayCode">托盘编码</param>
        /// <param name="locationCode">货位编码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-04-17</History>
        [HttpGet]
        public string AddTrayLocationRelation(string trayCode, string locationCode, string projectCode)
        {
            try
            {
                return ValidateToken(t =>
                {
                    OperateResult result = BLLCreator.Create<HkBLL>(t).AddTrayLocationRelation(trayCode, locationCode, t, projectCode);

                    return JsonConvert.SerializeObject(result);
                });
            }
            catch (Exception ex)
            {
                Log.Error("AddTrayLocationRelation异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }

        /// <summary>
        /// 绑定货位等同出库，减少仓库、库区库存
        /// </summary>
        /// <param name="trayCode">托盘编码</param>
        /// <param name="locationCode">货位编码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-04-17</History>
        [HttpGet]
        public string DeleteTrayLocationRelation(string trayCode, string locationCode, string projectCode)
        {
            try
            {
                return ValidateToken(t =>
               {
                    OperateResult result = BLLCreator.Create<HkBLL>(t).DeleteTrayLocationRelation(trayCode, locationCode, t, projectCode);
                    return JsonConvert.SerializeObject(result);
                });
            }
            catch (Exception ex)
            {
                Log.Error("DeleteTrayLocationRelation异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        /// <summary>
        /// 托盘货位绑定
        /// </summary>
        /// <param name="trayCode">托盘编码</param>
        /// <param name="locationCode">货位编码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-04-17</History>
        [HttpPost]
        public string LoadAndUnload(LocationTrayItmRelEntity entity)
        {
            try
            {
                return ValidateToken(entity.TokenId, t =>
                {
                    OperateResult result = BLLCreator.Create<HkBLL>(t).LoadAndUnload(entity, t);

                    return JsonConvert.SerializeObject(result);
                });
            }
            catch (Exception ex)
            {
                Log.Error("LoadAndUnload异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        #endregion

        #region 整托上架入库相关接口
        /// <summary>
        /// 整托获取建议货位-空货位
        /// </summary>
        /// <param name="areaCode">库区</param>
        /// <param name="trayCode">托盘编码</param>
        /// <param name="itemCode">物料编码</param>
        /// <param name="locationQty">获取货位的数量</param>
        /// <param name="tokenId">tokenId</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetZtEmptyCommandLocation(string areaCode, string trayCode, string itemCode, int locationQty)
        {
            try
            {
                //调用入库算法，获取空货位
                InAlgorEnitty iAe = new InAlgorEnitty()
                {
                    stockAreaCode = areaCode,
                    logicCode = "",
                    locationQty = locationQty,
                    trayCode = trayCode,
                    itemCode = itemCode,
                    lockLocation = false//是否需要锁定货位
                };
                iAe.lstDevice = null;
                InResultEntity irEresult = BLLCreator.Create<In_AlgorBLL>().In(iAe);
                if (!irEresult.Success)
                {
                    return OperateResult.Error(irEresult.Msg);//货位获取失败！
                }
                return OperateResult.Succeed("", irEresult.lstLocation);
            }
            catch (Exception ex)
            {
                Log.Error("GetZtEmptyCommandLocation异常:====>", ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message);
            }
        }

        /// <summary>
        /// 检查货位是否可用
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string CheckInStockLocation(string locationCode)
        {
            try
            {
                OperateResult result = BLLCreator.Create<HkBLL>().CheckInStockLocation(locationCode);

                return JsonConvert.SerializeObject(result);

            }
            catch (Exception ex)
            {
                Log.Error("CheckInStockLocation异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }
        /// <summary>
        /// 检查托盘是否可用
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string CheckInStockTray(string trayCode)
        {
            try
            {
                OperateResult result = BLLCreator.Create<HkBLL>().CheckInStockTray(trayCode);

                return JsonConvert.SerializeObject(result);

            }
            catch (Exception ex)
            {
                Log.Error("CheckInStockTray异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }

        /// <summary>
        /// 整托执行上架 宇寿
        /// </summary>
        /// <param name="json">数据Json</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-12-12</History>
        [HttpPost]
        public OperateResult SimZTShelfAuto(JObject json)
        {
            try
            {
                Log.Info("整托上架开始", "");
                TrayOnShelfEntity entity = JsonConvert.DeserializeObject<TrayOnShelfEntity>(json.ToString());
                return ValidateToken(entity.TokenId, t =>
                {
                    if (t == null)
                    {
                        return OperateResult.Error("登陆人员信息获取失败！");
                    }

                    return BLLCreator.Create<HkBLL>().SimZTShelfAuto(entity, t);
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message.ToString());
            }
        }
        /// <summary>
        /// 整托执行上架 宇寿
        /// </summary>
        /// <param name="json">数据Json</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-12-12</History>
        [HttpPost]
        public OperateResult SimZTShelfAutoWithBind(JObject json)
        {
            try
            {
                Log.Info("整托上架开始", "");
                TrayOnShelfEntity entity = JsonConvert.DeserializeObject<TrayOnShelfEntity>(json.ToString());
                return ValidateToken(entity.TokenId, t =>
                {
                    if (t == null)
                    {
                        return OperateResult.Error("登陆人员信息获取失败！");
                    }
                    OperateResult oresult = new OperateResult();
                    if (!entity.BIND_TRAY_LOCATION)
                    {
                        oresult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>(t).AddTrayLocationRelation(entity.CN_S_TRAY_CODE, entity.CN_S_DEVICE_NO, t, entity.projectCode);
                        if (oresult.Success)
                        {
                            oresult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().SimZTShelfAuto(entity, t);
                        }
                    }
                    else
                    {
                        oresult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().SimZTShelfAuto(entity, t);
                    }

                    return oresult;
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message.ToString());
            }
        }

        #endregion

        #region 生成流转任务
        /// <summary>
        /// 生成流转任务(朝阳)
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        /// <history>[HanHe(XDL)] CREATED 2018/6/30</history>
        [HttpGet]
        public string CreateTransTask(string startPosition, string endPosition, string tranType, string taskPriority, string projectCode)
        {
            Log.Info("调用CreateTransTask", "请求参数：startPosition" + startPosition.ToString() + "; endPosition" + endPosition.ToString() + "; tranType" + tranType.ToString() + "; taskPriority" + taskPriority.ToString());
            try
            {
                return ValidateToken(t =>
                {
                    OperateResult result = BLLCreator.Create<HkBLL>(t).CreateTransTask(startPosition, endPosition, tranType, taskPriority, projectCode, t);

                    return JsonConvert.SerializeObject(result);
                });
            }
            catch (Exception ex)
            {
                Log.Error("CreateTransTask异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }

        #endregion

        #region 整托叫料相关接口



        /// <summary>
        /// 叫料获取可出库货位
        /// </summary>
        /// <param name="areaCode">库区</param>
        /// <param name="trayCode">托盘编码</param>
        /// <param name="itemCode">物料编码</param>
        /// <param name="locationQty">获取货位的数量</param>
        /// <param name="tokenId">tokenId</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetZtFullCommandLocation(string stockCode, string areaCode, string itemCode, decimal locationQty, string traySpec)
        {
            try
            {

                List<areaPriorClass> lstArea = new List<areaPriorClass>();
                areaPriorClass areaClass = new areaPriorClass();
                areaClass.areaCode = areaCode;
                areaClass.Prior = 1;
                lstArea.Add(areaClass);
                //调用出库算法，获取出库货位
                OutAssignEnitty oAe = new OutAssignEnitty()
                {
                    lstAreaPrior = lstArea,
                    stockCode = stockCode,
                    itemCode = itemCode,
                    traySpec = traySpec,
                    lockLocation = false,//是否需要锁定货位
                    needCalLock = false

                };
                OutAssignResultEntity oaEresult = BLLCreator.Create<Out_AlgorBLL>().OutAssign(oAe);
                if (!oaEresult.Success)
                {
                    return OperateResult.Error(oaEresult.Msg);//货位获取失败！
                }
                return OperateResult.Succeed("", oaEresult);
            }
            catch (Exception ex)
            {
                Log.Error("GetZtFullCommandLocation异常:====>", ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message);
            }
        }
        /// <summary>
        /// 整托执行上架
        /// </summary>
        /// <param name="json">数据Json</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-12-12</History>
        [HttpPost]
        public OperateResult SimZTDownShelfAuto(JObject json)
        {
            try
            {
                Log.Info("整托下架开始", "");
                TrayOnShelfEntity entity = JsonConvert.DeserializeObject<TrayOnShelfEntity>(json.ToString());
                return ValidateToken(entity.TokenId, t =>
                {
                    if (t == null)
                    {
                        return OperateResult.Error("登陆人员信息获取失败！");
                    }

                    return BLLCreator.Create<HkBLL>().SimZTDownShelfAuto(entity, t);
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message.ToString());
            }
        }
        #endregion

        #region 分拣相关接口




        #region (PDA)获取的分拣单
        /// <summary>
        /// (PDA)获取的分拣单
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetCurrentSorting(string tokenId, string sortingNo = "")
        {
            return ValidateToken(tokenId, t =>
            {
                TN_WM_SORTING_LISTEntity sortingEntity = new TN_WM_SORTING_LISTEntity();
                sortingEntity.SortingLocationList = new List<TN_WM_SORTING_LOCATIONEntity>();
                if (!string.IsNullOrEmpty(sortingNo))
                {
                    sortingEntity = BLLCreator.Create<DapperBLL<TN_WM_SORTING_LISTEntity>>().GetSingleEntity(new
                    {
                        CN_S_SORTING_NO = sortingNo
                    });
                    if (sortingEntity == null)
                        return OperateResult.Error("未找到分拣单：" + sortingNo);
                }
                else
                {
                    sortingEntity = BLLCreator.Create<DapperBLL<TN_WM_SORTING_LISTEntity>>().GetSingleEntity(new
                    {
                        CN_S_STATE = Constants.Sorting_Being
                    });
                    if (sortingEntity == null)
                    {
                        sortingEntity = BLLCreator.Create<DapperBLL<TN_WM_SORTING_LISTEntity>>().GetSingleEntity(new
                        {
                            CN_S_STATE = new List<string>() { Constants.Sorting_Stay, Constants.Sorting_Being }
                        }, " ORDER BY CN_T_CREATE");
                        if (sortingEntity == null)
                        {
                            return OperateResult.Error("");
                        }
                    }
                }

                var sortingLocation = BLLCreator.Create<DapperBLL<TN_WM_SORTING_LOCATIONEntity>>().GetList(new
                {
                    CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO
                });
                sortingLocation = sortingLocation.GroupBy(x => new { x.CN_S_LOCATION_CODE, x.CN_S_TRAY_CODE })
                   .Select(y => new TN_WM_SORTING_LOCATIONEntity
                   {
                       CN_S_TRAY_CODE = y.Key.CN_S_TRAY_CODE,
                       CN_S_LOCATION_CODE = y.Key.CN_S_LOCATION_CODE,
                       CN_F_QUANTITY = y.Sum(z => z.CN_F_QUANTITY)
                   }).ToList();
                var sortingResult = BLLCreator.Create<DapperBLL<TN_WM_SORTING_RESULTEntity>>().GetList(new
                {
                    CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO
                });
                var result = new
                {
                    SortingNo = sortingEntity.CN_S_SORTING_NO,
                    //AreaCode = sortingEntity.CN_S_STOCK_AREA,
                    AreaCode = sortingEntity.CN_S_FROM_NO,
                    SortingState = sortingEntity.CN_S_STATE,
                    LocationItems = sortingLocation.Select(x => new
                    {
                        TrayCode = x.CN_S_TRAY_CODE,
                        LocationCode = x.CN_S_LOCATION_CODE,
                        PickNum = x.CN_F_QUANTITY,
                        PickedNum = sortingResult.Where(y => y.CN_S_LOCATION_CODE.Equals(x.CN_S_LOCATION_CODE)).Sum(z => z.CN_F_QUANTITY),
                        PickState = sortingResult.Where(y => y.CN_S_LOCATION_CODE.Equals(x.CN_S_LOCATION_CODE)).Sum(z => z.CN_F_QUANTITY) == x.CN_F_QUANTITY ? "已拣" : "未拣"//暂时赋值
                    }).Where(m => m.PickState != "已拣")
                };
                return OperateResult.Succeed(null, result);
            });
        }
        #endregion

        #region (PDA)执行分拣单
        /// <summary>
        /// (PDA)执行分拣单
        /// </summary>
        /// <param name="sortingNo"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult SimAutoExecuteSorting(string tokenId, string sortingNo, string area = "")
        {
            return ValidateToken(tokenId, t =>
            {
                var sortingEntity = BLLCreator.Create<DapperBLL<TN_WM_SORTING_LISTEntity>>().GetSingleEntity(new
                {
                    CN_S_SORTING_NO = sortingNo
                });
                if (sortingEntity == null)
                    return OperateResult.Error("未找到分拣单：" + sortingNo);
                if (sortingEntity.CN_S_STATE != Constants.Sorting_Stay)
                    return OperateResult.Error("当前分拣单不是待分拣，请重新选择");
                #region 生成分拣明细

                var sortingLocationResult = BLLCreator.Create<DapperBLL<TN_WM_SORTING_LOCATIONEntity>>().GetList(new
                {
                    CN_S_SORTING_NO = sortingNo
                });

                sortingEntity.SortingLocationList.AddRange(sortingLocationResult);
                #endregion
                var trayItem = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
                #region 自动库需要生成出库任务

                //生成任务
                List<string> endAreas = new List<string>();
                var outTaskResult = BLLCreator.Create<TN_WM_SORTING_LISTBLL>(t).GetOutTask(ref sortingEntity, ref endAreas, "", area);

                if (!outTaskResult.Success)
                {
                    return outTaskResult;
                }
                var tasks = outTaskResult.GetData<List<TN_WM_TASKEntity>>();
                sortingEntity.Tasks = tasks;
                sortingEntity.EndBits = endAreas;

                #endregion

                var result = BLLCreator.Create<TN_WM_SORTING_LISTBLL>().ExecuteSorting(sortingEntity, trayItem);

                if (!result.Success)
                    return result;


                return result;
            });
        }
        #endregion

        #region (PDA)根据分拣单获取波次下所有发货通知单和分拣明细
        /// <summary>
        /// (PDA汇聚)根据分拣单获取波次下所有发货通知单和分拣明细
        /// </summary>
        /// <param name="sortingNo"></param>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetSimAutoSortingData(string sortingNo, string locationCode)
        {
            return ValidateToken(t =>
            {
                var sortingEntity = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetSingleEntity(new
                {
                    CN_S_SORTING_NO = sortingNo
                });
                if (sortingEntity == null)
                    return OperateResult.Error("未找到分拣单：" + sortingNo);
                //当前分拣单当前货位
                var currentSortingLocation = BLLCreator.CreateDapper<TN_WM_SORTING_LOCATIONEntity>().GetList(new
                {
                    CN_S_SORTING_NO = sortingNo,
                    CN_S_LOCATION_CODE = locationCode
                });
                //当前分拣单波次下所有出库单
                var currentWaveOut = BLLCreator.Create<TN_WM_OUT_MSTBLL>().GetOutListByWave(sortingEntity.CN_S_FROM_NO);
                //订单拣货数据
                var orderSortingRels = BLLCreator.CreateDapper<TN_WM_ORDER_SORTING_RELEntity>().GetList(new
                {
                    CN_S_ORDER_NO = currentWaveOut.Select(s => s.CN_S_OP_NO).ToList()
                });

                //批分每个出库单每个物料拣了多少个
                foreach (var currentOut in currentWaveOut)
                {
                    var curOrderSorting = orderSortingRels.Where(s => s.CN_S_ORDER_NO == currentOut.CN_S_OP_NO);

                    foreach (var currentOutDtl in currentOut.OutDtlList)
                    {
                        var equalsCurOS = curOrderSorting.Where(w =>
                        w.CN_S_ITEM_CODE == currentOutDtl.CN_S_ITEM_CODE &&
                        w.CN_S_ITEM_STATE == currentOutDtl.CN_S_ITEM_STATE &&
                        w.CN_S_OWNER == currentOut.CN_S_OWNER &&
                        (w.CN_S_LOT_NO == currentOutDtl.CN_S_LOT_CODE || string.IsNullOrEmpty(currentOutDtl.CN_S_LOT_CODE)));
                        foreach (var curOS in equalsCurOS)
                        {
                            var qty = currentOutDtl.CN_F_QUANTITY - currentOutDtl.CN_F_PICKED_QTY;
                            if (qty == 0) break;
                            if (curOS.CN_F_QUANTITY == 0) continue;
                            if (curOS.CN_F_QUANTITY >= qty)
                            {
                                currentOutDtl.CN_F_PICKED_QTY += qty;
                                curOS.CN_F_QUANTITY -= qty;
                            }
                            else
                            {
                                currentOutDtl.CN_F_PICKED_QTY += curOS.CN_F_QUANTITY;
                                curOS.CN_F_QUANTITY = 0;
                            }
                        }
                    }
                }
                var result = new
                {
                    SortingLocations = currentSortingLocation,
                    OutData = currentWaveOut,
                    SortingBit = new string[] { "FJT01", "FJT02", "FJT03", "FJT04", }
                };

                return OperateResult.Succeed(null, result);
            });
        }
        #endregion

        #region (PDA)保存一单一播
        /// <summary>
        /// (PDA汇聚)保存边拣边播
        /// </summary>
        /// <param name="saveData"></param>
        /// <returns></returns>
        public OperateResult SimSaveAutoSort(dynamic saveData)
        {
            string tokenId = Util.ToString(saveData.tokenId);
            return ValidateToken(tokenId, t =>
            {
                Log.Info("保存边拣边播SaveBJBB", JsonConvert.SerializeObject(saveData));
                //分拣结果
                List<TN_WM_SORTING_RESULTEntity> sortingResult = JsonConvert.DeserializeObject<List<TN_WM_SORTING_RESULTEntity>>(Util.ToString(saveData.SortingResult));
                if (!sortingResult.Any())
                    return OperateResult.Error("分拣结果数据不可为空");

                List<TN_WM_ORDER_SORTING_RELEntity> orderSortingRel = JsonConvert.DeserializeObject<List<TN_WM_ORDER_SORTING_RELEntity>>(Util.ToString(saveData.OrderSortingRel));
                if (!orderSortingRel.Any())
                    return OperateResult.Error("订单拣货明细不可为空");

                //周转箱号
                string boxNo = Util.ToString(saveData.BoxNo);
                if (string.IsNullOrEmpty(boxNo))
                    return OperateResult.Error("合箱容器号不可为空");

                var sortingLocations = BLLCreator.CreateDapper<TN_WM_SORTING_LOCATIONEntity>().GetList(new
                {
                    CN_S_SORTING_NO = sortingResult[0].CN_S_SORTING_NO,
                });

                var pickedItemLocations = sortingLocations.Where(w =>
                w.CN_S_TRAY_CODE == sortingResult[0].CN_S_TRAY_CODE &&
                w.CN_S_LOCATION_CODE == sortingResult[0].CN_S_LOCATION_CODE &&
                sortingResult.Exists(e => e.CN_S_ITEM_CODE == w.CN_S_ITEM_CODE)).ToList();

                //批分分拣明细分拣数量
                foreach (var sr in sortingResult)
                {
                    foreach (var pickedItem in pickedItemLocations)
                    {
                        if (sr.CN_F_QUANTITY == 0) break;
                        var stayQty = pickedItem.CN_F_QUANTITY - pickedItem.CN_F_PICKED_QTY;
                        if (stayQty == 0) continue;
                        if (sr.CN_F_QUANTITY >= stayQty)
                        {
                            pickedItem.CN_F_PICKED_QTY += stayQty;
                            sr.CN_F_QUANTITY -= stayQty;
                        }
                        else
                        {
                            pickedItem.CN_F_PICKED_QTY += sr.CN_F_QUANTITY;
                            sr.CN_F_QUANTITY = 0;
                        }
                    }
                }
                //分拣单,波次是否已分拣
                bool sortingPicked = false; bool wavePicked = false;
                //分拣单是否全部分拣完
                if (sortingLocations.Sum(s => s.CN_F_QUANTITY) == sortingLocations.Sum(s => s.CN_F_PICKED_QTY))
                    sortingPicked = true;
                //当前分拣单实体
                var currentSorting = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetSingleEntity(new
                {
                    CN_S_SORTING_NO = sortingResult[0].CN_S_SORTING_NO
                });

                #region 分拣单捡完了，判断波次有没有捡完
                //分拣单捡完了，判断波次有没有捡完
                if (sortingPicked)
                {
                    var waveSortings = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetList(new
                    {
                        CN_S_FROM_NO = currentSorting.CN_S_FROM_NO
                    });
                    if (!(waveSortings.Exists(e => e.CN_S_STATE != Constants.Sorting_Sorted)))
                        wavePicked = true;
                }
                #endregion

                #region 如果分拣单拣完了，批分库区降库存
                List<TN_WM_B_AREA_QTYEntity> areaQtyList = new List<TN_WM_B_AREA_QTYEntity>();
                //算法策略
                List<string> lstStrate = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().GetStrateListByAreaOrStock("", "", Constants.Out)
                     .OrderByDescending(a => a.CN_N_PRIORITY).Select(o => o.CN_S_CODE).ToList();
                Log.Info("确认分拣", "lstStrate");

                //分拣单都拣完了，批分库区降库存
                if (sortingPicked)
                {
                    Log.Info("确认分拣sortingResult", JsonConvert.SerializeObject(sortingResult));
                    if (currentSorting != null)
                    {
                        var currentSortingDtl = BLLCreator.CreateDapper<TN_WM_SORTING_DTLEntity>()
                            .GetList(new
                            {
                                CN_S_SORTING_NO = currentSorting.CN_S_SORTING_NO
                            });
                        currentSorting.SortingDtlList = currentSortingDtl;

                        areaQtyList = BLLCreator.CreateDapper<TN_WM_B_AREA_QTYEntity>().GetList(new
                        {
                            CN_S_ITEM_CODE = currentSortingDtl.Select(x => x.CN_S_ITEM_CODE).ToList()
                        });
                        //反批分库区分配量
                        Log.Info("确认分拣反批分库区分配量", "BatchesAreaQty");
                        var result = areaQtyList.BatchesAreaQty(new List<TN_WM_SORTING_LISTEntity>() { currentSorting }, lstStrate, true);
                        Log.Info("确认分拣反批分库区分配量结果", JsonConvert.SerializeObject(result));
                        if (!result.Success)
                            return result;
                    }
                }
                #endregion

                #region 批分托盘物料关联，降分配量，删子表，解货位
                //分拣结果的托盘物料关联数据
                var trayItemMstList = BLLCreator.Create<TN_WM_SORTING_LISTBLL>().BatchesTrayItemByResult(sortingResult);
                var currentTrayLocation = BLLCreator.CreateDapper<TN_WM_B_TRAY_LOCATIONEntity>().GetSingleEntity(new
                {
                    CN_S_TRAY_CODE = sortingResult[0].CN_S_TRAY_CODE
                });

                #endregion

                #region 初始化分拣结果，订单拣货明细实体

                sortingResult.ForEach(p =>
                {
                    p.CN_GUID = Guid.NewGuid().ToString();
                    p.CN_S_SERIAL_NO = p.CN_S_SERIAL_NO ?? "";
                    p.CN_S_TRAY_CODE = p.CN_S_TRAY_CODE ?? "";
                    p.CN_S_TURNOVERBOX_CODE = p.CN_S_TURNOVERBOX_CODE ?? boxNo;
                    p.CN_S_CREATOR = t.CN_S_LOGIN;
                    p.CN_S_CREATOR_BY = t.CN_S_NAME;
                    p.CN_T_CREATE = DateTime.Now;
                    p.CN_S_MODIFY = t.CN_S_LOGIN;
                    p.CN_S_MODIFY_BY = t.CN_S_NAME;
                    p.CN_T_MODIFY = DateTime.Now;
                });
                orderSortingRel.ForEach(p =>
                {
                    p.CN_GUID = Guid.NewGuid().ToString();
                    p.CN_S_SERIAL_NO = p.CN_S_SERIAL_NO ?? "";
                    p.CN_S_CREATOR = t.CN_S_LOGIN;
                    p.CN_S_CREATOR_BY = t.CN_S_NAME;
                    p.CN_T_CREATE = DateTime.Now;
                    p.CN_S_MODIFY = t.CN_S_LOGIN;
                    p.CN_S_MODIFY_BY = t.CN_S_NAME;
                    p.CN_T_MODIFY = DateTime.Now;
                });
                #endregion

                SavePickEntity savePickEntity = new SavePickEntity()
                {
                    CurrentSorting = currentSorting,
                    SortingPicked = sortingPicked,
                    WavePicked = wavePicked,
                    BoxNo = boxNo,
                    WaveNo = currentSorting.CN_S_FROM_NO,
                    SortingNo = currentSorting.CN_S_SORTING_NO,
                    SortingResult = sortingResult,
                    SortingLocation = pickedItemLocations,
                    OrderSortingRel = orderSortingRel,
                    TrayItemList = trayItemMstList,
                    TrayLocation = currentTrayLocation,
                    AreaQtyList = areaQtyList
                };

                return BLLCreator.Create<TN_WM_SORTING_LISTBLL>().SaveBJBB(savePickEntity);
            });
        }
        #endregion
        #endregion

        #region 上料相关接口


        /// <summary>
        /// 验证料箱码是否属于当前托盘
        /// </summary>
        /// <param name="trayCode"></param>
        /// <param name="uniqueCode"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult CheckUniqueIsCurTray(string trayCode, string uniqueCode)
        {
            bool result = BLLCreator.Create<HkBLL>().CheckUniqueIsCurTray(trayCode, uniqueCode);
            if (result)
            {
                return OperateResult.Succeed("");
            }
            else
            {
                return OperateResult.Error("该唯一码不属于当前托盘");
            }

        }


        /// <summary>
        /// 上架确认
        /// </summary>
        /// <param name="trayCode"></param>
        /// <param name="type">上架类型 all 整托 part 部分</param>
        /// <param name="uniqueCodes"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult UpMaterialSure(string trayCode, string type, string uniqueCodes)
        {
            var logPara = LogType.LogPara("上料确认（" + (type == "all" ? "整托" : "部分") + "）");
            Log.Detail(logPara, "接收参数：trayCode：" + trayCode + "，type：" + type + "，uniqueCodes：" + uniqueCodes);
            var result = BLLCreator.Create<HkBLL>().UpMaterialSure(trayCode, type, uniqueCodes, logPara);
            return result;
        }


        [HttpGet]
        public OperateResult CheckTrayByUpMaterial(string trayCode)
        {
            var logPara = LogType.LogPara("检查托盘（上料）");
            Log.Detail(logPara, "接收参数托盘号：" + trayCode);
            var result = BLLCreator.Create<HkBLL>().CheckTrayByUpMaterial(trayCode);
            Log.Detail(logPara, LogDescribe.Content(result));
            return result;
        }


        #endregion

        #region 按数量叫料相关接口
        /// <summary>
        /// 宇寿调用算法获取托盘
        /// </summary>
        /// <param name="stockCode">仓库编码</param>
        /// <param name="areaCode">库区编码</param>
        /// <param name="itemCode">物料编码</param>
        /// <param name="traySpec">物料规格</param>
        /// <param name="locationQty">物料数量</param>
        /// <param name="tokenId">身份验证</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetLocationCodeAction(string stockCode, string areaCode, string itemCode, string traySpec, decimal locationQty, string tokenId)
        {
            try
            {
                return ValidateToken(tokenId, t =>
                {
                    Log.Error("调用算法获取托盘：", "开始！");
                    if (t == null)
                    {
                        return OperateResult.Error("登陆人员信息获取失败！");
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(itemCode))
                        {
                            //检查物料编码是否正确 
                            var item = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItem(itemCode);
                            if (item == null)
                            {
                                return OperateResult.Error("当前物料编码未在AutoBom中找到！");
                            }
                        }
                        List<areaPriorClass> lstArea = new List<areaPriorClass>();
                        areaPriorClass areaClass = new areaPriorClass();
                        areaClass.areaCode = areaCode;
                        areaClass.Prior = 1;
                        lstArea.Add(areaClass);
                        //调用出库算法，获取待出去托盘
                        OutAssignEnitty oAe = new OutAssignEnitty()
                        {
                            lstAreaPrior = lstArea,
                            stockCode = stockCode,
                            itemCode = itemCode,
                            traySpec = traySpec,
                            itemQty = locationQty,
                            needCalLock = false,
                            lockLocation = false//是否需要锁定货位
                        };
                        OutAssignResultEntity oaEresult = BLLCreator.Create<Out_AlgorBLL>().OutAssign(oAe);
                        if (!oaEresult.Success)
                        {
                            Log.Error("调用出库算法，获取待出库托盘：", oaEresult.Msg);
                            return OperateResult.Error(oaEresult.Msg);//货位获取失败！
                        }
                        return OperateResult.Succeed("", oaEresult);
                    }
                });
            }
            catch (Exception ex)
            {
                Log.Error("GetLocationCodeAction异常:====>", ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message);
            }
        }


        /// <summary>
        /// 宇寿叫料
        /// </summary>
        /// <param name="locationCode">建议货位码</param>
        /// <param name="areaCode">目标库区</param>
        /// <param name="qTrayCode">起始托盘码</param>
        /// <param name="mTrayCode">目的货位码</param>
        /// <param name="tokenId">身份验证</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetCallMaterialAction(string locationCode, string areaCode, string qTrayCode, string endBit, string TaskType, string tokenId)
        {
            try
            {
                return ValidateToken(tokenId, t =>
                {
                    var logPara = LogType.LogPara("叫料");
                    if (t == null)
                    {
                        return OperateResult.Error("登陆人员信息获取失败！");
                    }
                    else
                    {

                        TrayOnShelfEntity entity = new TrayOnShelfEntity();
                        entity.CN_S_DEVICE_NO = endBit;   //终点
                        entity.CN_S_LOCATION_CODE = locationCode; //起点
                        entity.CN_S_END_AREA_CODE = areaCode;//目标库区
                        entity.CN_S_TRAY_CODE = qTrayCode; //起始托盘码
                        entity.CN_S_TASK_TYPE = TaskType; //任务类型
                        var result = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().SimZTDownShelfCallMaterial(entity, t);
                        if (!result.Success)
                        {
                            // BLLCreator.Create<YuShouApiBLL>().RollBackLocation(moveResult, locationCode, logPara);
                        }
                        else
                        {
                            //增加库区量表
                            TN_WM_LOCATION_EXTEntity startlocation = BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().GetExtModel(" where CN_S_LOCATION_CODE='" + locationCode + "'");
                            BLLCreator.Create<HkBLL>().AddAllocQty(qTrayCode, startlocation.CN_S_STOCK_CODE, startlocation.CN_S_AREA_CODE, logPara);
                        }
                        Log.Detail(logPara, "调用叫料结果：" + JsonConvert.SerializeObject(result));
                        return result;
                    }
                });
            }
            catch (Exception ex)
            {
                Log.Error("GetCallMaterialAction异常:====>", ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message);
            }
        }
        /// <summary>
        /// 检查叫料货位是否可用
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string CheckLocationJL(string locationCode)
        {
            try
            {
                OperateResult result = BLLCreator.Create<HkBLL>().CheckLocationJL(locationCode);

                return JsonConvert.SerializeObject(result);

            }
            catch (Exception ex)
            {
                Log.Error("CheckLocationYS异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }
        #endregion

        #region 空托回库相关代码
        /// <summary>
        /// 空托回库检测托盘码
        /// </summary>
        /// <param name="trayCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string CheckTrayCodeKT(string trayCode)
        {
            try
            {
                OperateResult result = BLLCreator.Create<HkBLL>().CheckTrayCodeKT(trayCode);
                return JsonConvert.SerializeObject(result);

            }
            catch (Exception ex)
            {
                Log.Error("CheckInStockTray异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }
        /// <summary>
        /// 空托回库检测货位码和托盘码
        /// </summary>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string CheckLocationCodeKT(string locationCode)
        {
            try
            {
                OperateResult result = BLLCreator.Create<HkBLL>().CheckLocationCodeKT(locationCode);

                return JsonConvert.SerializeObject(result);

            }
            catch (Exception ex)
            {
                Log.Error("CheckInStockLocation异常:====>", ex.Message + ex.StackTrace);
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }
        [HttpPost]
        public OperateResult SimZTShelfAutoKT(JObject json)
        {
            try
            {
                Log.Info("空托上架开始", "");
                TrayOnShelfEntity entity = JsonConvert.DeserializeObject<TrayOnShelfEntity>(json.ToString());
                return ValidateToken(entity.TokenId, t =>
                {
                    if (t == null)
                    {
                        return OperateResult.Error("登陆人员信息获取失败！");
                    }
                    OperateResult oresult = new OperateResult();
                    if (!entity.BIND_TRAY_LOCATION)
                    {
                        oresult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>(t).AddTrayLocationRelation(entity.CN_S_TRAY_CODE, entity.CN_S_DEVICE_NO, t, entity.projectCode);
                        if (oresult.Success)
                        {
                            oresult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().SimZTShelfAuto(entity, t);
                        }
                    }
                    else
                    {
                        oresult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().SimZTShelfAuto(entity, t);
                    }

                    return oresult;
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message.ToString());
            }
        }
        #endregion

        #region 空托出库相关代码
        /// <summary>
        /// 获取托盘类型列表
        /// </summary>
        /// <param name="loctiontype">托盘类型</param>
        /// <returns></returns>
        [HttpGet]
        public string GetTraySpecList()
        {
            try
            {
                return ValidateToken(x =>
                {
                    List<AutoBomStockAreaEntity> LoctionList = new List<AutoBomStockAreaEntity>();
                    AutoBomStockAreaEntity LoctionModel = null;
                    LoctionModel = new AutoBomStockAreaEntity();
                    LoctionModel.CN_S_AREA_CODE = "120*100";
                    LoctionList.Add(LoctionModel);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", LoctionList));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }

        #endregion

        #region 调用入库方法
        [HttpPost]
        public OperateResult InAssignAlgor(JObject jsonData)
        {
            InAssignEntity entity = JsonConvert.DeserializeObject<InAssignEntity>(jsonData.ToString());
            InAssignResultEntity resultEntity = new InAssignResultEntity();
            resultEntity = BLLCreator.Create<In_AlgorBLL>().InAssign(entity);
            return OperateResult.Succeed("", resultEntity);
        }
        #endregion
    }
}