using System;
using System.Collections.Generic;
using System.Web.Http;
using System.Web.Http.Description;

namespace GSYWApi.Controllers
{
    /// <summary>
    /// 进销存相关接口
    /// </summary>
    public class InSalesController : BaseController
    {
        #region 获取采购单列表
        /// <summary>
        /// 获取采购单列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetPurchaseList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.PURCHASEModel>>))]
        public IHttpActionResult GetPurchaseList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取采购单列表
                List<Model.PURCHASEModel> PURCHASEList = Helper.PURCHASEHelper.GetPURCHASEList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.PURCHASEModel> jsonList = Models.JsonList<Model.PURCHASEModel>.Success(
                    PURCHASEList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.PURCHASEModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPurchaseList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取采购单列表
        /// <summary>
        /// 获取采购单列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetPURCHASEList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.PURCHASEModel>>))]
        public IHttpActionResult GetPURCHASEList(Models.SearchModel<Model.PURCHASEModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取采购单列表
                List<Model.PURCHASEModel> PURCHASEList = Helper.PURCHASEHelper.GetPURCHASEList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.PURCHASEModel> jsonList = Models.JsonList<Model.PURCHASEModel>.Success(
                    PURCHASEList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.PURCHASEModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPURCHASEList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取采购单明细
        /// <summary>
        /// 获取采购单明细
        /// </summary>
        /// <param name="PURCHASEId"></param>
        /// <returns></returns>
        [Route("InSales/GetPurchaseDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.PURCHASEModel>))]
        public IHttpActionResult GetPurchaseDetail(int PURCHASEId)
        {
            string Parameter = "入参信息：采购单内码【" + PURCHASEId + "】";
            try
            {
                //获取采购单明细
                Model.PURCHASEModel purchaseModel = Helper.PURCHASEHelper.GetPURCHASEDetail(transaction, PURCHASEId);

                return Ok(Models.JsonMsg<Model.PURCHASEModel>.Success(purchaseModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPurchaseDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步采购单
        /// <summary>
        /// 同步采购单
        /// </summary>
        /// <param name="purchaseModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroPurchase")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroPurchase(Model.PURCHASEModel purchaseModel)
        {
            try
            {
                //新增采购单
                bool SynchroFlag = Helper.PURCHASEHelper.SynchroPURCHASE(transaction, purchaseModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroPurchase");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除采购单
        /// <summary>
        /// 删除采购单
        /// </summary>
        /// <param name="PurchaseId">采购单内码</param>
        /// <returns></returns>
        [Route("InSales/DeletePurchase")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeletePurchase(int PurchaseId)
        {
            string Parameter = "入参信息：采购单内码【" + PurchaseId + "】";
            try
            {
                //删除采购单
                bool DeleteFlag = Helper.PURCHASEHelper.DeletePURCHASE(transaction, PurchaseId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeletePurchase");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取采购明细列表
        /// <summary>
        /// 获取采购明细列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetPurchaseDetailList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.PURCHASEDETAILModel>>))]
        public IHttpActionResult GetPurchaseDetailList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取采购明细列表
                List<Model.PURCHASEDETAILModel> PURCHASEDETAILList = Helper.PURCHASEDETAILHelper.GetPURCHASEDETAILList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.PURCHASEDETAILModel> jsonList = Models.JsonList<Model.PURCHASEDETAILModel>.Success(
                    PURCHASEDETAILList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.PURCHASEDETAILModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPurchaseDetailList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取采购明细列表
        /// <summary>
        /// 获取采购明细列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetPURCHASEDETAILList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.PURCHASEDETAILModel>>))]
        public IHttpActionResult GetPURCHASEDETAILList(Models.SearchModel<Model.PURCHASEDETAILModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取采购明细列表
                List<Model.PURCHASEDETAILModel> PURCHASEDETAILList = Helper.PURCHASEDETAILHelper.GetPURCHASEDETAILList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.PURCHASEDETAILModel> jsonList = Models.JsonList<Model.PURCHASEDETAILModel>.Success(
                    PURCHASEDETAILList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.PURCHASEDETAILModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPURCHASEDETAILList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取采购明细
        /// <summary>
        /// 获取采购明细
        /// </summary>
        /// <param name="PurchaseDetailId">采购明细内码</param>
        /// <returns></returns>
        [Route("InSales/GetPurchaseDetailDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.PURCHASEDETAILModel>))]
        public IHttpActionResult GetPurchaseDetailDetail(int PurchaseDetailId)
        {
            string Parameter = "入参信息：采购明细内码【" + PurchaseDetailId + "】";
            try
            {
                //获取采购明细明细
                Model.PURCHASEDETAILModel purchasedetailModel = Helper.PURCHASEDETAILHelper.GetPURCHASEDETAILDetail(
                    transaction, PurchaseDetailId);

                return Ok(Models.JsonMsg<Model.PURCHASEDETAILModel>.Success(purchasedetailModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPurchaseDetailDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步采购明细
        /// <summary>
        /// 同步采购明细
        /// </summary>
        /// <param name="purchasedetailModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroPurchaseDetail")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroPurchaseDetail(Model.PURCHASEDETAILModel purchasedetailModel)
        {
            try
            {
                //新增采购明细
                bool SynchroFlag = Helper.PURCHASEDETAILHelper.SynchroPURCHASEDETAIL(transaction, purchasedetailModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroPurchaseDetail");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除采购明细
        /// <summary>
        /// 删除采购明细
        /// </summary>
        /// <param name="PurchaseDetailId">采购明细内码</param>
        /// <returns></returns>
        [Route("InSales/DeletePurchaseDetail")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeletePurchaseDetail(int PurchaseDetailId)
        {
            string Parameter = "入参信息：采购明细内码【" + PurchaseDetailId + "】";
            try
            {
                //删除采购明细
                bool DeleteFlag = Helper.PURCHASEDETAILHelper.DeletePURCHASEDETAIL(transaction, PurchaseDetailId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeletePurchaseDetail");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取入库信息列表
        /// <summary>
        /// 获取入库信息列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetReceiveServerpartList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.RECEIVESERVERPARTModel>>))]
        public IHttpActionResult GetReceiveServerpartList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取入库信息列表
                List<Model.RECEIVESERVERPARTModel> RECEIVESERVERPARTList = Helper.RECEIVESERVERPARTHelper.GetRECEIVESERVERPARTList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.RECEIVESERVERPARTModel> jsonList = Models.JsonList<Model.RECEIVESERVERPARTModel>.Success(
                    RECEIVESERVERPARTList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.RECEIVESERVERPARTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetReceiveServerpartList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取入库信息列表
        /// <summary>
        /// 获取入库信息列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetRECEIVESERVERPARTList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.RECEIVESERVERPARTModel>>))]
        public IHttpActionResult GetRECEIVESERVERPARTList(Models.SearchModel<Model.RECEIVESERVERPARTModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取入库信息列表
                List<Model.RECEIVESERVERPARTModel> RECEIVESERVERPARTList = Helper.RECEIVESERVERPARTHelper.GetRECEIVESERVERPARTList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.RECEIVESERVERPARTModel> jsonList = Models.JsonList<Model.RECEIVESERVERPARTModel>.Success(
                    RECEIVESERVERPARTList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.RECEIVESERVERPARTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetRECEIVESERVERPARTList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取入库信息详情
        /// <summary>
        /// 获取入库信息详情
        /// </summary>
        /// <param name="ReceiveServerpartId">入库信息详情</param>
        /// <returns></returns>
        [Route("InSales/GetReceiveServerpartDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.RECEIVESERVERPARTModel>))]
        public IHttpActionResult GetReceiveServerpartDetail(int ReceiveServerpartId)
        {
            string Parameter = "入参信息：入库信息内码【" + ReceiveServerpartId + "】";
            try
            {
                //获取入库信息明细
                Model.RECEIVESERVERPARTModel receiveserverpartModel = Helper.RECEIVESERVERPARTHelper.GetRECEIVESERVERPARTDetail(
                    transaction, ReceiveServerpartId);

                return Ok(Models.JsonMsg<Model.RECEIVESERVERPARTModel>.Success(receiveserverpartModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetReceiveServerpartDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步入库信息
        /// <summary>
        /// 同步入库信息
        /// </summary>
        /// <param name="receiveserverpartModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroReceiveServerpart")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroReceiveServerpart(Model.RECEIVESERVERPARTModel receiveserverpartModel)
        {
            try
            {
                //新增入库信息
                bool SynchroFlag = Helper.RECEIVESERVERPARTHelper.SynchroRECEIVESERVERPART(transaction, receiveserverpartModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroReceiveServerpart");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除入库信息
        /// <summary>
        /// 删除入库信息
        /// </summary>
        /// <param name="ReceiveServerpartId">入库信息内码</param>
        /// <returns></returns>
        [Route("InSales/DeleteReceiveServerpart")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteReceiveServerpart(int ReceiveServerpartId)
        {
            string Parameter = "入参信息：入库信息内码【" + ReceiveServerpartId + "】";
            try
            {
                //删除入库信息
                bool DeleteFlag = Helper.RECEIVESERVERPARTHelper.DeleteRECEIVESERVERPART(transaction, ReceiveServerpartId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteReceiveServerpart");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取入库明细列表
        /// <summary>
        /// 获取入库明细列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetReceiveDetailServerpartList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.RECEIVEDETAILSERVERPARTModel>>))]
        public IHttpActionResult GetReceiveDetailServerpartList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取入库详情列表
                List<Model.RECEIVEDETAILSERVERPARTModel> RECEIVEDETAILSERVERPARTList =
                    Helper.RECEIVEDETAILSERVERPARTHelper.GetRECEIVEDETAILSERVERPARTList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.RECEIVEDETAILSERVERPARTModel> jsonList = Models.JsonList<Model.RECEIVEDETAILSERVERPARTModel>.Success(
                    RECEIVEDETAILSERVERPARTList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.RECEIVEDETAILSERVERPARTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetReceiveDetailServerpartList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取入库详情列表
        /// <summary>
        /// 获取入库详情列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetRECEIVEDETAILSERVERPARTList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.RECEIVEDETAILSERVERPARTModel>>))]
        public IHttpActionResult GetRECEIVEDETAILSERVERPARTList(Models.SearchModel<Model.RECEIVEDETAILSERVERPARTModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取入库详情列表
                List<Model.RECEIVEDETAILSERVERPARTModel> RECEIVEDETAILSERVERPARTList = Helper.RECEIVEDETAILSERVERPARTHelper.GetRECEIVEDETAILSERVERPARTList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.RECEIVEDETAILSERVERPARTModel> jsonList = Models.JsonList<Model.RECEIVEDETAILSERVERPARTModel>.Success(
                    RECEIVEDETAILSERVERPARTList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.RECEIVEDETAILSERVERPARTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetRECEIVEDETAILSERVERPARTList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取入库明细
        /// <summary>
        /// 获取入库明细
        /// </summary>
        /// <param name="ReceiveDetailServerpartId">入库明细内码</param>
        /// <returns></returns>
        [Route("InSales/GetReceiveDetailServerpartDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.RECEIVEDETAILSERVERPARTModel>))]
        public IHttpActionResult GetRECEIVEDETAILSERVERPARTDetail(int ReceiveDetailServerpartId)
        {
            string Parameter = "入参信息：入库详情内码【" + ReceiveDetailServerpartId + "】";
            try
            {
                //获取入库详情明细
                Model.RECEIVEDETAILSERVERPARTModel receivedetailserverpartModel =
                    Helper.RECEIVEDETAILSERVERPARTHelper.GetRECEIVEDETAILSERVERPARTDetail(transaction, ReceiveDetailServerpartId);

                return Ok(Models.JsonMsg<Model.RECEIVEDETAILSERVERPARTModel>.Success(receivedetailserverpartModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetReceiveDetailServerpartDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步入库明细
        /// <summary>
        /// 同步入库明细
        /// </summary>
        /// <param name="receivedetailserverpartModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroReceiveDetailServerpart")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroReceiveDetailServerpart(Model.RECEIVEDETAILSERVERPARTModel receivedetailserverpartModel)
        {
            try
            {
                //新增入库详情
                bool SynchroFlag = Helper.RECEIVEDETAILSERVERPARTHelper.SynchroRECEIVEDETAILSERVERPART(transaction, receivedetailserverpartModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroReceiveDetailServerpart");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除入库明细
        /// <summary>
        /// 删除入库明细
        /// </summary>
        /// <param name="ReceiveDetailServerpartId">入库明细内码</param>
        /// <returns></returns>
        [Route("InSales/DeleteReceiveDetailServerpart")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteReceiveDetailServerpart(int ReceiveDetailServerpartId)
        {
            string Parameter = "入参信息：入库详情内码【" + ReceiveDetailServerpartId + "】";
            try
            {
                //删除入库详情
                bool DeleteFlag = Helper.RECEIVEDETAILSERVERPARTHelper.DeleteRECEIVEDETAILSERVERPART(transaction, ReceiveDetailServerpartId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteReceiveDetailServerpart");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取项目流程表列表
        /// <summary>
        /// 获取项目流程表列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetSaleStoreProinstList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.SALESTOREPROINSTModel>>))]
        public IHttpActionResult GetSaleStoreProinstList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取项目流程表列表
                List<Model.SALESTOREPROINSTModel> SALESTOREPROINSTList = Helper.SALESTOREPROINSTHelper.GetSALESTOREPROINSTList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.SALESTOREPROINSTModel> jsonList = Models.JsonList<Model.SALESTOREPROINSTModel>.Success(
                    SALESTOREPROINSTList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.SALESTOREPROINSTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetSaleStoreProinstList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取项目流程表列表
        /// <summary>
        /// 获取项目流程表列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetSALESTOREPROINSTList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.SALESTOREPROINSTModel>>))]
        public IHttpActionResult GetSALESTOREPROINSTList(Models.SearchModel<Model.SALESTOREPROINSTModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取项目流程表列表
                List<Model.SALESTOREPROINSTModel> SALESTOREPROINSTList = Helper.SALESTOREPROINSTHelper.GetSALESTOREPROINSTList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.SALESTOREPROINSTModel> jsonList = Models.JsonList<Model.SALESTOREPROINSTModel>.Success(
                    SALESTOREPROINSTList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.SALESTOREPROINSTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetSALESTOREPROINSTList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取项目流程表明细
        /// <summary>
        /// 获取项目流程表明细
        /// </summary>
        /// <param name="SaleStoreProinstId">项目流程内码</param>
        /// <returns></returns>
        [Route("InSales/GetSaleStoreProinstDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.SALESTOREPROINSTModel>))]
        public IHttpActionResult GetSaleStoreProinstDetail(int SaleStoreProinstId)
        {
            string Parameter = "入参信息：项目流程表内码【" + SaleStoreProinstId + "】";
            try
            {
                //获取项目流程表明细
                Model.SALESTOREPROINSTModel salestoreproinstModel = 
                    Helper.SALESTOREPROINSTHelper.GetSALESTOREPROINSTDetail(transaction, SaleStoreProinstId);

                return Ok(Models.JsonMsg<Model.SALESTOREPROINSTModel>.Success(salestoreproinstModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetSaleStoreProinstDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步项目流程表
        /// <summary>
        /// 同步项目流程表
        /// </summary>
        /// <param name="salestoreproinstModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroSaleStoreProinst")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroSaleStoreProinst(Model.SALESTOREPROINSTModel salestoreproinstModel)
        {
            try
            {
                //新增项目流程表
                bool SynchroFlag = Helper.SALESTOREPROINSTHelper.SynchroSALESTOREPROINST(transaction, salestoreproinstModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroSaleStoreProinst");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除项目流程表
        /// <summary>
        /// 删除项目流程表
        /// </summary>
        /// <param name="SaleStoreProinstId">项目流程内码</param>
        /// <returns></returns>
        [Route("InSales/DeleteSaleStoreProinst")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteSaleStoreProinst(int SaleStoreProinstId)
        {
            string Parameter = "入参信息：项目流程表内码【" + SaleStoreProinstId + "】";
            try
            {
                //删除项目流程表
                bool DeleteFlag = Helper.SALESTOREPROINSTHelper.DeleteSALESTOREPROINST(transaction, SaleStoreProinstId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteSaleStoreProinst");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取领用表列表
        [Route("InSales/GetReceiveCommodityList")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.RECEIVECOMMODITYModel>>))]
        public IHttpActionResult GetReceiveCommodityList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取领用表列表
                List<Model.RECEIVECOMMODITYModel> RECEIVECOMMODITYList = Helper.RECEIVECOMMODITYHelper.GetRECEIVECOMMODITYList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.RECEIVECOMMODITYModel> jsonList = Models.JsonList<Model.RECEIVECOMMODITYModel>.Success(
                    RECEIVECOMMODITYList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.RECEIVECOMMODITYModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetReceiveCommodityList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取领用表明细
        [Route("InSales/GetReceiveCommodityDetail")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<Model.RECEIVECOMMODITYModel>))]
        public IHttpActionResult GetReceiveCommodityDetail(int ReceiveCommodityId)
        {
            string Parameter = "入参信息：领用表内码【" + ReceiveCommodityId + "】";
            try
            {
                //获取领用表明细
                Model.RECEIVECOMMODITYModel receivecommodityModel =
                    Helper.RECEIVECOMMODITYHelper.GetRECEIVECOMMODITYDetail(transaction, ReceiveCommodityId);

                return Ok(Models.JsonMsg<Model.RECEIVECOMMODITYModel>.Success(receivecommodityModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetReceiveCommodityDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步领用表
        [Route("InSales/SynchroReceiveCommodity")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroReceiveCommodity(Model.RECEIVECOMMODITYModel receivecommodityModel)
        {
            try
            {
                //新增领用表
                bool SynchroFlag = Helper.RECEIVECOMMODITYHelper.SynchroRECEIVECOMMODITY(transaction, receivecommodityModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroReceiveCommodity");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除领用表
        [Route("InSales/DeleteReceiveCommodity")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteReceiveCommodity(int ReceiveCommodityId)
        {
            string Parameter = "入参信息：领用表内码【" + ReceiveCommodityId + "】";
            try
            {
                //删除领用表
                bool DeleteFlag = Helper.RECEIVECOMMODITYHelper.DeleteRECEIVECOMMODITY(transaction, ReceiveCommodityId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteReceiveCommodity");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取调拨列表
        /// <summary>
        /// 获取调拨列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetPrepareCommodityList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.PREPARECOMMODITYModel>>))]
        public IHttpActionResult GetPrepareCommodityList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取调拨表列表
                List<Model.PREPARECOMMODITYModel> PREPARECOMMODITYList = Helper.PREPARECOMMODITYHelper.GetPREPARECOMMODITYList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.PREPARECOMMODITYModel> jsonList = Models.JsonList<Model.PREPARECOMMODITYModel>.Success(
                    PREPARECOMMODITYList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.PREPARECOMMODITYModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPrepareCommodityList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取调拨列表
        /// <summary>
        /// 获取调拨列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetPREPARECOMMODITYList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.PREPARECOMMODITYModel>>))]
        public IHttpActionResult GetPREPARECOMMODITYList(Models.SearchModel<Model.PREPARECOMMODITYModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取调拨列表
                List<Model.PREPARECOMMODITYModel> PREPARECOMMODITYList = Helper.PREPARECOMMODITYHelper.GetPREPARECOMMODITYList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.PREPARECOMMODITYModel> jsonList = Models.JsonList<Model.PREPARECOMMODITYModel>.Success(
                    PREPARECOMMODITYList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.PREPARECOMMODITYModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPREPARECOMMODITYList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取调拨表明细
        /// <summary>
        /// 获取调拨表明细
        /// </summary>
        /// <param name="PrepareCommodityId">调拨内码</param>
        /// <returns></returns>
        [Route("InSales/GetPrepareCommodityDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.PREPARECOMMODITYModel>))]
        public IHttpActionResult GetPrepareCommodityDetail(int PrepareCommodityId)
        {
            string Parameter = "入参信息：调拨表内码【" + PrepareCommodityId + "】";
            try
            {
                //获取调拨表明细
                Model.PREPARECOMMODITYModel preparecommodityModel = 
                    Helper.PREPARECOMMODITYHelper.GetPREPARECOMMODITYDetail(transaction, PrepareCommodityId);

                return Ok(Models.JsonMsg<Model.PREPARECOMMODITYModel>.Success(preparecommodityModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetPrepareCommodityDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步调拨表
        /// <summary>
        /// 同步调拨表
        /// </summary>
        /// <param name="preparecommodityModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroPrepareCommodity")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroPrepareCommodity(Model.PREPARECOMMODITYModel preparecommodityModel)
        {
            try
            {
                //新增调拨表
                bool SynchroFlag = Helper.PREPARECOMMODITYHelper.SynchroPREPARECOMMODITY(transaction, preparecommodityModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroPrepareCommodity");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除调拨表
        /// <summary>
        /// 删除调拨表
        /// </summary>
        /// <param name="PrepareCommodityId">调拨内码</param>
        /// <returns></returns>
        [Route("InSales/DeletePrepareCommodity")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeletePrepareCommodity(int PrepareCommodityId)
        {
            string Parameter = "入参信息：调拨表内码【" + PrepareCommodityId + "】";
            try
            {
                //删除调拨表
                bool DeleteFlag = Helper.PREPARECOMMODITYHelper.DeletePREPARECOMMODITY(transaction, PrepareCommodityId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeletePrepareCommodity");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取库存操作记录列表
        /// <summary>
        /// 获取库存操作记录列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetStockLogList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.STOCKLOGModel>>))]
        public IHttpActionResult GetStockLogList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取库存操作记录表列表
                List<Model.STOCKLOGModel> STOCKLOGList = Helper.STOCKLOGHelper.GetSTOCKLOGList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.STOCKLOGModel> jsonList = Models.JsonList<Model.STOCKLOGModel>.Success(
                    STOCKLOGList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.STOCKLOGModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetStockLogList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取库存操作记录列表
        /// <summary>
        /// 获取库存操作记录列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetSTOCKLOGList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.STOCKLOGModel>>))]
        public IHttpActionResult GetSTOCKLOGList(Models.SearchModel<Model.STOCKLOGModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取库存操作记录列表
                List<Model.STOCKLOGModel> STOCKLOGList = Helper.STOCKLOGHelper.GetSTOCKLOGList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.STOCKLOGModel> jsonList = Models.JsonList<Model.STOCKLOGModel>.Success(
                    STOCKLOGList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.STOCKLOGModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetSTOCKLOGList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取盘存表列表
        /// <summary>
        /// 获取盘存表列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetCheckCommodityList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.CHECKCOMMODITYModel>>))]
        public IHttpActionResult GetCheckCommodityList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取盘存表列表
                List<Model.CHECKCOMMODITYModel> CHECKCOMMODITYList = Helper.CHECKCOMMODITYHelper.GetCHECKCOMMODITYList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.CHECKCOMMODITYModel> jsonList = Models.JsonList<Model.CHECKCOMMODITYModel>.Success(
                    CHECKCOMMODITYList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.CHECKCOMMODITYModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetCheckCommodityList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取盘存表列表
        /// <summary>
        /// 获取盘存表列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetCHECKCOMMODITYList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.CHECKCOMMODITYModel>>))]
        public IHttpActionResult GetCHECKCOMMODITYList(Models.SearchModel<Model.CHECKCOMMODITYModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取盘存表列表
                List<Model.CHECKCOMMODITYModel> CHECKCOMMODITYList = Helper.CHECKCOMMODITYHelper.GetCHECKCOMMODITYList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.CHECKCOMMODITYModel> jsonList = Models.JsonList<Model.CHECKCOMMODITYModel>.Success(
                    CHECKCOMMODITYList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.CHECKCOMMODITYModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetCHECKCOMMODITYList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取盘存表明细
        /// <summary>
        /// 获取盘存表明细
        /// </summary>
        /// <param name="CheckCommodityId">盘存表内码</param>
        /// <returns></returns>
        [Route("InSales/GetCheckCommodityDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.CHECKCOMMODITYModel>))]
        public IHttpActionResult GetCheckCommodityDetail(int CheckCommodityId)
        {
            string Parameter = "入参信息：盘存表内码【" + CheckCommodityId + "】";
            try
            {
                //获取盘存表明细
                Model.CHECKCOMMODITYModel checkcommodityModel =
                    Helper.CHECKCOMMODITYHelper.GetCHECKCOMMODITYDetail(transaction, CheckCommodityId);

                return Ok(Models.JsonMsg<Model.CHECKCOMMODITYModel>.Success(checkcommodityModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetCheckCommodityDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步盘存表
        /// <summary>
        /// 同步盘存表
        /// </summary>
        /// <param name="checkcommodityModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroCheckCommodity")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroCheckCommodity(Model.CHECKCOMMODITYModel checkcommodityModel)
        {
            try
            {
                //新增盘存表
                bool SynchroFlag = Helper.CHECKCOMMODITYHelper.SynchroCHECKCOMMODITY(transaction, checkcommodityModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroCheckCommodity");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除盘存表
        /// <summary>
        /// 删除盘存表
        /// </summary>
        /// <param name="CheckCommodityId">盘存表内码</param>
        /// <returns></returns>
        [Route("InSales/DeleteCheckCommodity")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteCheckCommodity(int CheckCommodityId)
        {
            string Parameter = "入参信息：盘存表内码【" + CheckCommodityId + "】";
            try
            {
                //删除盘存表
                bool DeleteFlag = Helper.CHECKCOMMODITYHelper.DeleteCHECKCOMMODITY(transaction, CheckCommodityId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteCheckCommodity");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取盘存明细列表
        /// <summary>
        /// 获取盘存明细列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetCheckCommodityDetailList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.CHECKCOMMODITYDETAILModel>>))]
        public IHttpActionResult GetCheckCommodityDetailList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取盘存明细列表
                List<Model.CHECKCOMMODITYDETAILModel> CHECKCOMMODITYDETAILList = Helper.CHECKCOMMODITYDETAILHelper.GetCHECKCOMMODITYDETAILList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.CHECKCOMMODITYDETAILModel> jsonList = Models.JsonList<Model.CHECKCOMMODITYDETAILModel>.Success(
                    CHECKCOMMODITYDETAILList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.CHECKCOMMODITYDETAILModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetCheckCommodityDetailList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取盘存明细列表
        /// <summary>
        /// 获取盘存明细列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetCHECKCOMMODITYDETAILList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.CHECKCOMMODITYDETAILModel>>))]
        public IHttpActionResult GetCHECKCOMMODITYDETAILList(Models.SearchModel<Model.CHECKCOMMODITYDETAILModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取盘存明细列表
                List<Model.CHECKCOMMODITYDETAILModel> CHECKCOMMODITYDETAILList = Helper.CHECKCOMMODITYDETAILHelper.GetCHECKCOMMODITYDETAILList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.CHECKCOMMODITYDETAILModel> jsonList = Models.JsonList<Model.CHECKCOMMODITYDETAILModel>.Success(
                    CHECKCOMMODITYDETAILList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.CHECKCOMMODITYDETAILModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetCHECKCOMMODITYDETAILList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取盘存明细
        /// <summary>
        /// 获取盘存明细
        /// </summary>
        /// <param name="CheckCommodityDetailId">盘存明细内码</param>
        /// <returns></returns>
        [Route("InSales/GetCheckCommodityDetailInfo")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.CHECKCOMMODITYDETAILModel>))]
        public IHttpActionResult GetCheckCommodityDetailInfo(int CheckCommodityDetailId)
        {
            string Parameter = "入参信息：盘存明细内码【" + CheckCommodityDetailId + "】";
            try
            {
                //获取盘存明细详情
                Model.CHECKCOMMODITYDETAILModel checkcommoditydetailModel = 
                    Helper.CHECKCOMMODITYDETAILHelper.GetCHECKCOMMODITYDETAILInfo(transaction, CheckCommodityDetailId);

                return Ok(Models.JsonMsg<Model.CHECKCOMMODITYDETAILModel>.Success(checkcommoditydetailModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetCheckCommodityDetailInfo");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步盘存明细
        /// <summary>
        /// 同步盘存明细
        /// </summary>
        /// <param name="checkcommoditydetailModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroCheckCommodityDetail")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroCheckCommodityDetail(Model.CHECKCOMMODITYDETAILModel checkcommoditydetailModel)
        {
            try
            {
                //新增盘存明细
                bool SynchroFlag = Helper.CHECKCOMMODITYDETAILHelper.SynchroCHECKCOMMODITYDETAIL(transaction, checkcommoditydetailModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroCheckCommodityDetail");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除盘存明细
        /// <summary>
        /// 删除盘存明细
        /// </summary>
        /// <param name="CheckCommodityDetailId">盘存明细内码</param>
        /// <returns></returns>
        [Route("InSales/DeleteCheckCommodityDetail")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteCheckCommodityDetail(int CheckCommodityDetailId)
        {
            string Parameter = "入参信息：盘存明细内码【" + CheckCommodityDetailId + "】";
            try
            {
                //删除盘存明细
                bool DeleteFlag = Helper.CHECKCOMMODITYDETAILHelper.DeleteCHECKCOMMODITYDETAIL(transaction, CheckCommodityDetailId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteCheckCommodityDetail");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取配货列表
        /// <summary>
        /// 获取配货列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetDeliverServerpartList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.DELIVERSERVERPARTModel>>))]
        public IHttpActionResult GetDeliverServerpartList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取配货列表
                List<Model.DELIVERSERVERPARTModel> DELIVERSERVERPARTList = Helper.DELIVERSERVERPARTHelper.GetDELIVERSERVERPARTList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.DELIVERSERVERPARTModel> jsonList = Models.JsonList<Model.DELIVERSERVERPARTModel>.Success(
                    DELIVERSERVERPARTList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.DELIVERSERVERPARTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetDeliverServerpartList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取配货列表
        /// <summary>
        /// 获取配货列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetDELIVERSERVERPARTList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.DELIVERSERVERPARTModel>>))]
        public IHttpActionResult GetDELIVERSERVERPARTList(Models.SearchModel<Model.DELIVERSERVERPARTModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取配货列表
                List<Model.DELIVERSERVERPARTModel> DELIVERSERVERPARTList = Helper.DELIVERSERVERPARTHelper.GetDELIVERSERVERPARTList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.DELIVERSERVERPARTModel> jsonList = Models.JsonList<Model.DELIVERSERVERPARTModel>.Success(
                    DELIVERSERVERPARTList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.DELIVERSERVERPARTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetDELIVERSERVERPARTList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取配货信息详情
        /// <summary>
        /// 获取配货信息详情
        /// </summary>
        /// <param name="DeliverServerpartId"></param>
        /// <returns></returns>
        [Route("InSales/GetDeliverServerpartDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.DELIVERSERVERPARTModel>))]
        public IHttpActionResult GetDeliverServerpartDetail(int DeliverServerpartId)
        {
            string Parameter = "入参信息：配货内码【" + DeliverServerpartId + "】";
            try
            {
                //获取配货信息详情
                Model.DELIVERSERVERPARTModel deliverserverpartModel =
                    Helper.DELIVERSERVERPARTHelper.GetDELIVERSERVERPARTDetail(transaction, DeliverServerpartId);

                return Ok(Models.JsonMsg<Model.DELIVERSERVERPARTModel>.Success(deliverserverpartModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetDeliverServerpartDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步配货单信息
        /// <summary>
        /// 同步配货单信息
        /// </summary>
        /// <param name="deliverserverpartModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroDeliverServerpart")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroDeliverServerpart(Model.DELIVERSERVERPARTModel deliverserverpartModel)
        {
            try
            {
                //同步配货单信息
                bool SynchroFlag = Helper.DELIVERSERVERPARTHelper.SynchroDELIVERSERVERPART(transaction, deliverserverpartModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroDeliverServerpart");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除配货单
        /// <summary>
        /// 删除配货单
        /// </summary>
        /// <param name="DeliverServerpartId">配货单内码</param>
        /// <returns></returns>
        [Route("InSales/DeleteDeliverServerpart")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteDeliverServerpart(int DeliverServerpartId)
        {
            string Parameter = "入参信息：配货单内码【" + DeliverServerpartId + "】";
            try
            {
                //删除配货单
                bool DeleteFlag = Helper.DELIVERSERVERPARTHelper.DeleteDELIVERSERVERPART(transaction, DeliverServerpartId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteDeliverServerpart");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取配货明细列表
        /// <summary>
        /// 获取配货明细列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetDeliverDetailServerpartList")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.DELIVERDETAILSERVERPARTModel>>))]
        public IHttpActionResult GetDeliverDetailServerpartList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取配货明细列表
                List<Model.DELIVERDETAILSERVERPARTModel> DELIVERDETAILSERVERPARTList =
                    Helper.DELIVERDETAILSERVERPARTHelper.GetDELIVERDETAILSERVERPARTList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.DELIVERDETAILSERVERPARTModel> jsonList = Models.JsonList<Model.DELIVERDETAILSERVERPARTModel>.Success(
                    DELIVERDETAILSERVERPARTList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.DELIVERDETAILSERVERPARTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetDeliverDetailServerpartList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取配货明细列表
        /// <summary>
        /// 获取配货明细列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetDELIVERDETAILSERVERPARTList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.DELIVERDETAILSERVERPARTModel>>))]
        public IHttpActionResult GetDELIVERDETAILSERVERPARTList(Models.SearchModel<Model.DELIVERDETAILSERVERPARTModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取配货明细列表
                List<Model.DELIVERDETAILSERVERPARTModel> DELIVERDETAILSERVERPARTList = Helper.DELIVERDETAILSERVERPARTHelper.GetDELIVERDETAILSERVERPARTList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.DELIVERDETAILSERVERPARTModel> jsonList = Models.JsonList<Model.DELIVERDETAILSERVERPARTModel>.Success(
                    DELIVERDETAILSERVERPARTList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.DELIVERDETAILSERVERPARTModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetDELIVERDETAILSERVERPARTList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取配货明细详情
        /// <summary>
        /// 获取配货明细详情
        /// </summary>
        /// <param name="DeliverDetailServerpartId">配货明细内码</param>
        /// <returns></returns>
        [Route("InSales/GetDeliverDetailServerpartDetail")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<Model.DELIVERDETAILSERVERPARTModel>))]
        public IHttpActionResult GetDeliverDetailServerpartDetail(int DeliverDetailServerpartId)
        {
            string Parameter = "入参信息：配货明细内码【" + DeliverDetailServerpartId + "】";
            try
            {
                //获取配货明细详情
                Model.DELIVERDETAILSERVERPARTModel deliverdetailserverpartModel =
                    Helper.DELIVERDETAILSERVERPARTHelper.GetDELIVERDETAILSERVERPARTDetail(transaction, DeliverDetailServerpartId);

                return Ok(Models.JsonMsg<Model.DELIVERDETAILSERVERPARTModel>.Success(deliverdetailserverpartModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetDeliverDetailServerpartDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步配货明细
        /// <summary>
        /// 同步配货明细
        /// </summary>
        /// <param name="deliverdetailserverpartModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroDeliverDetailServerpart")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroDeliverDetailServerpart(Model.DELIVERDETAILSERVERPARTModel deliverdetailserverpartModel)
        {
            try
            {
                //同步配货明细
                bool SynchroFlag = Helper.DELIVERDETAILSERVERPARTHelper.SynchroDELIVERDETAILSERVERPART(transaction, deliverdetailserverpartModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroDeliverDetailServerpart");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除配货明细
        /// <summary>
        /// 删除配货明细
        /// </summary>
        /// <param name="DeliverDetailServerpartId">配货明细内码</param>
        /// <returns></returns>
        [Route("InSales/DeleteDeliverDetailServerpart")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteDeliverDetailServerpart(int DeliverDetailServerpartId)
        {
            string Parameter = "入参信息：配货明细内码【" + DeliverDetailServerpartId + "】";
            try
            {
                //删除配货明细
                bool DeleteFlag = Helper.DELIVERDETAILSERVERPARTHelper.DeleteDELIVERDETAILSERVERPART(transaction, DeliverDetailServerpartId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteDeliverDetailServerpart");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取退货列表
        /// <summary>
        /// 获取退货信息列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <param name="SortStr"></param>
        /// <returns></returns>
        [Route("InSales/GetBackCommodityList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.BACKCOMMODITYModel>>))]
        public IHttpActionResult GetBackCommodityList(int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取退货列表
                List<Model.BACKCOMMODITYModel> BACKCOMMODITYList = Helper.BACKCOMMODITYHelper.GetBACKCOMMODITYList(
                    transaction, ref TotalCount, PageIndex, PageSize, SortStr);

                //转化json形式
                Models.JsonList<Model.BACKCOMMODITYModel> jsonList = Models.JsonList<Model.BACKCOMMODITYModel>.Success(
                    BACKCOMMODITYList, TotalCount, PageIndex, PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.BACKCOMMODITYModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBackCommodityList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取退货列表
        /// <summary>
        /// 获取退货列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("InSales/GetBACKCOMMODITYList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.BACKCOMMODITYModel>>))]
        public IHttpActionResult GetBACKCOMMODITYList(Models.SearchModel<Model.BACKCOMMODITYModel> searchModel)
        {
            string Parameter = "入参信息：查询方式【" + searchModel.QueryType + "】，查询页码【" + searchModel.PageIndex + "】，" +
                "每页显示数量【" + searchModel.PageSize + "】，排序条件【" + searchModel.SortStr + "】";
            try
            {
                int TotalCount = 0;
                //获取退货列表
                List<Model.BACKCOMMODITYModel> BACKCOMMODITYList = Helper.BACKCOMMODITYHelper.GetBACKCOMMODITYList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<Model.BACKCOMMODITYModel> jsonList = Models.JsonList<Model.BACKCOMMODITYModel>.Success(
                    BACKCOMMODITYList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

                return Ok(Models.JsonMsg<Models.JsonList<Model.BACKCOMMODITYModel>>.Success(jsonList, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBACKCOMMODITYList");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 获取退货明细
        /// <summary>
        /// 获取退货明细
        /// </summary>
        /// <param name="BackCommodityId">退货内码</param>
        /// <returns></returns>
        [Route("InSales/GetBackCommodityDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.BACKCOMMODITYModel>))]
        public IHttpActionResult GetBackCommodityDetail(int BackCommodityId)
        {
            string Parameter = "入参信息：退货内码【" + BackCommodityId + "】";
            try
            {
                //获取退货明细
                Model.BACKCOMMODITYModel backcommodityModel = Helper.BACKCOMMODITYHelper.GetBACKCOMMODITYDetail(transaction, BackCommodityId);

                return Ok(Models.JsonMsg<Model.BACKCOMMODITYModel>.Success(backcommodityModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "查询失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_GetBackCommodityDetail");
                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 同步退货表
        /// <summary>
        /// 同步退货表
        /// </summary>
        /// <param name="backcommodityModel"></param>
        /// <returns></returns>
        [Route("InSales/SynchroBackCommodity")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroBackCommodity(Model.BACKCOMMODITYModel backcommodityModel)
        {
            try
            {
                //新增退货表
                bool SynchroFlag = Helper.BACKCOMMODITYHelper.SynchroBACKCOMMODITY(transaction, backcommodityModel);

                if (SynchroFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "同步成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "更新失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "同步失败！失败原因：" + ex.Message,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroBackCommodity");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除退货表
        /// <summary>
        /// 删除退货表
        /// </summary>
        /// <param name="BackCommodityId">退货表内码</param>
        /// <returns></returns>
        [Route("InSales/DeleteBackCommodity")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteBackCommodity(int BackCommodityId)
        {
            string Parameter = "入参信息：退货表内码【" + BackCommodityId + "】";
            try
            {
                //删除退货表
                bool DeleteFlag = Helper.BACKCOMMODITYHelper.DeleteBACKCOMMODITY(transaction, BackCommodityId);

                if (DeleteFlag)
                {
                    return Ok(Helper.Common.ReturnJson(100, "删除成功"));
                }
                else
                {
                    return Ok(Helper.Common.ReturnJson(200, "删除失败，数据不存在！"));
                }
            }
            catch (Exception ex)
            {
                //事务回滚
                transaction.Rollback();
                Helper.LogUtil.WriteLog(null, "删除失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_DeleteBackCommodity");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion
    }
}