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

namespace GSYWApi.Controllers
{
    /// <summary>
    /// 基础信息管理相关接口
    /// </summary>
    public class BasicInfoController : BaseController
    {
        #region 服务区站点

        #region 获取服务区站点列表
        /// <summary>
        /// 获取服务区站点列表
        /// </summary>
        /// <param name="PageIndex">查询页码数</param>
        /// <param name="PageSize">每页显示数量</param>
        /// <param name="SERVERPART_NAME">服务区名称</param>
        /// <param name="SPREGIONTYPE_NAME">区域名称</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        [Route("BasicInfo/GetServerpartList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.SERVERPARTModel>>))]
        public IHttpActionResult GetServerpartList(int PageIndex = 1, int PageSize = 10,
            string SERVERPART_NAME = "", string SPREGIONTYPE_NAME = "", string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取服务区站点列表
                List<Model.SERVERPARTModel> SERVERPARTList = Helper.SERVERPARTHelper.GetSERVERPARTList(
                    transaction, ref TotalCount, PageIndex, PageSize, SERVERPART_NAME, SPREGIONTYPE_NAME, SortStr);

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

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

        #region 获取服务区站点明细
        /// <summary>
        /// 获取服务区明细
        /// </summary>
        /// <param name="SERVERPARTId">服务区内码</param>
        /// <returns></returns>
        [Route("BasicInfo/GetServerpartDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.SERVERPARTModel>))]
        public IHttpActionResult GetServerpartDetail(int SERVERPARTId)
        {
            string Parameter = "入参信息：服务区站点内码【" + SERVERPARTId + "】";
            try
            {
                //获取服务区站点明细
                Model.SERVERPARTModel serverpartModel = Helper.SERVERPARTHelper.GetSERVERPARTDetail(transaction, SERVERPARTId);

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

        #region 同步服务区站点
        /// <summary>
        /// 同步服务区站点（新增/更新）
        /// </summary>
        /// <param name="serverpartModel">服务区对象</param>
        /// <returns></returns>
        [Route("BasicInfo/SynchroServerpart")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroServerpart(Model.SERVERPARTModel serverpartModel)
        {
            try
            {
                //新增服务区站点
                bool SynchroFlag = Helper.SERVERPARTHelper.SynchroSERVERPART(transaction, serverpartModel);

                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") + "_SynchroSERVERPART");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除服务区站点
        /// <summary>
        /// 删除服务区信息
        /// </summary>
        /// <param name="SERVERPARTId">服务区内码</param>
        /// <returns></returns>
        [Route("BasicInfo/DeleteServerpart")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteServerpart(int SERVERPARTId)
        {
            string Parameter = "入参信息：服务区站点内码【" + SERVERPARTId + "】";
            try
            {
                //删除服务区站点
                bool DeleteFlag = Helper.SERVERPARTHelper.DeleteSERVERPART(transaction, SERVERPARTId);

                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") + "_DeleteSERVERPART");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #endregion

        #region 门店信息

        #region 获取门店列表
        /// <summary>
        /// 获取门店列表
        /// </summary>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="PageIndex">查询页码数</param>
        /// <param name="PageSize">每页显示数量</param>
        /// <param name="BUSINESS_TYPE">经营模式</param>
        /// <param name="BUSINESS_STATE">经营状态</param>
        /// <param name="SHOPNAME">门店名称</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        [Route("BasicInfo/GetServerpartShopList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.SERVERPARTSHOPModel>>))]
        public IHttpActionResult GetServerpartShopList(int? ServerpartId = null, int PageIndex = 1, int PageSize = 10,
            int? BUSINESS_TYPE = null, int? BUSINESS_STATE = null, string SHOPNAME = "", string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取门店列表
                List<Model.SERVERPARTSHOPModel> SERVERPARTSHOPList = Helper.SERVERPARTSHOPHelper.GetSERVERPARTSHOPList(transaction,
                    ref TotalCount, ServerpartId, PageIndex, PageSize, BUSINESS_TYPE, BUSINESS_STATE, SHOPNAME, SortStr);

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

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

        #region 获取门店明细
        /// <summary>
        /// 获取门店明细
        /// </summary>
        /// <param name="SERVERPARTSHOPId"></param>
        /// <returns></returns>
        [Route("BasicInfo/GetServerpartShopDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.SERVERPARTSHOPModel>))]
        public IHttpActionResult GetServerpartShopDetail(int SERVERPARTSHOPId)
        {
            string Parameter = "入参信息：门店内码【" + SERVERPARTSHOPId + "】";
            try
            {
                //获取门店明细
                Model.SERVERPARTSHOPModel serverpartshopModel = Helper.SERVERPARTSHOPHelper.GetSERVERPARTSHOPDetail(transaction, SERVERPARTSHOPId);

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

        #region 同步门店
        /// <summary>
        /// 同步门店信息
        /// </summary>
        /// <param name="serverpartshopModel">门店数据对象</param>
        /// <returns></returns>
        [Route("BasicInfo/SynchroServerpartShop")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroServerpartShop(Model.SERVERPARTSHOPModel serverpartshopModel)
        {
            try
            {
                //新增门店
                bool SynchroFlag = Helper.SERVERPARTSHOPHelper.SynchroSERVERPARTSHOP(transaction, serverpartshopModel);

                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") + "_SynchroSERVERPARTSHOP");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 设置有效状态
        /// <summary>
        /// 设置有效状态
        /// </summary>
        /// <param name="ServerpartShopId">门店内码</param>
        /// <param name="ShopStatus">有效状态</param>
        /// <returns></returns>
        [Route("BasicInfo/UpdateServerpartShopStatus")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult UpdateServerpartShopStatus(int? ServerpartShopId, int ShopStatus)
        {
            string Parameter = "入参信息：门店内码【" + ServerpartShopId + "】,有效状态【" + ShopStatus + "】";
            try
            {
                //删除门店
                bool DeleteFlag = Helper.SERVERPARTSHOPHelper.UpdateServerpartShopStatus(
                    transaction, ServerpartShopId, ShopStatus);

                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") + "_UpdateServerpartShopStatus");
                return Ok(Helper.Common.ReturnJson(999, "设置失败" + ex.Message));
            }
        }
        #endregion

        #region 删除门店
        /// <summary>
        /// 删除门店信息
        /// </summary>
        /// <param name="SERVERPARTSHOPId"></param>
        /// <returns></returns>
        [Route("BasicInfo/DeleteServerpartShop")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteServerpartShop(int SERVERPARTSHOPId)
        {
            string Parameter = "入参信息：门店内码【" + SERVERPARTSHOPId + "】";
            try
            {
                //删除门店
                bool DeleteFlag = Helper.SERVERPARTSHOPHelper.DeleteSERVERPARTSHOP(transaction, SERVERPARTSHOPId);

                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") + "_DeleteSERVERPARTSHOP");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #endregion

        #region 收银人员

        #region 获取收银人员表列表
        /// <summary>
        /// 获取收银人员列表
        /// </summary>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="CashWorker_Type">人员类型</param>
        /// <param name="Worker_Valid">有效状态</param>
        /// <param name="PageIndex">查询页码数</param>
        /// <param name="PageSize">每页显示数量</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        [Route("BasicInfo/GetCashWorkerList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.CASHWORKERModel>>))]
        public IHttpActionResult GetCashWorkerList(int? ServerpartId = null, int? CashWorker_Type = null,
            int? Worker_Valid = null, int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取收银人员表列表
                List<Model.CASHWORKERModel> CASHWORKERList = Helper.CASHWORKERHelper.GetCASHWORKERList(
                    transaction, ServerpartId, CashWorker_Type, Worker_Valid, ref TotalCount, PageIndex, PageSize, SortStr);

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

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

        #region 获取收银人员表明细
        /// <summary>
        /// 获取收银人员表明细
        /// </summary>
        /// <param name="CASHWORKERId">收银人员内码</param>
        /// <returns></returns>
        [Route("BasicInfo/GetCashWorkerDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.CASHWORKERModel>))]
        public IHttpActionResult GetCashWorkerDetail(int CASHWORKERId)
        {
            string Parameter = "入参信息：收银人员表内码【" + CASHWORKERId + "】";
            try
            {
                //获取收银人员表明细
                Model.CASHWORKERModel cashworkerModel = Helper.CASHWORKERHelper.GetCASHWORKERDetail(transaction, CASHWORKERId);

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

        #region 同步收银人员表
        /// <summary>
        /// 同步收银人员
        /// </summary>
        /// <param name="cashworkerModel">收银人员对象</param>
        /// <returns></returns>
        [Route("BasicInfo/SynchroCashWorker")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroCashWorker(Model.CASHWORKERModel cashworkerModel)
        {
            try
            {
                //新增收银人员表
                bool SynchroFlag = Helper.CASHWORKERHelper.SynchroCASHWORKER(transaction, cashworkerModel);

                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") + "_SynchroCASHWORKER");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除收银人员表
        /// <summary>
        /// 删除收银人员表
        /// </summary>
        /// <param name="CASHWORKERId">收银人员内码</param>
        /// <returns></returns>
        [Route("BasicInfo/DeleteCashWorker")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteCashWorker(int CASHWORKERId)
        {
            string Parameter = "入参信息：收银人员表内码【" + CASHWORKERId + "】";
            try
            {
                //删除收银人员表
                bool DeleteFlag = Helper.CASHWORKERHelper.DeleteCASHWORKER(transaction, CASHWORKERId);

                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") + "_DeleteCASHWORKER");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #endregion

        #region 商品类别

        #region 获取商品类别列表
        /// <summary>
        /// 获取商品类别列表
        /// </summary>
        /// <param name="CommodityTypePID">上级类别内码</param>
        /// <param name="PageIndex">查询页码数</param>
        /// <param name="PageSize">每页显示数量</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        [Route("BasicInfo/GetCommodityTypeList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.COMMODITYTYPEModel>>))]
        public IHttpActionResult GetCommodityTypeList(int? CommodityTypePID = null,
            int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：上级类别内码【" + CommodityTypePID + "】，" +
                "查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取商品类别列表
                List<Model.COMMODITYTYPEModel> COMMODITYTYPEList = Helper.COMMODITYTYPEHelper.GetCOMMODITYTYPEList(
                    transaction, CommodityTypePID, ref TotalCount, PageIndex, PageSize, SortStr);

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

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

        #region 获取商品类别明细
        /// <summary>
        /// 获取商品类别明细
        /// </summary>
        /// <param name="COMMODITYTYPEId">商品类别内码</param>
        /// <returns></returns>
        [Route("BasicInfo/GetCommodityTypeDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.COMMODITYTYPEModel>))]
        public IHttpActionResult GetCommodityTypeDetail(int COMMODITYTYPEId)
        {
            string Parameter = "入参信息：商品类别内码【" + COMMODITYTYPEId + "】";
            try
            {
                //获取商品类别明细
                Model.COMMODITYTYPEModel commoditytypeModel = Helper.COMMODITYTYPEHelper.GetCOMMODITYTYPEDetail(transaction, COMMODITYTYPEId);

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

        #region 同步商品类别
        /// <summary>
        /// 同步商品类别
        /// </summary>
        /// <param name="commoditytypeModel">商品类别对象</param>
        /// <returns></returns>
        [Route("BasicInfo/SynchroCommodityType")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroCommodityType(Model.COMMODITYTYPEModel commoditytypeModel)
        {
            try
            {
                //新增商品类别
                bool SynchroFlag = Helper.COMMODITYTYPEHelper.SynchroCOMMODITYTYPE(transaction, commoditytypeModel);

                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") + "_SynchroCOMMODITYTYPE");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除商品类别
        /// <summary>
        /// 删除商品类别
        /// </summary>
        /// <param name="COMMODITYTYPEId">商品类别内码</param>
        /// <returns></returns>
        [Route("BasicInfo/DeleteCommodityType")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteCommodityType(int COMMODITYTYPEId)
        {
            string Parameter = "入参信息：商品类别内码【" + COMMODITYTYPEId + "】";
            try
            {
                //删除商品类别
                bool DeleteFlag = Helper.COMMODITYTYPEHelper.DeleteCOMMODITYTYPE(transaction, COMMODITYTYPEId);

                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") + "_DeleteCOMMODITYTYPE");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取嵌套商品类别
        /// <summary>
        /// 获取嵌套商品类别
        /// </summary>
        /// <param name="CommodityTypePID">上级类别内码</param>
        /// <returns></returns>
        [Route("BasicInfo/GetNestingCommodityTypeLsit")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Models.NestingModel<Model.COMMODITYTYPEModel>>>))]
        public IHttpActionResult GetNestingCommodityTypeLsit(int? CommodityTypePID = null)
        {
            string Parameter = "入参信息：上级类别内码【" + CommodityTypePID + "】";
            try
            {
                //获取商品类别列表
                List<Models.NestingModel<Model.COMMODITYTYPEModel>> COMMODITYTYPEList =
                    Helper.COMMODITYTYPEHelper.GetNestingCommodityTypeLsit(transaction, CommodityTypePID);

                //转化json形式
                Models.JsonList<Models.NestingModel<Model.COMMODITYTYPEModel>> jsonList =
                    Models.JsonList<Models.NestingModel<Model.COMMODITYTYPEModel>>.Success(COMMODITYTYPEList);

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

        #endregion

        #region 商品管理

        #region 获取商品信息列表
        /// <summary>
        /// 获取商品管理列表
        /// </summary>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="PageIndex">查询页码数</param>
        /// <param name="PageSize">每页显示数量</param>
        /// <param name="keyword">模糊查询内容：商品名称、条码</param>
        /// <param name="COMMODITY_TYPE">商品类别</param>
        /// <param name="BUSINESSTYPE">商品业态</param>
        /// <param name="COMMODITY_STATE">商品状态</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        [Route("BasicInfo/GetCommodityList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.COMMODITYModel>>))]
        public IHttpActionResult GetCommodityList(int? ServerpartId = null, int PageIndex = 1, int PageSize = 10, string keyword = "",
            int? COMMODITY_TYPE = null, int? BUSINESSTYPE = null, int? COMMODITY_STATE = null, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取商品管理列表
                List<Model.COMMODITYModel> COMMODITYList = Helper.COMMODITYHelper.GetCOMMODITYList(
                    transaction, ServerpartId, ref TotalCount, PageIndex, PageSize,
                    keyword, COMMODITY_TYPE, BUSINESSTYPE, COMMODITY_STATE, SortStr);

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

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

        #region 获取商品管理明细
        /// <summary>
        /// 获取商品详情
        /// </summary>
        /// <param name="COMMODITYId">商品内码</param>
        /// <returns></returns>
        [Route("BasicInfo/GetCommodityDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.COMMODITYModel>))]
        public IHttpActionResult GetCommodityDetail(int COMMODITYId)
        {
            string Parameter = "入参信息：商品管理内码【" + COMMODITYId + "】";
            try
            {
                //获取商品管理明细
                Model.COMMODITYModel commodityModel = Helper.COMMODITYHelper.GetCOMMODITYDetail(transaction, COMMODITYId);

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

        #region 同步商品信息
        /// <summary>
        /// 同步商品信息
        /// </summary>
        /// <param name="commodityModel">商品信息对象</param>
        /// <returns></returns>
        [Route("BasicInfo/SynchroCommodity")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroCommodity(Model.COMMODITYModel commodityModel)
        {
            try
            {
                //新增商品管理
                bool SynchroFlag = Helper.COMMODITYHelper.SynchroCOMMODITY(transaction, commodityModel);

                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") + "_SynchroCOMMODITY");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除商品数据
        /// <summary>
        /// 删除商品数据
        /// </summary>
        /// <param name="COMMODITYId">商品内码</param>
        /// <returns></returns>
        [Route("BasicInfo/DeleteCommodity")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteCommodity(int COMMODITYId)
        {
            string Parameter = "入参信息：商品管理内码【" + COMMODITYId + "】";
            try
            {
                //删除商品管理
                bool DeleteFlag = Helper.COMMODITYHelper.DeleteCOMMODITY(transaction, COMMODITYId);

                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") + "_DeleteCOMMODITY");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #endregion

        #region 机器信息

        #region 获取机器信息表列表
        /// <summary>
        /// 获取机器信息表列表
        /// </summary>
        /// <param name="ServerpartId">服务区内码</param>
        /// <param name="ServerpartShopId">门店内码</param>
        /// <param name="MachineStatus">机器状态：1【有效】，0【无效】</param>
        /// <param name="PageIndex">查询页码数</param>
        /// <param name="PageSize">每页显示行数</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        [Route("BasicInfo/GetMachineManageList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.MACHINEMANAGEModel>>))]
        public IHttpActionResult GetMachineManageList(int? ServerpartId = null, int? ServerpartShopId = null,
            int? MachineStatus = null, int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取机器信息表列表
                List<Model.MACHINEMANAGEModel> MACHINEMANAGEList = Helper.MACHINEMANAGEHelper.GetMACHINEMANAGEList(
                    transaction, ServerpartId, ServerpartShopId, MachineStatus, ref TotalCount, PageIndex, PageSize, SortStr);

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

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

        #region 获取机器信息表明细
        /// <summary>
        /// 获取机器信息表明细
        /// </summary>
        /// <param name="MACHINEMANAGEId">机器信息表内码</param>
        /// <returns></returns>
        [Route("BasicInfo/GetMachineManageDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.MACHINEMANAGEModel>))]
        public IHttpActionResult GetMachineManageDetail(int MACHINEMANAGEId)
        {
            string Parameter = "入参信息：机器信息表内码【" + MACHINEMANAGEId + "】";
            try
            {
                //获取机器信息表明细
                Model.MACHINEMANAGEModel machinemanageModel = Helper.MACHINEMANAGEHelper.GetMACHINEMANAGEDetail(transaction, MACHINEMANAGEId);

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

        #region 同步机器信息表
        /// <summary>
        /// 同步机器信息表
        /// </summary>
        /// <param name="machinemanageModel">机器信息数据对象</param>
        /// <returns></returns>
        [Route("BasicInfo/SynchroMachineManage")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroMachineManage(Model.MACHINEMANAGEModel machinemanageModel)
        {
            try
            {
                //新增机器信息表
                bool SynchroFlag = Helper.MACHINEMANAGEHelper.SynchroMACHINEMANAGE(transaction, machinemanageModel);

                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") + "_SynchroMACHINEMANAGE");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除机器信息表
        /// <summary>
        /// 删除机器信息表
        /// </summary>
        /// <param name="MACHINEMANAGEId">机器信息表内码</param>
        /// <returns></returns>
        [Route("BasicInfo/DeleteMachineManage")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteMachineManage(int MACHINEMANAGEId)
        {
            string Parameter = "入参信息：机器信息表内码【" + MACHINEMANAGEId + "】";
            try
            {
                //删除机器信息表
                bool DeleteFlag = Helper.MACHINEMANAGEHelper.DeleteMACHINEMANAGE(transaction, MACHINEMANAGEId);

                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") + "_DeleteMACHINEMANAGE");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #endregion

        #region 促销信息

        #region 获取促销信息表列表
        /// <summary>
        /// 获取促销信息表列表
        /// </summary>
        /// <param name="PromotionType">促销类型</param>
        /// <param name="PromotionStatus">促销状态<br/>
        /// 1：有效，2：审核中，0：无效
        /// </param>
        /// <param name="Serverpart_IDS">服务区内码集合</param>
        /// <param name="PageIndex">查询页码数</param>
        /// <param name="PageSize">每显示行数</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        [Route("BasicInfo/GetPromotionList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.PROMOTIONModel>>))]
        public IHttpActionResult GetPromotionList(int? PromotionType = null, int? PromotionStatus = null,
            string Serverpart_IDS = "", int PageIndex = 1, int PageSize = 10, string SortStr = "")
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取促销信息表列表
                List<Model.PROMOTIONModel> PROMOTIONList = Helper.PROMOTIONHelper.GetPROMOTIONList(
                    transaction, PromotionType, PromotionStatus, Serverpart_IDS, ref TotalCount, PageIndex, PageSize, SortStr);

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

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

        #region 获取促销信息表明细
        /// <summary>
        /// 获取促销信息表明细
        /// </summary>
        /// <param name="PROMOTIONId">促销内码</param>
        /// <returns></returns>
        [Route("BasicInfo/GetPromotionDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.PROMOTIONModel>))]
        public IHttpActionResult GetPromotionDetail(int PROMOTIONId)
        {
            string Parameter = "入参信息：促销信息表内码【" + PROMOTIONId + "】";
            try
            {
                //获取促销信息表明细
                Model.PROMOTIONModel promotionModel = Helper.PROMOTIONHelper.GetPROMOTIONDetail(transaction, PROMOTIONId);

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

        #region 同步促销信息表
        /// <summary>
        /// 同步促销信息表
        /// </summary>
        /// <param name="promotionModel"></param>
        /// <returns></returns>
        [Route("BasicInfo/SynchroPromotion")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroPromotion(Model.PROMOTIONModel promotionModel)
        {
            try
            {
                //新增促销信息表
                bool SynchroFlag = Helper.PROMOTIONHelper.SynchroPROMOTION(transaction, promotionModel);

                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") + "_SynchroPROMOTION");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 更新促销信息状态
        /// <summary>
        /// 更新促销信息状态
        /// </summary>
        /// <param name="PromotionId">促销信息表内码</param>
        /// <param name="PromotionStatus">促销状态</param>
        /// <returns></returns>
        [Route("BasicInfo/UpdatePromotionstatus")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult UpdatePromotionstatus(int PromotionId, int PromotionStatus)
        {
            string Parameter = "入参信息：促销信息表内码【" + PromotionId + "】,促销状态【" + PromotionStatus + "】";

            try
            {
                //新增促销信息表
                bool UpdateFlag = Helper.PROMOTIONHelper.UpdatePromotionstatus(transaction, PromotionId, PromotionStatus);

                if (UpdateFlag)
                {
                    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") + "_UpdatePromotionstatus");
                return Ok(Helper.Common.ReturnJson(999, "更新失败" + ex.Message));
            }
        }
        #endregion

        #region 删除促销信息表
        /// <summary>
        /// 删除促销信息表
        /// </summary>
        /// <param name="PROMOTIONId">促销信息内码</param>
        /// <returns></returns>
        [Route("BasicInfo/DeletePromotion")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeletePromotion(int PROMOTIONId)
        {
            string Parameter = "入参信息：促销信息表内码【" + PROMOTIONId + "】";
            try
            {
                //删除促销信息表
                bool DeleteFlag = Helper.PROMOTIONHelper.DeletePROMOTION(transaction, PROMOTIONId);

                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") + "_DeletePROMOTION");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #region 获取促销商品详情列表
        /// <summary>
        /// 获取促销商品详情列表
        /// </summary>
        /// <param name="PageIndex"></param>
        /// <param name="PageSize"></param>
        /// <returns></returns>
        [Route("BasicInfo/GetRTPromotionList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Model.RTPROMOTIONModel>>))]
        public IHttpActionResult GetRTPromotionList(int PageIndex = 1, int PageSize = 10)
        {
            string Parameter = "入参信息：查询页码【" + PageIndex + "】，每页显示数量【" + PageSize + "】";
            try
            {
                int TotalCount = 0;
                //获取促销商品详情表列表
                List<Model.RTPROMOTIONModel> RTPROMOTIONList = Helper.RTPROMOTIONHelper.GetRTPROMOTIONList(
                    transaction, ref TotalCount, PageIndex, PageSize);

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

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

        #region 获取促销商品详情表明细
        /// <summary>
        /// 获取促销商品详情
        /// </summary>
        /// <param name="RTPROMOTIONId">促销商品详情内码</param>
        /// <returns></returns>
        [Route("BasicInfo/GetRTPromotionDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Model.RTPROMOTIONModel>))]
        public IHttpActionResult GetRTPromotionDetail(int RTPROMOTIONId)
        {
            string Parameter = "入参信息：促销商品详情表内码【" + RTPROMOTIONId + "】";
            try
            {
                //获取促销商品详情表明细
                Model.RTPROMOTIONModel rtpromotionModel = Helper.RTPROMOTIONHelper.GetRTPROMOTIONDetail(transaction, RTPROMOTIONId);

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

        #region 同步促销商品详情表
        /// <summary>
        /// 同步促销商品详情表
        /// </summary>
        /// <param name="rtpromotionModel"></param>
        /// <returns></returns>
        [Route("BasicInfo/SynchroRTPromotion")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroRTPromotion(Model.RTPROMOTIONModel rtpromotionModel)
        {
            try
            {
                //新增促销商品详情表
                bool SynchroFlag = Helper.RTPROMOTIONHelper.SynchroRTPROMOTION(transaction, rtpromotionModel);

                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") + "_SynchroRTPROMOTION");
                return Ok(Helper.Common.ReturnJson(999, "同步失败" + ex.Message));
            }
        }
        #endregion

        #region 删除促销商品详情表
        /// <summary>
        /// 删除促销商品详情表
        /// </summary>
        /// <param name="RTPROMOTIONId">促销商品详情表内码</param>
        /// <returns></returns>
        [Route("BasicInfo/DeleteRTPromotion")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteRTPromotion(int RTPROMOTIONId)
        {
            string Parameter = "入参信息：促销商品详情表内码【" + RTPROMOTIONId + "】";
            try
            {
                //删除促销商品详情表
                bool DeleteFlag = Helper.RTPROMOTIONHelper.DeleteRTPROMOTION(transaction, RTPROMOTIONId);

                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") + "_DeleteRTPROMOTION");
                return Ok(Helper.Common.ReturnJson(999, "删除失败" + ex.Message));
            }
        }
        #endregion

        #endregion 

        #region 绑定下拉框

        #region 绑定服务区下拉框
        /// <summary>
        /// 绑定服务区下拉框
        /// </summary>
        /// <param name="ServerpartCodes">服务区编码集合</param>
        /// <returns></returns>
        [Route("BasicInfo/GetServerpartDDL")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Models.CommonModel>>))]
        public IHttpActionResult GetServerpartDDL(string ServerpartCodes = "")
        {
            string Parameter = "入参信息：服务区编码集合【" + ServerpartCodes + "】";
            try
            {
                //获取合同备案表列表
                List<Models.CommonModel> ServerpartList = Helper.SERVERPARTHelper.GetServerpartDDL(transaction, ServerpartCodes);

                //转化json形式
                Models.JsonList<Models.CommonModel> jsonList = Models.JsonList<Models.CommonModel>.Success(ServerpartList);

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

        #region 绑定商品类别下拉框
        /// <summary>
        /// 绑定商品类别下拉框
        /// </summary>
        /// <param name="CommodityTypePID">商品类别上级分类</param>
        /// <param name="ShowStatus">商品类别状态</param>
        /// <returns></returns>
        [Route("BasicInfo/GetCommodityTypeDDL")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<Models.CommonPidModel>>))]
        public IHttpActionResult GetCommodityTypeDDL(int? CommodityTypePID = -1, bool ShowStatus = false)
        {
            string Parameter = "入参信息：商品类别上级分类【" + CommodityTypePID + "】，商品类别状态【" + ShowStatus + "】";
            try
            {
                //获取合同备案表列表
                List<Models.NestingModel<Models.CommonPidModel>> CommodityTypeList =
                    Helper.COMMODITYTYPEHelper.GetCommodityTypeDDL(transaction, CommodityTypePID, ShowStatus);

                //转化json形式
                Models.JsonList<Models.NestingModel<Models.CommonPidModel>> jsonList =
                    Models.JsonList<Models.NestingModel<Models.CommonPidModel>>.Success(CommodityTypeList);

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

        #endregion
    }
}