using HH.Redis.ReisModel;
using HH.WMS.BLL;
using HH.WMS.BLL.Basic;
using HH.WMS.BLL.InStock;
using HH.WMS.BLL.SysMgr;
using HH.WMS.Common;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Common;
using HH.WMS.Entitys.Entitys;
using HH.WMS.Entitys.Func;
using HH.WMS.WebApi.Areas.Common.Controllers;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;

namespace HH.WMS.WebApi.Areas.InStock.Controllers
{
    public class InController : BaseController
    {
        #region 新增入库单
        /// <summary>
        /// 新增入库单
        /// </summary>
        /// <param name="Entity">入库单实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-13</History>
        [HttpPost]
        public OperateResult AddIncrease(TN_WM_INCREASE_INVENTORY_MSTEntity entity)
        {
            try
            {
                return ValidateToken(entity.TokenId, t =>
                {
                    OperateResult result = new OperateResult();

                    //entity.CN_S_ORGAN = t.CN_S_ORGCODE;
                    entity.CN_S_CREATOR = t.CN_S_LOGIN;
                    entity.CN_S_CREATOR_BY = t.CN_S_NAME;
                    entity.CN_T_CREATE = DateTime.Now;

                    entity.CN_S_MODIFY = t.CN_S_LOGIN;
                    entity.CN_S_MODIFY_BY = t.CN_S_NAME;
                    entity.CN_T_MODIFY = DateTime.Now;

                    entity.CN_GUID = Guid.NewGuid().ToString();
                    entity.CN_S_OWNER = Constants.DefaultOwner;
                    int rowNo = 1;
                    foreach (var inDtl in entity.DTLEntity)
                    {
                        AutoBomItemEntity itemenity = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItem(inDtl.CN_S_ITEM_CODE);
                        inDtl.CN_S_EXT1 = "";//物料是否大小件
                       
                        inDtl.CN_GUID = Guid.NewGuid().ToString();
                        inDtl.CN_N_ROW_NO = rowNo++;
                        inDtl.CN_S_MSTGUID = entity.CN_GUID;
                        inDtl.CN_S_OP_NO = entity.CN_S_OP_NO;
                        inDtl.CN_S_STATE = entity.CN_S_STATE;
                        inDtl.CN_S_ITEM_STATE = string.IsNullOrEmpty(inDtl.CN_S_ITEM_STATE.ToString()) ? "合格" : inDtl.CN_S_ITEM_STATE.ToString();
                        inDtl.CN_C_IS_BALANCE = "N";
                        inDtl.CN_C_IS_SCRAP = "N";
                        inDtl.CN_F_UPSHELF_QTY = 0;
                        inDtl.CN_F_ALLOT_QTY = 0;
                        inDtl.CN_F_PRINTING_QTY = 0;
                        inDtl.CN_F_ADD_ONTRAY_QTY = 0;
                        inDtl.CN_T_CREATE = DateTime.Now;
                        inDtl.CN_S_CREATOR = entity.CN_S_CREATOR;
                        inDtl.CN_S_CREATOR_BY = entity.CN_S_CREATOR_BY;
                        inDtl.CN_T_MODIFY = DateTime.Now;
                        inDtl.CN_S_MODIFY = entity.CN_S_MODIFY;
                        inDtl.CN_S_MODIFY_BY = entity.CN_S_MODIFY_BY;
                    }

                    result = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().AddIncreaseInventory(entity, t);


                    if (result.Success && (entity.OperateMessage == Constants.Operate_EditAndSubmit))
                    {
                        List<TN_WM_B_EXAMINEEntity> examineList = new List<TN_WM_B_EXAMINEEntity>();
                        examineList.Add(new TN_WM_B_EXAMINEEntity()
                        {
                            CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                            CN_S_EXAMINE_TYPE = Constants.State_Submit,
                            CN_S_OP_FROM = "入库单",
                            CN_S_FROM_NO = entity.CN_S_OP_NO,
                            CN_S_CREATOR = t.CN_S_LOGIN,
                            CN_S_CREATOR_BY = t.CN_S_NAME,
                            CN_T_CREATE = DateTime.Now,
                            CN_S_OPINION = "",
                            TokenId = entity.TokenId
                        });

                        return SubmitIncrease(examineList);
                    }
                    return result;
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 修改入库单
        /// <summary>
        /// 修改入库单
        /// </summary>
        /// <param name="Entity">入库单实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        [HttpPost]
        public OperateResult UpdateIncrease(TN_WM_INCREASE_INVENTORY_MSTEntity entity)
        {
            try
            {
                return ValidateToken(entity.TokenId, t =>
                {
                    OperateResult result = new OperateResult();

                    var existsInMst = BLLCreator.Create<DapperBLL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetSingleEntity(new
                    {
                        CN_S_OP_NO = entity.CN_S_OP_NO
                    });

                    entity.CN_GUID = existsInMst.CN_GUID;
                    entity.CN_T_CREATE = existsInMst.CN_T_CREATE;
                    entity.CN_S_CREATOR = existsInMst.CN_S_CREATOR;
                    entity.CN_S_CREATOR_BY = existsInMst.CN_S_CREATOR_BY;

                    //根据tokenId 获取当前登陆信息
                    //entity.CN_S_ORGAN = t.CN_S_ORGCODE;
                    entity.CN_S_MODIFY = t.CN_S_LOGIN;
                    entity.CN_S_MODIFY_BY = t.CN_S_NAME;
                    //修改
                    entity.CN_T_MODIFY = DateTime.Now;
                    //货主不能为空，暂时赋值
                    entity.CN_S_OWNER = Constants.DefaultOwner;
                    int rowNo = 1;
                    foreach (var inDtl in entity.DTLEntity)
                    {
                        inDtl.CN_GUID = Guid.NewGuid().ToString();
                        inDtl.CN_N_ROW_NO = rowNo++;
                        inDtl.CN_S_MSTGUID = entity.CN_GUID;
                        inDtl.CN_S_OP_NO = entity.CN_S_OP_NO;
                        inDtl.CN_S_STATE = entity.CN_S_STATE;
                        inDtl.CN_S_ITEM_STATE = string.IsNullOrEmpty(inDtl.CN_S_ITEM_STATE.ToString()) ? "合格" : inDtl.CN_S_ITEM_STATE.ToString();
                        inDtl.CN_C_IS_BALANCE = "N";
                        inDtl.CN_C_IS_SCRAP = "N";
                        inDtl.CN_F_UPSHELF_QTY = 0;
                        inDtl.CN_F_ALLOT_QTY = 0;
                        inDtl.CN_F_PRINTING_QTY = 0;
                        inDtl.CN_F_ADD_ONTRAY_QTY = 0;
                        inDtl.CN_T_CREATE = DateTime.Now;
                        inDtl.CN_S_CREATOR = entity.CN_S_CREATOR;
                        inDtl.CN_S_CREATOR_BY = entity.CN_S_CREATOR_BY;
                        inDtl.CN_T_MODIFY = DateTime.Now;
                        inDtl.CN_S_MODIFY = entity.CN_S_MODIFY;
                        inDtl.CN_S_MODIFY_BY = entity.CN_S_MODIFY_BY;
                    }
                    result = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().UpdateIncreaseInventory(entity);

                    if (result.Success && (entity.OperateMessage == Constants.Operate_EditAndSubmit))
                    {
                        List<TN_WM_B_EXAMINEEntity> examineList = new List<TN_WM_B_EXAMINEEntity>();
                        examineList.Add(new TN_WM_B_EXAMINEEntity()
                        {
                            CN_GUID = System.Guid.NewGuid().ToString().ToUpper(),
                            CN_S_EXAMINE_TYPE = Constants.State_Submit,
                            CN_S_OP_FROM = "入库单",
                            CN_S_FROM_NO = entity.CN_S_OP_NO,
                            CN_S_CREATOR = t.CN_S_LOGIN,
                            CN_S_CREATOR_BY = t.CN_S_NAME,
                            CN_T_CREATE = DateTime.Now,
                            CN_S_OPINION = "",
                            TokenId = entity.TokenId
                        });

                        return SubmitIncrease(examineList);
                    }
                    return result;
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 删除入库单
        /// <summary>
        /// 删除入库单
        /// </summary>
        /// <param name="opNo">入库单单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        [HttpGet]
        public OperateResult DeleteIncrease(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                      {
                          return BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().DeleteIncreaseInventory(opNo);
                      });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 提交入库单
        /// <summary>
        /// 提交入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        [HttpPost]
        public OperateResult SubmitIncrease(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                  {
                      return BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().Submit(entity);
                  });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 审核入库单
        /// <summary>
        /// 审核入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        [HttpPost]
        public OperateResult AuditIncrease(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                   {
                       return ChangeInOperate(entity[0].CN_S_FROM_NO, outMst =>
                       {
                           if (outMst.CN_S_STATE != Constants.State_Submit && outMst.CN_S_STATE != Constants.State_ReAudit)
                           {
                               return OperateResult.Error("该单据状态已被修改，请刷新页面");
                           }
                           return BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().Audit(entity);
                       });
                   });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 反审入库单
        /// <summary>
        /// 反审入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        [HttpPost]
        public OperateResult ReAuditIncrease(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                   {
                       return ChangeInOperate(entity[0].CN_S_FROM_NO, outMst =>
                       {
                           //反审时状态必须为 已审核
                           if (outMst.CN_S_STATE != Constants.State_Audit)
                           {
                               return OperateResult.Error("该单据状态已被修改，请刷新页面");
                           }
                           return BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().ReAudit(entity);
                       });
                   });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 取消入库单
        /// <summary>
        /// 取消入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-11</History>
        [HttpPost]
        public OperateResult CancelIncrease(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                {
                    return ChangeInOperate(entity[0].CN_S_FROM_NO, outMst =>
                    {
                        //取消时状态必须为 已审核
                        if (outMst.CN_S_STATE != Constants.State_Audit)
                        {
                            return OperateResult.Error("该单据状态已被修改，请刷新页面");
                        }
                        return BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().CancelIncrease(entity);
                    });
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 驳回入库单
        /// <summary>
        /// 驳回入库单
        /// </summary>
        /// <param name="entity">审批实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-14</History>
        [HttpPost]
        public OperateResult RejectIncrease(List<TN_WM_B_EXAMINEEntity> entity)
        {
            try
            {
                return ValidateToken(entity[0].TokenId, t =>
                     {
                         return ChangeInOperate(entity[0].CN_S_FROM_NO, outMst =>
                         {
                             string rejectMsg = Util.ToString(entity[0].CN_S_OPINION);
                             if (string.IsNullOrEmpty(rejectMsg))
                                 return OperateResult.Error("驳回意见不可为空");
                             //驳回时状态必须为 已提交
                             if (outMst.CN_S_STATE != Constants.State_Submit && outMst.CN_S_STATE != Constants.State_ReAudit)
                             {
                                 return OperateResult.Error("该单据状态已被修改，请刷新页面");
                             } //驳回实体
                             TN_WM_B_REJECTEntity rejectEntity = new TN_WM_B_REJECTEntity()
                             {
                                 CN_GUID = Guid.NewGuid().ToString(),
                                 CN_S_OP_FROM = Constants.Rule_OutOrder,
                                 CN_S_FROM_NO = entity[0].CN_S_FROM_NO,
                                 CN_S_OPINION = rejectMsg,
                                 CN_S_CREATOR = Util.ToString(entity[0].CN_S_CREATOR),
                                 CN_S_CREATOR_BY = Util.ToString(entity[0].CN_S_CREATOR_BY),
                                 CN_T_CREATE = DateTime.Now,
                                 CN_S_MODIFY = Util.ToString(entity[0].CN_S_CREATOR),
                                 CN_S_MODIFY_BY = Util.ToString(entity[0].CN_S_CREATOR_BY),
                                 CN_T_MODIFY = DateTime.Now
                             };
                             return BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().Reject(entity, rejectEntity);
                         });
                     });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 查询数据集
        /// <summary>
        /// 获取入库单列表
        /// </summary>
        /// <param name="searchModel">查询实体（页码，显示条数，条件等）</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-24</History>
        [HttpPost]
        public string GetIncreaseList(SearchModel searchModel)
        {
            return ValidateToken(searchModel.TokenId, t =>
                  {
                      //根据tokenId 获取当前登陆信息
                      OperateResult resultInfo = GetTokenInfo(searchModel.TokenId);
                      if (!resultInfo.Success) return JsonConvert.SerializeObject(resultInfo);
                      IsoDateTimeConverter timeFormat = new IsoDateTimeConverter();
                      timeFormat.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
                      // OperateResult pagingList = BLLCreator.Create<DapperBLL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetPagingResult(searchModel.PageIndex, searchModel.PageSize, searchModel.SearchCondition);

                      long total;
                      DataTable dt = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetIncreaseList(searchModel, out total, false);

                      OperateResult pagingList = OperateResult.Succeed("", new
                      {
                          rows = dt,
                          total = total
                      });
                      return JsonConvert.SerializeObject(pagingList, timeFormat);
                  });
        }

        /// <summary>
        /// 导出
        /// </summary>
        /// <param name="searchModel"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetIncreaseListExport(SearchModel searchModel)
        {
            return ValidateToken(searchModel.TokenId, t =>
            {
                //根据tokenId 获取当前登陆信息
                OperateResult resultInfo = GetTokenInfo(searchModel.TokenId);
                if (!resultInfo.Success) return JsonConvert.SerializeObject(resultInfo);
                IsoDateTimeConverter timeFormat = new IsoDateTimeConverter();
                timeFormat.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
                // OperateResult pagingList = BLLCreator.Create<DapperBLL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetPagingResult(searchModel.PageIndex, searchModel.PageSize, searchModel.SearchCondition);

                long total;
                DataTable dt = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetIncreaseList(searchModel, out total, true);

                OperateResult pagingList = OperateResult.Succeed("", new
                {
                    rows = dt,
                    total = total
                });
                return JsonConvert.SerializeObject(pagingList, timeFormat);
            });
        }
        #endregion

        #region 带出入库单实体
        /// <summary>
        /// 带出入库单实体
        /// </summary>
        /// <param name="opNo"></param>
        /// <param name="funcOut"></param>
        /// <returns></returns>
        public OperateResult ChangeInOperate(string opNo, Func<TN_WM_INCREASE_INVENTORY_MSTEntity, OperateResult> funcIn)
        {
            try
            {
                if (string.IsNullOrEmpty(opNo))
                    return OperateResult.Error("入库单号不可为空");
                var inMst = BLLCreator.Create<DapperBLL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetSingleEntity(new
                {
                    CN_S_OP_NO = opNo
                });
                if (inMst == null)
                    return OperateResult.Error("未找到入库单号：" + opNo);
                return funcIn(inMst);
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 获取入库单主表
        /// <summary>
        /// 获取入库单主表
        /// </summary>
        /// <param name="stockCode">仓库号</param>
        /// <param name="opType">业务类型</param>
        /// <param name="opNo">业务单号</param>
        /// <param name="opDate">业务日期</param>
        /// <returns></returns>
        /// <history>[HANHE(lt)] CREATED BY 2018-11-14</history>
        /// <history>[HANHE(dbs)] modify BY 2018-12-18</history>
        [HttpGet]
        public string GetListInventoryMst(string stockCode, string opType, string opNo, string opDate, string vendorName)
        {
            try
            {
                return ValidateToken(t =>
                {
                    var list = BLLCreator.Create<DapperBLL<TN_WM_INCREASE_INVENTORY_MSTEntity>>().GetList(new List<SearchWhere>() {
                        new SearchWhere(){ key="CN_S_STOCK_CODE", sign= WhereSign.Eq, value = stockCode},
                        new SearchWhere(){ key="CN_S_OP_TYPE", sign= WhereSign.Eq, value = opType},
                        new SearchWhere(){ key="CN_S_OP_NO", sign= WhereSign.Like, value=opNo},
                        new SearchWhere(){ key="CN_T_OPERATE", sign= WhereSign.TEq, value=opDate},
                        new SearchWhere(){ key="CN_S_VENDOR_NAME", sign= WhereSign.Like, value=vendorName}
                    }, new
                    {
                        CN_S_STOCK_CODE = stockCode,
                        CN_S_OP_TYPE = opType,
                        CN_S_OP_NO = "%" + opNo + "%",
                        CN_T_OPERATE = opDate,
                        CN_S_VENDOR_NAME = "%" + vendorName + "%"
                    }, false);

                    return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
                });
            }
            catch (Exception ex)
            {

                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }

        }

        /// <summary>
        /// 获取入库单
        /// </summary>
        /// <returns></returns>
        /// <history>[HANHE(lt)] CREATED BY 2018-11-14</history>
        [HttpGet]
        public string GetListInventoryDtl(string opNo)
        {
            try
            {
                var list = BLLCreator.Create<DapperBLL<TN_WM_INCREASE_INVENTORY_DTLEntity>>().GetList(new { CN_S_OP_NO = opNo });
                return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
            }
            catch (Exception ex)
            {

                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }

        }
        #endregion

        #region 获取入库订单
        /// <summary>
        /// 获取入库订单
        /// </summary>
        /// <returns></returns>
        /// <history>[HANHE(lt)] CREATED BY 2018-11-14</history>
        [HttpGet]
        public string GetInMstList(string opNo)
        {
            try
            {
                var sqlwhere = "";
                if (!string.IsNullOrEmpty(opNo))
                {

                    sqlwhere += " where CN_S_OP_NO like '%" + opNo + "%'";
                }
                var list = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetInMstList(sqlwhere);
                return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
            }
            catch (Exception ex)
            {

                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }

        }


        /// <summary>
        /// 获取入库订单
        /// </summary>
        /// <returns></returns>
        /// <history>[HANHE(lt)] CREATED BY 2018-11-14</history>
        [HttpGet]
        public string GetInDtlList(string opNo)
        {
            try
            {
                var sqlwhere = " ";
                if (!string.IsNullOrEmpty(opNo))
                {
                    sqlwhere += " where CN_S_OP_NO like '%" + opNo + "%'";
                }
                var list = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetInDtlList(sqlwhere);
                return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
            }
            catch (Exception ex)
            {

                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }

        }

        #endregion

        #region (物料)新增打码表数据
        /// <summary>
        /// (物料)新增打码表数据
        /// </summary>
        /// <returns></returns>
        /// <history>[HANHE(lt)] CREATED BY 2018-11-15</history>
        [HttpPost]
        public string AddItem(JObject obj)
        {

            try
            {
                bool bools = false;
                DataTable dtjson = JsonConvert.DeserializeObject<DataTable>(obj["list"].ToString());//打印实体
                List<string> itemCodeList = dtjson.AsEnumerable().Select(s => s.Field<string>("CN_S_ITEM_CODE")).ToList(); ;


                List<MONGO_PRINT_BARCODE> printbarlist = new List<MONGO_PRINT_BARCODE>();
                List<MONGO_KEYTYPE_MAP> Maplist = new List<MONGO_KEYTYPE_MAP>();
                List<AutoBomItemEntity> itemlist = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItemList(itemCodeList);
                foreach (DataRow dr in dtjson.Rows)//循环打印
                {
                    string guid = dr["key"].ToString();
                    MONGO_PRINT_BARCODE printbar = new MONGO_PRINT_BARCODE();
                    MONGO_KEYTYPE_MAP Map = new MONGO_KEYTYPE_MAP();//码值对照表

                    Map.Key = guid;
                    Map.Type = "1";
                    List<AutoBomItemEntity> itemEntity = itemlist.AsEnumerable().Where(w => w.CN_S_ITEM_CODE == dr["CN_S_ITEM_CODE"].ToString()).ToList();//选择
                    printbar.CN_S_UNIQUE_CODE = guid;
                    //printbar.CN_S_OWNER = dtwhere[0]["CN_S_OWNER"].ToString();
                    //printbar.CN_S_VENDOR_NO = dtwhere[0]["CN_S_VENDOR_NO"].ToString();
                    //printbar.CN_S_VENDOR_NAME = dtwhere[0]["CN_S_VENDOR_NAME"].ToString();

                    //printbar.CN_S_LOT_CODE = dtwhere[0]["CN_S_LOT_NO"].ToString();
                    //printbar.CN_S_SERAIL_NO = itemEntity[0].CN_S_SERIAL_CODE;
                    printbar.CN_S_ITEM_CODE = dr["CN_S_ITEM_CODE"].ToString();

                    printbar.CN_S_ITEM_NAME = itemEntity[0].CN_S_ITEM_NAME;
                    printbar.CN_S_MODEL = itemEntity[0].CN_S_MODEL;

                    // printbar.CN_S_QGP_UNIT = itemEntity;

                    printbar.CN_N_QGP = Convert.ToInt32(itemEntity[0].CN_F_WARRNTY_PARTS);


                    printbar.CN_C_IS_WARRANTY_PARTS = itemEntity[0].CN_C_IS_WARRNTY_PARTS;
                    printbar.CN_S_FIGURE_NO = itemEntity[0].CN_S_FIGURE_NO;
                    printbar.CN_S_PACKING_UNIT = dr["CN_F_PACKING_QTY"].ToString() + itemEntity[0].CN_S_MEASURE_UNIT;
                    printbar.CN_F_PACKING_QTY = Convert.ToInt32(dr["CN_F_PACKING_QTY"]);
                    printbar.CN_T_CREATE = DateTime.Now;

                    printbarlist.Add(printbar);
                    Maplist.Add(Map);
                    //}
                }
                if (printbarlist.Any() && Maplist.Any())
                {
                    bools = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().AddPrintBarcode(printbarlist);
                    bools = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().AddKeyType(Maplist);
                    if (!bools)
                    {
                        return JsonConvert.SerializeObject(OperateResult.Error("保存失败"));
                    }
                }

                return JsonConvert.SerializeObject(OperateResult.Succeed("", null));

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

        #region 获取物料信息
        /// <summary>
        /// 新增打码表数据
        /// </summary>
        /// <returns></returns>
        /// <history>[HANHE(lt)] CREATED BY 2018-11-26</history>
        public string GetItemList(string itemCode)
        {
            try
            {
                List<string> 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()));
            }
        }
        #endregion

        #region 获取未完全打印的入库单记录
        /// <summary>
        /// 获取未完全打印的入库单记录
        /// </summary>
        /// <param name="stockCode">仓库号</param>
        /// <returns></returns>
        /// <History>[HANHE(DBS)] CREATED BY 2019-02-28</History>
        public OperateResult GetWaitPrintOrder(string stockCode)
        {
            return ValidateToken(t =>
            {
                return BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetWaitPrintOrder(stockCode);
            });
        }
        #endregion

        #region PDA、外部调用全部接口
        /// <summary>
        /// 获取可上架入库单列表
        /// </summary>
        /// <param name="opNo">模糊查询条件：入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-13</History>
        [HttpGet]
        public string GetIncreaseInventoryList(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                    {
                        List<TN_WM_INCREASE_INVENTORY_MSTEntity> list = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetIncreaseInventoryList(opNo);
                        return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
                    });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        /// <summary>
        /// 获取可码盘入库单列表
        /// </summary>
        /// <param name="opNo">模糊查询条件：入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-13</History>
        [HttpGet]
        public string GetInListWithCodedisc(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                 {
                     List<TN_WM_INCREASE_INVENTORY_MSTEntity> list = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetInListWithCodedisc(opNo);
                     return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
                 });
            }
            catch (Exception ex)
            {
                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 GetIncreaseInventoryMstAndDtl(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                  {
                      TN_WM_INCREASE_INVENTORY_MSTEntity inMstEntity = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetIncreaseInventoryMstAndDtl(opNo);
                      return JsonConvert.SerializeObject(OperateResult.Succeed("", inMstEntity));
                  });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }

        /// <summary>
        /// 根据单号获取主子表信息-可码盘明细
        /// </summary>
        /// <param name="opNo">入库单号</param>
        /// <returns></returns>
        [HttpGet]
        public string GetInMstAndDtl_OnTray(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                {
                    TN_WM_INCREASE_INVENTORY_MSTEntity inMstEntity = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetInMstAndDtl_OnTray(opNo);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", inMstEntity));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }
        /// <summary>
        /// 根据单号获取主子表信息-可上架明细
        /// </summary>
        /// <param name="opNo">入库单号</param>
        /// <returns></returns>
        [HttpGet]
        public string GetInMstAndDtl_OnShelf(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                {
                    TN_WM_INCREASE_INVENTORY_MSTEntity inMstEntity = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetInMstAndDtl_OnShelf(opNo);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", inMstEntity));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }

        /// <summary>
        /// 根据入库单号获取入库单明细
        /// </summary>
        /// <param name="opNo">入库单号</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2018-11-13</History>
        [HttpGet]
        public string GetIncreaseInventoryDetail(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                  {
                      List<TN_WM_INCREASE_INVENTORY_DTLEntity> list = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetIncreaseInventoryDetail(opNo);


                      return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
                  });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }

        /// <summary>
        /// U8服务调用-新增入库单主子表、仓库库区量表
        /// </summary>
        /// <param name="mstList">入库单主子表集合</param>
        /// <returns></returns>
        [HttpPost]
        public string AddU8InData(List<TN_WM_INCREASE_INVENTORY_MSTEntity> mstList)
        {
            OperateResult or = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().AddU8InData(mstList);
            return JsonConvert.SerializeObject(or);

        }

        /// <summary>
        /// U8服务调用-调拨单更新物料状态
        /// </summary>
        /// <param name="transVouchList">集合</param>
        /// <returns></returns>
        [HttpPost]
        public string UpdateTransVouchItemState(List<U8_TransVouchEntity> transVouchList)
        {
            OperateResult or = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().UpdateTransVouchItemState(transVouchList);
            return JsonConvert.SerializeObject(or);

        }

        #region 还料单相关接口
        /// <summary>
        /// 新增-还料单
        /// </summary>
        /// <returns></returns>
        /// <history>[HANHE(xdl)] CREATED BY 2019-1-16</history>
        [HttpPost]
        public OperateResult SaveItemBack(JObject objData)
        {
            try
            {

                Log.Info("还料单传参", objData.ToString());
                ItemOnShelfEntity entity = JsonConvert.DeserializeObject<ItemOnShelfEntity>(objData.ToString());
                var oResult = ValidateToken(entity.TokenId, t =>
                {
                    if (t == null)
                    {
                        return OperateResult.Error("登陆人员信息获取失败！");
                    }

                    return BLLCreator.Create<TN_WM_ITEMBACK_MSTBLL>().SaveItemBack(entity, t);
                });
                return oResult;
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message.ToString());
            }
        }

        /// <summary>
        /// 获取可还料单列表
        /// </summary>
        /// <param name="CN_S_OP_NO">模糊查询条件：还料单号</param>
        /// <returns></returns>
        [HttpGet]
        public string GetItemBackList(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                {
                    List<TN_WM_ITEMBACK_MSTEntity> list = BLLCreator.Create<TN_WM_ITEMBACK_MSTBLL>().GetItemBackList(opNo);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", list));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }

        /// <summary>
        /// 根据单号获取主子表信息
        /// </summary>
        /// <param name="CN_S_OP_NO">模糊查询条件：还料单号</param>
        /// <returns></returns>
        [HttpGet]
        public string GetItemBackMstAndDtl(string opNo)
        {
            try
            {
                return ValidateToken(t =>
                {
                    TN_WM_ITEMBACK_MSTEntity mstEntity = BLLCreator.Create<TN_WM_ITEMBACK_MSTBLL>().GetItemBackMstAndDtl(opNo);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", mstEntity));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message.ToString()));
            }
        }

        #endregion

        /// <summary>
        /// PDA接口-获取待贴码信息
        /// </summary>
        /// <param name="packingCode">产品唯一码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-15</History>
        [HttpGet]
        public string GetFixedData(string packingCode)
        {
            try
            {
                return ValidateToken(t =>
                {
                    MONGO_PRINT_BARCODE printBarCode = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().GetValue(packingCode);
                    if (printBarCode != null)
                    {
                        DataTable dt = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetFixedData(printBarCode);
                        return JsonConvert.SerializeObject(OperateResult.Succeed("", dt));
                    }
                    else
                    {
                        return JsonConvert.SerializeObject(OperateResult.Succeed("码值 " + packingCode + " 无效！", null));
                    }
                });
            }
            catch (Exception ex)
            {
                Log.Info("获取待贴码信息报错", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }


        }

        /// <summary>
        /// PDA接口-贴码确认
        /// </summary>
        /// <param name="json">数据Json实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-15</History>
        [HttpPost]
        public string FixedConfirm(JObject json)
        {
            try
            {
                string tokenId = json.Value<string>("tokenId");
                return ValidateToken(tokenId, t =>
                 {
                     OperateResult result = new OperateResult();
                     string packingCode = json.Value<string>("packingCode");
                     MONGO_PRINT_BARCODE printBarCode = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().GetValue(packingCode);
                     if (printBarCode != null)
                     {
                         result = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().FixedConfirm(printBarCode);
                         return JsonConvert.SerializeObject(result);
                     }
                     else
                     {
                         return JsonConvert.SerializeObject(OperateResult.Succeed("码值 " + packingCode + " 无效！", null));
                     }
                 });
            }
            catch (Exception ex)
            {
                Log.Info("贴码确认", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }
        }

        /// <summary>
        /// PDA接口-获取搬运信息
        /// </summary>
        /// <param name="packingCode">产品唯一码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-15</History>
        [HttpGet]
        public string GetTransData(string packingCode)
        {
            try
            {
                return ValidateToken(t =>
                {
                    MONGO_PRINT_BARCODE printBarCode = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().GetValue(packingCode);
                    if (printBarCode != null)
                    {
                        OperateResult oresult = new OperateResult();
                        oresult = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetTransData(printBarCode);
                        return JsonConvert.SerializeObject(oresult);
                    }
                    else
                    {
                        return JsonConvert.SerializeObject(OperateResult.Succeed("码值 " + packingCode + " 无效！", null));
                    }
                });
            }
            catch (Exception ex)
            {
                Log.Info("获取搬运信息", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }

        }

        /// <summary>
        ///  PDA接口-搬运确认
        /// </summary>
        /// <param name="json">数据Json实体</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-15</History>
        [HttpPost]
        public string TransConfirm(List<JObject> json)
        {
            OperateResult finalResult = new OperateResult();
            try
            {
                string tokenId = json[0].Value<string>("tokenId");
                return ValidateToken(tokenId, t =>
                {
                    List<OperateResult> results = new List<OperateResult>();
                    foreach (var _json in json)
                    {
                        OperateResult result = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().TransConfirm(_json);
                        results.Add(result);
                    }
                    results = results.FindAll(p => !p.Success);
                    if (results.Any())
                    {
                        List<string> msgs = new List<string>();
                        results.ForEach(p =>
                        {
                            if (p.Msg != null)
                                msgs.Add(p.Msg);
                        });
                        finalResult.Success = false;
                        finalResult.Msg = string.Join(",", msgs);
                    }
                    else
                    {
                        finalResult.Success = true;
                        finalResult.Msg = "搬运确认成功！";
                    }

                    return JsonConvert.SerializeObject(finalResult);
                });
            }
            catch (Exception ex)
            {
                Log.Info("搬运确认", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }
        }

        /// <summary>
        /// PDA接口-获取物料所在库区
        /// </summary>
        /// <param name="packingCode">产品唯一码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-19</History>
        [HttpGet]
        public string GetItemStockArea(string packingCode)
        {
            try
            {
                return ValidateToken(t =>
                {
                    MONGO_PRINT_BARCODE printBarCode = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().GetValue(packingCode);
                    if (printBarCode != null)
                    {
                        OperateResult oresult = new OperateResult();
                        oresult = BLLCreator.Create<TN_WM_INCREASE_INVENTORYBLL>().GetItemStockArea(printBarCode);
                        return JsonConvert.SerializeObject(oresult);
                    }
                    else
                    {
                        return JsonConvert.SerializeObject(OperateResult.Succeed("码值 " + packingCode + " 无效！", null));
                    }
                });
            }
            catch (Exception ex)
            {
                Log.Info("获取物料所在库区", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }

        }
        
        /// <summary>
        ///  PDA接口-根据托盘码获取存放容量
        /// </summary>
        /// <param name="trayCode">托盘码</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-19</History>
        [HttpGet]
        public string GetCapacityinfoByTrayCode(string trayCode)
        {
            try
            {
                return ValidateToken(t =>
                {
                        OperateResult oresult = new OperateResult();
                        oresult = BLLCreator.Create<TN_WM_B_TRAY_CAPACITYBLL>().GetCapacityinfoByTrayCode(trayCode);
                        return JsonConvert.SerializeObject(oresult);
                });
            }
            catch (Exception ex)
            {
                Log.Info("根据托盘码获取存放容量", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }
        }

        /// <summary>
        /// PDA接口-获取物料明细（根据产品码）
        /// </summary>
        /// <param name="scanCode">条码</param>
        /// <param name="codeType">条码类型</param>
        /// <returns></returns>
        /// <History>[HANHE(XDL)] CREATED BY 2019-03-19</History>
        [HttpGet]
        public string GetItemDetail(string scanCode, string codeType)
        {
            try
            {
                return ValidateToken(t =>
                {
                    OperateResult oresult = new OperateResult();
                    oresult = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItemDetail(scanCode, codeType);
                    return JsonConvert.SerializeObject(oresult);
                });
            }
            catch (Exception ex)
            {
                Log.Info("获取物料明细", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }
        }

        /// <summary>
        /// PDA接口-根据托盘码里面物料获取库区
        /// </summary>
        /// <param name="trayCode">托盘码</param>
        /// <history>[HanHe(XDL)] CREATED 2019/04/11</history>
        [HttpGet]
        public string GetTrayItemByArea(string trayCode)
        {
            try
            {
                return ValidateToken(t =>
                {
                    OperateResult oresult = new OperateResult();
                    oresult = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemByArea(trayCode);
                    return JsonConvert.SerializeObject(oresult);
                });
            }
            catch (Exception ex)
            {
                Log.Info("根据托盘码里面物料获取库区", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }
          
        }


        /// <summary>
        /// PDA接口-整托获取建议货位
        /// </summary>
        /// <param name="trayCode">托盘码</param>
        /// <param name="platformArea">分拣台</param>
        /// <param name="stockArea">库区</param>
        /// <returns></returns>
        /// <history>[HanHe(XDL)] CREATED 2019/04/11</history>
        [HttpGet]
        public string ZTGetLocationCode(string trayCode, string platformArea, string stockArea)
        {
            try
            {
                return ValidateToken(t =>
                {
                    OperateResult oresult = new OperateResult();
                    oresult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().ZTGetLocationCode(trayCode, platformArea, stockArea);
                    return JsonConvert.SerializeObject(oresult);
                });
            }
            catch (Exception ex)
            {
                Log.Info("整托获取建议货位", ex.Message.ToString());
                return JsonConvert.SerializeObject(OperateResult.Succeed("抛异常！", ex.Message.ToString()));
            }
        }




        #endregion
    }
}