using HH.WCS.Mobox3.NFLZ.device;
using HH.WCS.Mobox3.NFLZ.dispatch;
using HH.WCS.Mobox3.NFLZ.models;
using HH.WCS.Mobox3.NFLZ.process;
using HH.WCS.Mobox3.NFLZ.util;
using HH.WCS.Mobox3.NFLZ.wms;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using static HH.WCS.Mobox3.NFLZ.api.ApiModel;
using static HH.WCS.Mobox3.NFLZ.api.OtherModel;
using static HH.WCS.Mobox3.NFLZ.wms.WMSHelper;

namespace HH.WCS.Mobox3.NFLZ.api
{
    /// <summary>
    /// api接口辅助类
    /// </summary>
    public class ApiHelper
    {
        static ApiHelper()
        {

        }


        internal static SimpleResult Putaway_Order_In(Putaway_Order_In model)
        {
            var result = new SimpleResult();
            //创建入库单主子表
            var po = WMSHelper.GetPutawayOrder(model.Data.arrival_no);
            if (po == null)
            {
                po = new PutawayOrder { S_NO = model.Data.arrival_no, S_BS_TYPE = model.Data.op_type };
                po.Details = new List<PutawayDetail>();
                if (model.Data.items.Count > 0)
                {
                    model.Data.items.ForEach(a =>
                    {
                        po.Details.Add(new PutawayDetail
                        {
                            S_PUTAWAY_NO = model.Data.arrival_no,
                            N_ROW_NO = po.Details.Count + 1,
                            S_ITEM_CODE = a.item_code,
                            F_QTY = a.qty,
                            S_BATCH_NO = a.batch_no,
                        });
                    });
                    WMSHelper.CreatePutawayOrder(po);
                }

            }
            return result;
        }

        internal static PlcSendTaskres PlcCallbackState(PlcState model)
        {
            var db = new SqlHelper<object>().GetInstance();
            var result = new PlcSendTaskres { requestPk = model.requestPk, code = "0" };
            string message = "";
            if (model.noticeType == "0")
            {
                //称重
            }
            else
            {
                var task = WCSHelper.GetTask(model.requestPk);
                if (task != null)
                {
                    //if (!WCSHelper.CheckActionRecordExist(task.S_CODE, int.Parse(model.noticeType)))
                    //{
                    switch (model.noticeType)
                    {
                        case "3":
                            //执行状态
                            WCSHelper.Begin(task);
                            WCSHelper.UpdateStorStatus(task.S_CNTR_CODE, 3);
                            break;
                        case "2":
                            //完成状态 (出库任务生成第二段agv任务) 解绑起点终点
                            //if (task.S_B_STATE != "取消" && task.S_B_STATE != "完成" && task.S_B_STATE != "关闭" && task.S_B_STATE != "强制完成")
                            //{
                            TaskProcess.OperateStatus(task, 4);
                            TaskProcess.OperateStatus(task, 6);
                            if (task.S_TYPE.Contains("入库"))
                            {
                                WMSHelper.AddChange(task);
                            }
                            //TaskProcess.PlcSencondTask(task);
                            WCSHelper.End(task);
                            WMSHelper.End(task);
                            //}
                            break;
                        case "8":
                            //取货无货(释放货位)
                            quhuowuhuo(db, task);
                            break;
                    }
                    WCSHelper.AddActionRecord(task.S_CODE, int.Parse(model.noticeType), "", "");
                    //}
                }
                else
                {
                    result.code = "1";
                    result.msg = "该任务编号不存在";
                }
            }
            return result;
        }

        internal static SimpleResult OutboundOrderExecute(OutboundOrderCheck model)
        {
            var result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();
            var nolist = model.out_no.Split(',').ToList();
            nolist.ForEach(a =>
            {
                var OutboundOrder = db.Queryable<TN_Outbound_Order>().Where(it => it.S_NO == a && it.N_B_STATE == 0).Includes(it => it.Details).First();
                if (OutboundOrder != null)
                {
                    var res = false;
                    for (int i = 0; i < OutboundOrder.Details.Count; i++)
                    {
                        var detail = OutboundOrder.Details[i];
                        var whi = db.Queryable<WHInventory>().Where(w => w.S_ITEM_CODE == detail.S_ITEM_CODE).First();
                        if (whi != null && whi.F_QTY - whi.F_ALLOC_QTY > 0)
                        {
                            res = true;
                            Expression<Func<CntrItemRel, bool>> expression = x => x.S_ITEM_CODE == detail.S_ITEM_CODE;
                            expression.AndAlso(x => x.Cntr.C_ENABLE == "Y");
                            expression.AndAlso(x => (x.F_QTY - x.F_ALLOC_QTY) > (detail.F_QTY - detail.F_ACC_D_QTY));
                            expression.AndAlso(x => (x.F_QTY - x.F_ALLOC_QTY) / 2 < (detail.F_QTY - detail.F_ACC_D_QTY));
                            if (!string.IsNullOrEmpty(detail.S_BATCH_NO)) expression.AndAlso(x => x.S_BATCH_NO == detail.S_BATCH_NO);
                            if (!string.IsNullOrEmpty(detail.S_OWNER)) expression.AndAlso(x => x.S_OWNER == detail.S_OWNER);
                            if (!string.IsNullOrEmpty(detail.S_ERP_WH_CODE)) expression.AndAlso(x => x.S_ERP_WH_CODE == detail.S_ERP_WH_CODE);
                            var bol = false;
                            var fjlist = db.Queryable<CntrItemRel>().Includes(c => c.Cntr)
                            .Where(expression)
                            .OrderBy(c => c.T_CREATE)
                            .ToList();
                            for (int j = 0; j < fjlist.Count; j++)
                            {
                                //检测这个托盘物料是否单一
                                var cir = fjlist[j];
                                //var isfj = db.Queryable<TN_Distribution_CNTR>().Where(c => c.S_CNTR_CODE == cir.S_CNTR_CODE && c.C_REVERSE == "Y" && c.N_B_STATE < 2).First();
                                //if (isfj == null)
                                //{
                                //    var itemlist = db.Queryable<CntrItemRel>().Where(c => c.S_CNTR_CODE == cir.S_CNTR_CODE && c.F_QTY > 0).ToList();
                                //    if (itemlist.Count == 1)
                                //    {
                                //        var dc_no = WMSHelper.GenerateDistrbutionCntrNo();
                                //        bol = true;
                                //        var dc = new TN_Distribution_CNTR
                                //        {
                                //            S_DC_NO = dc_no,
                                //            S_BS_NO = detail.S_DO_NO,
                                //            S_BS_TYPE = OutboundOrder.S_BS_TYPE,
                                //            S_CNTR_CODE = cir.S_CNTR_CODE,
                                //            S_EXIT_AREA_CODE = OutboundOrder.S_AREA_CODE,
                                //            S_OP_TYPE = OutboundOrder.S_BS_TYPE,
                                //            C_REVERSE = "Y"
                                //        };
                                //        db.Insertable(dc).ExecuteCommand();
                                //
                                //        var dc_detail = new TN_Distribution_CNTR_Detail
                                //        {
                                //            S_ITEM_CODE = detail.S_ITEM_CODE,
                                //            S_ITEM_NAME = detail.S_ITEM_NAME,
                                //            S_BATCH_NO = detail.S_BATCH_NO,
                                //            S_ERP_WH_CODE = detail.S_ERP_WH_CODE,
                                //            S_SUPPLIER_NO = detail.S_SUPPLIER_NO,
                                //            S_OWNER = detail.S_OWNER,
                                //            N_BS_ROW_NO = detail.N_ROW_NO,
                                //            S_BS_TYPE = OutboundOrder.S_BS_TYPE,
                                //            S_DC_NO = dc_no,
                                //            S_BS_NO = OutboundOrder.S_NO,
                                //            F_QTY = (itemlist[0].F_QTY - itemlist[0].F_ALLOC_QTY) - (detail.F_QTY - detail.F_ACC_D_QTY),
                                //        };
                                //        db.Insertable(dc_detail).ExecuteCommand();
                                //        //更新容器货品表分配量
                                //        cir.F_ALLOC_QTY += (float)dc_detail.F_QTY;
                                //        cir.T_MODIFY = DateTime.Now;
                                //        db.Updateable(cir).UpdateColumns(it => new { it.F_ALLOC_QTY, it.T_MODIFY }).ExecuteCommand();
                                //        //更新分拣单子表的量
                                //        detail.F_ACC_D_QTY += detail.F_QTY - detail.F_ACC_D_QTY;
                                //        detail.T_MODIFY = DateTime.Now;
                                //        db.Updateable(detail).UpdateColumns(it => new { it.F_ACC_D_QTY, it.T_MODIFY }).ExecuteCommand();
                                //        whi.F_ALLOC_QTY += (float)(detail.F_QTY - detail.F_ACC_D_QTY);
                                //        whi.T_MODIFY = DateTime.Now;
                                //        db.Updateable(whi).UpdateColumns(it => new { it.F_ALLOC_QTY, it.T_MODIFY }).ExecuteCommand();
                                //        break;
                                //    }
                                //}
                            }


                            Expression<Func<CntrItemRel, bool>> expression1 = x => x.S_ITEM_CODE == detail.S_ITEM_CODE;
                            expression1.AndAlso(x => x.Cntr.C_ENABLE == "Y");
                            expression1.AndAlso(x => (x.F_QTY - x.F_ALLOC_QTY) > 0);
                            if (!string.IsNullOrEmpty(detail.S_BATCH_NO)) expression1.AndAlso(x => x.S_BATCH_NO == detail.S_BATCH_NO);
                            if (!string.IsNullOrEmpty(detail.S_OWNER)) expression1.AndAlso(x => x.S_OWNER == detail.S_OWNER);
                            if (!string.IsNullOrEmpty(detail.S_ERP_WH_CODE)) expression1.AndAlso(x => x.S_ERP_WH_CODE == detail.S_ERP_WH_CODE);

                            if (!bol)
                            {
                                //按分拣单子表去配货，查找可用托盘(先查所有符合的，后面再优化)
                                var cirList = db.Queryable<CntrItemRel>().Includes(c => c.Cntr)
                                .Where(expression1)
                                .OrderBy(c => c.T_CREATE)
                                .ToList();
                                for (int j = 0; j < cirList.Count; j++)
                                {
                                    var cir = cirList[j];
                                    //var isfj = db.Queryable<TN_Distribution_CNTR>().Where(c => c.S_CNTR_CODE == cir.S_CNTR_CODE && c.C_REVERSE == "Y" && c.N_B_STATE < 2).First();
                                    //if (isfj == null)
                                    //{
                                    //    var dc_no = WMSHelper.GenerateDistrbutionCntrNo();
                                    //    bol = true;
                                    //    var dc = new TN_Distribution_CNTR
                                    //    {
                                    //        S_DC_NO = dc_no,
                                    //        S_BS_NO = detail.S_DO_NO,
                                    //        S_BS_TYPE = OutboundOrder.S_BS_TYPE,
                                    //        S_CNTR_CODE = cir.S_CNTR_CODE,
                                    //        S_EXIT_AREA_CODE = OutboundOrder.S_AREA_CODE,
                                    //        S_OP_TYPE = OutboundOrder.S_BS_TYPE
                                    //    };
                                    //    db.Insertable(dc).ExecuteCommand();
                                    //    var dc_detail = new TN_Distribution_CNTR_Detail
                                    //    {
                                    //        S_ITEM_CODE = detail.S_ITEM_CODE,
                                    //        S_ITEM_NAME = detail.S_ITEM_NAME,
                                    //        S_BATCH_NO = detail.S_BATCH_NO,
                                    //        S_ERP_WH_CODE = detail.S_ERP_WH_CODE,
                                    //        S_SUPPLIER_NO = detail.S_SUPPLIER_NO,
                                    //        S_OWNER = detail.S_OWNER,
                                    //        N_BS_ROW_NO = detail.N_ROW_NO,
                                    //        S_BS_TYPE = OutboundOrder.S_BS_TYPE,
                                    //        S_DC_NO = dc_no,
                                    //        S_BS_NO = OutboundOrder.S_NO,
                                    //    };
                                    //    bool needBreak = false;
                                    //    if (cir.F_QTY - cir.F_ALLOC_QTY >= (detail.F_QTY - detail.F_ACC_D_QTY))
                                    //    {
                                    //        dc_detail.F_QTY = detail.F_QTY - detail.F_ACC_D_QTY;
                                    //        needBreak = true;
                                    //    }
                                    //    else
                                    //    {
                                    //        //生成分拣明细，继续创建
                                    //        dc_detail.F_QTY = cir.F_QTY - cir.F_ALLOC_QTY;
                                    //    }
                                    //    db.Insertable(dc_detail).ExecuteCommand();
                                    //    //更新容器货品表分配量
                                    //    cir.F_ALLOC_QTY += (float)dc_detail.F_QTY;
                                    //    cir.T_MODIFY = DateTime.Now;
                                    //    db.Updateable(cir).UpdateColumns(it => new { it.F_ALLOC_QTY, it.T_MODIFY }).ExecuteCommand();
                                    //    //更新分拣单子表的量
                                    //    detail.F_ACC_D_QTY += dc_detail.F_QTY;
                                    //    detail.T_MODIFY = DateTime.Now;
                                    //    db.Updateable(detail).UpdateColumns(it => new { it.F_ACC_D_QTY, it.T_MODIFY }).ExecuteCommand();
                                    //    whi.F_ALLOC_QTY += (float)dc_detail.F_QTY;
                                    //    whi.T_MODIFY = DateTime.Now;
                                    //    db.Updateable(whi).UpdateColumns(it => new { it.F_ALLOC_QTY, it.T_MODIFY }).ExecuteCommand();
                                    //    if (needBreak)
                                    //    {
                                    //        break;
                                    //    }
                                    //}
                                }
                            }
                        }
                        else
                        {
                            //修改出库单明细状态为缺件
                        }
                    }
                }

                //修改出库单状态为执行 
            });

            return result;
        }

        private static void quhuowuhuo(SqlSugarClient db, WCSTask task)
        {
            TaskProcess.OperateStatus(task, 7);
            task.S_NOTE = "异常";
            db.Updateable(task).UpdateColumns(it => new { it.S_NOTE }).ExecuteCommand();
        }

        internal static WeiLiResult CancelOrder(CancelOrderModel model)
        {
            WeiLiResult result = new WeiLiResult();
            var db = new SqlHelper<object>().GetInstance();
            var tasks = db.Queryable<WCSTask>().Where(a => a.S_OP_CODE == model.task_no).ToList();
            if (tasks.Count >= 1)
            {
                //流程任务数量执行超过一条 任务不允许取消
                result.code = 500;
                result.msg = "流程任务执行中途不允许取消";
                return result;
            }
            var task = db.Queryable<WCSTask>().Where(a => a.S_OP_CODE == model.task_no).OrderByDescending(a => a.T_CREATE).First();
            if (task != null)
            {
                if (WCSHelper.CheckActionRecordExist(task.S_CODE, 4))
                {
                    result.code = 500;
                    result.msg = "任务已取货完成 不允许取消";
                    return result;
                }
                if (task.N_B_STATE == 0)
                {
                    //等待直接修改状态为取消
                    WCSHelper.UpdateStatus(model.task_no, 5);
                    //result.msg = "任务等待，直接取消";
                }
                else if (task.N_B_STATE != 3 && task.N_B_STATE != 4)
                {
                    if (task.S_TYPE == "杭奥")
                    {
                        //通知立库取消任务
                    }
                    else
                    {
                        //已推送但是没有完成或者取消，通知hosttoagv
                        //NDCHelper.Cancel(task.S_CODE.Trim());
                        NDCApi.CancelOrder(task.S_CODE.Trim());
                        //result.msg = "任务取消已经发送给小车";
                    }
                }
                else
                {
                    result.code = 500;
                    result.msg = "任务已结束";
                }
            }
            else
            {
                result.code = 500;
                result.msg = "任务不存在";
            }
            return result;
        }

       

        internal static WeiLiResult ChangeOrderPrioryty(ChangeOrderPriorytyModel model)
        {
            WeiLiResult result = new WeiLiResult();
            var db = new SqlHelper<object>().GetInstance();
            var task = db.Queryable<WCSTask>().Where(a => a.S_OP_CODE == model.orderNo).OrderByDescending(a => a.T_CREATE).First();
            if (task != null)
            {
                if (task.N_B_STATE == 0)
                {
                    //等待直接修改状态为取消
                    WCSHelper.UpdatePrioryty(task, model.priority);
                    result.msg = "修改优先级成功";
                }
                else if (task.N_B_STATE != 3 && task.N_B_STATE != 4)
                {
                    if (task.S_TYPE == "杭奥")
                    {
                        //通知立库修改任务优先级
                        result.msg = "修改优先级成功";
                    }
                    else
                    {
                        //通知杭叉修改优先级
                        //NDCHelper.Cancel(task.S_CODE.Trim());
                        NDCApi.CancelOrder(task.S_CODE.Trim());
                        result.msg = "修改优先级成功";
                    }
                }
                else
                {
                    result.code = 500;
                    result.msg = "任务已结束";
                }
            }
            else
            {
                result.code = 500;
                result.msg = "任务不存在";
            }
            return result;
        }

      

      

       
        
        

        

        

        internal static SimpleResult PalletSorting(PalletSorting model)
        {
            var result = new SimpleResult();
            //校验入库单数量，不可以超，成功后插入托盘物料表，更新入库单累计数量
            //也可以直接lua查询入库单数量，做校验
            var info = WMSHelper.GetPutawayOrderDetail(model.arrival_no, model.item_code);
            if (info != null)
            {
                if (info.F_QTY - info.F_ACC_B_QTY >= model.qty)
                {
                    // 插入到托盘明细表
                    var cntr = ContainerHelper.GetCntr(model.cntr_code, true);
                    if (cntr != null)
                    {
                        ContainerHelper.BindCntrItem(cntr, model.item_code, info.S_BATCH_NO, model.qty, model.arrival_no);
                        //更新入库单累计绑定数量
                        info.F_ACC_B_QTY += model.qty;
                        WMSHelper.UpdatePutawayOrderDetailQty(info);
                    }
                    else
                    {
                        result.resultCode = 2;
                        result.resultMsg = "获取托盘信息失败";
                    }
                }
                else
                {
                    result.resultCode = 1;
                    result.resultMsg = "累计码盘数量超出入库单数量";
                }
            }
            else
            {
                result.resultCode = 3;
                result.resultMsg = $"未找到入库单{model.arrival_no}";
            }

            return result;
        }

        


        public class ReceivingNoteSerialNo
        {
            public List<serial> data { get; set; } = new List<serial>();
            public class serial
            {
                public string rowID { get; set; }
                public List<string> serialNo { get; set; } = new List<string>();
            }
        }
        internal static SimpleResult OutboundOrder(OutboundOrder model)
        {
            var result = new SimpleResult();
            //创建发货单，人工点确认后生成分拣单，没有缺货的自动更新为失败，有货的更新为执行中
            //创建入库单主子表
            var po = WMSHelper.GetShippingOrder(model.Data.out_no);
            if (po == null)
            {
                po = new ShippingOrder { S_NO = model.Data.out_no, S_BS_TYPE = model.Data.op_type, LINE_AREA = model.Data.line_area };
                po.Details = new List<ShippingDetail>();
                if (model.Data.items.Count > 0)
                {
                    model.Data.items.ForEach(a =>
                    {
                        po.Details.Add(new ShippingDetail
                        {
                            S_SHIPPING_NO = model.Data.out_no,
                            N_ROW_NO = po.Details.Count + 1,
                            S_ITEM_CODE = a.item_code,
                            F_QTY = a.qty,
                            S_BATCH_NO = a.batch_no,
                        });
                    });
                    WMSHelper.CreateShippingOrder(po);
                }

            }
            return result;
        }

        internal static SimpleResult ShippingOrderExecute(ShippingOrderCheck model)
        {
            var result = new SimpleResult();
            //检查库存，更新发货单，生成分拣单，自动合并波次
            //这个后台做比较麻烦，Mobox3.NFLZ库存在内存中，任务完成的时候无法增加，还是用c#直接管内存，计算比较方便
            WMSHelper.CreateSortingOrder(model.out_nos.Split(',').ToList());
            return result;
        }

        /// <summary>
        /// 后面要把方法放到wmsHelper中
        /// </summary>
        /// <param name="models"></param>
        /// <returns></returns>
        internal static SimpleResult SortingResultCheck(List<SortingResultCheck> models)
        {
            //生成分拣结果，更新分拣明细状态
            var result = new SimpleResult();
            WMSHelper.SortingConfrim(models);
            return result;
        }



        /// <summary>
        /// 后面要把方法放到wmsHelper中
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResult Instock(InstockInfo model)
        {
            var result = new SimpleResult();
            //pda入库，目前人工放货在巷道口，扫托盘，后台只能计算当前巷道的终点，单深位立库
            //1，判断托盘信息，一种是码盘后的，默认enable是N，另一种是分拣回的
            var cntr = ContainerHelper.GetCntr(model.cntr);
            if (cntr != null)
            {
                var sortingInfo = WMSHelper.GetSortingDetailByCntr(model.cntr);
                if (cntr.C_ENABLE == "Y" && sortingInfo != null && sortingInfo.Count > 0)
                {
                    result.resultCode = 2;
                    result.resultMsg = $"托盘{model.cntr}未分拣完成";
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = $"托盘{model.cntr}不存在";
            }
            if (result.resultCode == 0)
            {
                //获取接驳位所在的巷道, 查找功能区，入库接驳位找逻辑库区（每个巷道一个逻辑库区）
                var fa = LocationHelper.GetFunctionAreaByCode(model.start, 2, 10);
                if (fa != null)
                {
                    //创建入库作业，简单判断一下是否有可入货位，如果不判断，人工货放上去一直不能入，也不知道原因
                    var end = LocationHelper.GetZoneLoc(fa.S_MASTER_CODE);
                    if (end != null)
                    {
                        //判断托盘是否已经生成任务，如果没有则生成
                        var wmsTask = WMSHelper.GetWmsTaskByCntr(model.cntr);
                        if (wmsTask != null)
                        {
                            result.resultCode = 3;
                            result.resultMsg = $"起点{model.start} 托盘{model.cntr}已经创建任务，请勿重复申请";
                        }
                        else
                        {
                            wmsTask = new WMSTask
                            {
                                S_CNTR_CODE = model.cntr,
                                S_CODE = WMSHelper.GenerateTaskNo(),
                                S_START_LOC = model.start,
                                S_END_LOC = end.S_LOC_CODE,
                                N_TYPE = 1,
                                S_TYPE = WMSTask.GetTypeStr(1),
                                S_OP_DEF_CODE = "",
                                S_OP_DEF_NAME = "pda入立库"
                            };
                            if (WMSHelper.CreateWmsTask(wmsTask))
                            {
                                LocationHelper.LockLoc(model.start, 1);
                                result.resultMsg = $"创建作业成功，作业号{wmsTask.S_CODE}";
                            }
                        }
                    }
                    else
                    {
                        result.resultCode = 3;
                        result.resultMsg = $"起点{model.start}对应的逻辑库区{fa.S_MASTER_CODE}没有可用货位，请更换巷道";
                    }
                }
                else
                {
                    result.resultCode = 3;
                    result.resultMsg = $"起点{model.start}没有对应的逻辑库区，请在逻辑库区设置功能区-入库接驳位";
                }
            }
            return result;
        }

        internal static SimpleResult SortingOrderExecute(SortingOrderCheck model)
        {
            var result = new SimpleResult();
            //分拣单配货执行
            WMSHelper.CreateSortingOrderDetail(model.s_no);
            return result;
        }


        internal static SimpleResult CheckSortingWholeCntr(CheckSortingWholeCntr model)
        {
            var result = new SimpleResult();
            if (WMSHelper.CheckSortingWholeCntr(model.cntr, model.autoSort == 1))
            {
                result.resultCode = 1;
                result.resultMsg = "整托分拣";
            }
            return result;
        }
        internal static CodeInfo GetCodeInfo(string code, string org)
        {
            //return new CodeInfo {  Fitemid_XK=code, FSourceNo="123456"};
            CodeInfo result = null;
            try
            {
                var db = new SqlHelper<object>().GetInstance(Settings.SqlServer1);
                var nameP = new SugarParameter("@FBarCode", code);
                var orgP = new SugarParameter("@Forg", org);
                //var ageP = new SugarParameter("@age", null, true);//设置为output
                //var dt = db.Ado.UseStoredProcedure().GetDataTable("sp_school", nameP, ageP);//返回dt
                result = db.Ado.UseStoredProcedure().SqlQuery<CodeInfo>("WMS_FBarCode", nameP, orgP).First();//返回List
                Console.WriteLine($"读存储过程成功,result={result}");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return result;
        }

        internal static SimpleResult PalletSorting1(PalletSorting1 model)
        {
            var result = new SimpleResult();
            //校验入库单数量，不可以超，成功后插入托盘物料表，更新入库单累计数量
            //也可以直接lua查询入库单数量，做校验
            //先用bar_code读存储过程获取信息
            var codeInfo = GetCodeInfo(model.bar_code, model.org);
            var info = WMSHelper.GetPutawayOrderDetail(model.bar_code);
            if (info != null)
            {
                if (info.F_QTY - info.F_ACC_B_QTY >= model.qty)
                {
                    // 插入到托盘明细表

                    var cntr = ContainerHelper.GetCntr(model.cntr_code, true);
                    if (cntr != null)
                    {
                        ContainerHelper.BindCntrItem(cntr, model.bar_code, info.S_BATCH_NO, model.qty, info.S_BATCH_NO);
                        //更新入库单累计绑定数量
                        info.F_ACC_B_QTY += model.qty;
                        WMSHelper.UpdatePutawayOrderDetailQty(info);
                    }
                    else
                    {
                        result.resultCode = 2;
                        result.resultMsg = "获取托盘信息失败";
                    }


                }
                else
                {
                    result.resultCode = 1;
                    result.resultMsg = "累计码盘数量超出入库单数量";
                }
            }
            else
            {
                result.resultCode = 3;
                result.resultMsg = $"未获取到该物料{model.bar_code}的入库单明细信息";
            }

            return result;
        }

        internal static ReturnResult bindCntr(bindModel model)
        {
            ReturnResult result = new ReturnResult() {ResultCode = -1 };
            var db = new SqlHelper<object>().GetInstance();

            if (TaskProcess.BindLocCntr(model.S_LOC_CODE, model.S_CNTR_CODE, model.S_ITEM_CODE, model.S_BATCH_CODE))
            {
                int num = model.S_CNTR_CODE.Split(',').Count();
                var locInfo = db.Queryable<Location>().Where(a => a.S_CODE == model.S_LOC_CODE).First();
                if(locInfo != null)
                {
                    locInfo.N_CURRENT_NUM = locInfo.N_CURRENT_NUM + num > locInfo.N_CAPACITY ? locInfo.N_CAPACITY : locInfo.N_CURRENT_NUM + num;
                    db.Updateable(locInfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                    result.ResultCode = 0;
                }
            }
            return result;
        }

        internal static ReturnResult unBindCntr(unBindModel model)
        {
            ReturnResult result = new ReturnResult() { ResultCode = -1 };
            var db = new SqlHelper<object>().GetInstance();
            var locInfo = db.Queryable<Location>().Where(a => a.S_CODE == model.S_LOC_CODE).First();
            if(locInfo != null)
            {
                var cntrList = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == model.S_LOC_CODE).ToList();
                if(cntrList.Count > 0)
                {
                    for (int i = cntrList.Count - 1; i >= 0; i --)
                    {
                        string cntrCode = cntrList[i].S_CNTR_CODE;
                        db.Deleteable<CntrItemRel>().Where(a => a.S_CNTR_CODE == cntrCode).ExecuteCommand();
                        db.Deleteable<LocCntrRel>().Where(a => a.S_CNTR_CODE == cntrCode).ExecuteCommand();
                        db.Deleteable<Container>().Where(a => a.S_CODE == cntrCode).ExecuteCommand();
                    }
                }
                locInfo.N_CURRENT_NUM = locInfo.N_CURRENT_NUM - 1;
                if (locInfo.N_CURRENT_NUM < 0) locInfo.N_CURRENT_NUM = 0;
                db.Updateable(locInfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                result.ResultCode = 0;
            }
            return result;
        }

        internal static ReturnResult JBIn(JBInModel model)
        {
            ReturnResult result = new ReturnResult() { ResultCode = -1 };
            var db = new SqlHelper<object>().GetInstance();
            string cntrCode = Guid.NewGuid().ToString("N");
            string batch = "";
            if (model.S_ITEM_TYPE == "小包装盖")
            {
                //小包装盖默认一层
                batch = "小包装盖";
            }
            if (model.S_ITEM_TYPE == "瓶坯")
            {
                //瓶坯默认两层
                cntrCode = cntrCode + ","+ Guid.NewGuid().ToString("N");
            }
            if (model.S_ITEM_TYPE == "大包装盖")
            {
                //大包装盖默认三层
                cntrCode = cntrCode + "," + Guid.NewGuid().ToString("N") + "," + Guid.NewGuid().ToString("N");
                batch = "大包装盖";
            }
            //创建作业
            var locInfo = db.Queryable<Location>().Where(a => a.S_CODE == model.S_LOC_CODE && a.S_LOCK_STATE == "无").First();
            if(locInfo != null)
            {
                LogHelper.Info($"JBIn:{model.S_LOC_CODE},{cntrCode},{"指定库区-" + model.S_END_AREA}");
                if (WMSHelper.CreateOpTask(model.S_LOC_CODE, "", "入库", "接驳位入库", cntrCode, "指定库区-" + model.S_END_AREA))
                {
                    TaskProcess.BindLocCntr(model.S_LOC_CODE, cntrCode, model.S_ITEM_CODE, batch);
                    result.ResultCode = 0;
                }
            }
            else
            {
                result.ResultMsg = $"该点位不存在或者有锁，货位编码：{model.S_LOC_CODE}";
            }
            

            return result;
        }

        internal static ReturnResult PtpTask(PtpTaskModel model, ReturnResult result)
        {
            var db = new SqlHelper<object>().GetInstance();
            var startLoc = db.Queryable<Location>().Where(a => a.S_CODE == model.S_START_LOC).First();
            if(startLoc != null && startLoc.S_LOCK_STATE == "无")
            {
                string cntrCode = "";
                var cntrInfo = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startLoc.S_CODE).First();
                if(cntrInfo != null)
                {
                    cntrCode = cntrInfo.S_CNTR_CODE;
                }
                else
                {
                    cntrCode = Guid.NewGuid().ToString("N");
                }
                var endLoc = db.Queryable<Location>().Where(a => a.S_CODE == model.S_END_LOC).First();
                if (endLoc != null && endLoc.S_LOCK_STATE == "无")
                {
                    WMSHelper.CreateOpTask(model.S_START_LOC, model.S_END_LOC, "入库", "点到点转运", cntrCode, "");
                }
                else
                {
                    result.ResultMsg = $"终点货位不存在或者有锁，货位编码：{model.S_END_LOC}";
                }
            }
            else
            {
                result.ResultMsg = $"起点货位不存在或者有锁，货位编码：{model.S_START_LOC}";
            }
            return result;
        }


        //public class AddTaskModel
        //{
        //    public string From { get; set; }
        //    public string To { get; set; }
        //    public string No { get; set; }
        //}
        public class TN_LocationModel
        {
            public string TN_Location { get; set; }
        }
        public class CodeInfo
        {
            /// <summary>
            /// 生产订单内码
            /// </summary>
            public string FInterID { get; set; }
            /// <summary>
            /// 生产订单编号
            /// </summary>
            public string FSourceNo { get; set; }
            /// <summary>
            /// 批号
            /// </summary>
            public string FGMPBatchNo { get; set; }
            public string FState { get; set; }
            /// <summary>
            /// 物料编码（内码就是编码）
            /// </summary>
            public string Fitemid_XK { get; set; }
            /// <summary>
            /// 分录id
            /// </summary>
            public string Fentryid { get; set; }
        }
        public class NoteInfo : CodeInfo
        {
            public string WmsBillNo { get; set; }
        }
    }
}