using System;
using System.Collections.Generic;
using System.Web.Http;
using System.Web.Http.Description;
using ESCG = CodeBuilderApi.GeneralMethod;
using ESCM = CodeBuilderApi.Model;
using Newtonsoft.Json;
using HZQR.Common;

namespace CodeBuilderApi.Controllers
{
    /// <summary>
    /// 低代码平台相关接口
    /// </summary>
    public class InterfaceController : BaseController
    {
        #region 获取数据库用户表列表
        /// <summary>
        /// 获取数据库用户表列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("Interface/GetDATABASEOWNERList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.DATABASEOWNERModel>>))]
        public IHttpActionResult GetDATABASEOWNERList(ESCM.SearchModel<ESCM.DATABASEOWNERModel> searchModel)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(searchModel);
            try
            {
                int TotalCount = 0;
                //获取数据库用户表列表
                List<ESCM.DATABASEOWNERModel> DATABASEOWNERList = ESCG.DATABASEOWNERHelper.GetDATABASEOWNERList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<ESCM.DATABASEOWNERModel> jsonList = Models.JsonList<ESCM.DATABASEOWNERModel>.Success(
                    DATABASEOWNERList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取数据库用户表明细
        /// <summary>
        /// 获取数据库用户表明细
        /// </summary>
        /// <param name="DATABASEOWNERId">数据库用户表内码</param>
        /// <returns></returns>
        [Route("Interface/GetDATABASEOWNERDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.DATABASEOWNERModel>))]
        public IHttpActionResult GetDATABASEOWNERDetail(int DATABASEOWNERId)
        {
            string Parameter = "入参信息：数据库用户表内码【" + DATABASEOWNERId + "】";
            try
            {
                //获取数据库用户表明细
                ESCM.DATABASEOWNERModel databaseownerModel = ESCG.DATABASEOWNERHelper.GetDATABASEOWNERDetail(transaction, DATABASEOWNERId);

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

        #region 同步数据库用户表
        /// <summary>
        /// 同步数据库用户表
        /// </summary>
        /// <param name="databaseownerModel"></param>
        /// <returns></returns>
        [Route("Interface/SynchroDATABASEOWNER")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroDATABASEOWNER(ESCM.DATABASEOWNERModel databaseownerModel)
        {
            try
            {
                //新增数据库用户表
                bool SynchroFlag = ESCG.DATABASEOWNERHelper.SynchroDATABASEOWNER(transaction, databaseownerModel);

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

        #region 删除数据库用户表
        /// <summary>
        /// 删除数据库用户表
        /// </summary>
        /// <param name="DATABASEOWNERId">数据库用户表内码</param>
        /// <returns></returns>
        [Route("Interface/DeleteDATABASEOWNER")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteDATABASEOWNER(int DATABASEOWNERId)
        {
            string Parameter = "入参信息：数据库用户表内码【" + DATABASEOWNERId + "】";
            try
            {
                //删除数据库用户表
                bool DeleteFlag = ESCG.DATABASEOWNERHelper.DeleteDATABASEOWNER(transaction, DATABASEOWNERId);

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

        #region 获取数据库表信息列表
        /// <summary>
        /// 获取数据库表信息列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("Interface/GetDATABASETABLEList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.DATABASETABLEModel>>))]
        public IHttpActionResult GetDATABASETABLEList(ESCM.SearchModel<ESCM.DATABASETABLEModel> searchModel)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(searchModel);
            try
            {
                int TotalCount = 0;
                //获取数据库表信息列表
                List<ESCM.DATABASETABLEModel> DATABASETABLEList = ESCG.DATABASETABLEHelper.GetDATABASETABLEList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<ESCM.DATABASETABLEModel> jsonList = Models.JsonList<ESCM.DATABASETABLEModel>.Success(
                    DATABASETABLEList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取数据库表信息明细
        /// <summary>
        /// 获取数据库表信息明细
        /// </summary>
        /// <param name="DATABASETABLEId">数据库表信息内码</param>
        /// <returns></returns>
        [Route("Interface/GetDATABASETABLEDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.DATABASETABLEModel>))]
        public IHttpActionResult GetDATABASETABLEDetail(int DATABASETABLEId)
        {
            string Parameter = "入参信息：数据库表信息内码【" + DATABASETABLEId + "】";
            try
            {
                //获取数据库表信息明细
                ESCM.DATABASETABLEModel databasetableModel = ESCG.DATABASETABLEHelper.GetDATABASETABLEDetail(transaction, DATABASETABLEId);

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

        #region 同步数据库表信息
        /// <summary>
        /// 同步数据库表信息
        /// </summary>
        /// <param name="databasetableModel"></param>
        /// <returns></returns>
        [Route("Interface/SynchroDATABASETABLE")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroDATABASETABLE(ESCM.DATABASETABLEModel databasetableModel)
        {
            try
            {
                //新增数据库表信息
                bool SynchroFlag = ESCG.DATABASETABLEHelper.SynchroDATABASETABLE(transaction, databasetableModel);

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

        #region 删除数据库表信息
        /// <summary>
        /// 删除数据库表信息
        /// </summary>
        /// <param name="DATABASETABLEId">数据库表信息内码</param>
        /// <returns></returns>
        [Route("Interface/DeleteDATABASETABLE")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteDATABASETABLE(int DATABASETABLEId)
        {
            string Parameter = "入参信息：数据库表信息内码【" + DATABASETABLEId + "】";
            try
            {
                //删除数据库表信息
                bool DeleteFlag = ESCG.DATABASETABLEHelper.DeleteDATABASETABLE(transaction, DATABASETABLEId);

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

        #region 获取数据库表字段列表
        /// <summary>
        /// 获取数据库表字段列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("Interface/GetDATABASECOLUMNList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.DATABASECOLUMNModel>>))]
        public IHttpActionResult GetDATABASECOLUMNList(ESCM.SearchModel<ESCM.DATABASECOLUMNModel> searchModel)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(searchModel);
            try
            {
                int TotalCount = 0;
                //获取数据库表字段列表
                List<ESCM.DATABASECOLUMNModel> DATABASECOLUMNList = ESCG.DATABASECOLUMNHelper.GetDATABASECOLUMNList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<ESCM.DATABASECOLUMNModel> jsonList = Models.JsonList<ESCM.DATABASECOLUMNModel>.Success(
                    DATABASECOLUMNList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取数据库表字段明细
        /// <summary>
        /// 获取数据库表字段明细
        /// </summary>
        /// <param name="DATABASECOLUMNId">数据库表字段内码</param>
        /// <returns></returns>
        [Route("Interface/GetDATABASECOLUMNDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.DATABASECOLUMNModel>))]
        public IHttpActionResult GetDATABASECOLUMNDetail(int DATABASECOLUMNId)
        {
            string Parameter = "入参信息：数据库表字段内码【" + DATABASECOLUMNId + "】";
            try
            {
                //获取数据库表字段明细
                ESCM.DATABASECOLUMNModel databasecolumnModel = ESCG.DATABASECOLUMNHelper.GetDATABASECOLUMNDetail(transaction, DATABASECOLUMNId);

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

        #region 同步数据库表字段
        /// <summary>
        /// 同步数据库表字段
        /// </summary>
        /// <param name="databasecolumnModel"></param>
        /// <returns></returns>
        [Route("Interface/SynchroDATABASECOLUMN")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroDATABASECOLUMN(ESCM.DATABASECOLUMNModel databasecolumnModel)
        {
            try
            {
                //新增数据库表字段
                bool SynchroFlag = ESCG.DATABASECOLUMNHelper.SynchroDATABASECOLUMN(transaction, databasecolumnModel);

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

        #region 删除数据库表字段
        /// <summary>
        /// 删除数据库表字段
        /// </summary>
        /// <param name="DATABASECOLUMNId">数据库表字段内码</param>
        /// <returns></returns>
        [Route("Interface/DeleteDATABASECOLUMN")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteDATABASECOLUMN(int DATABASECOLUMNId)
        {
            string Parameter = "入参信息：数据库表字段内码【" + DATABASECOLUMNId + "】";
            try
            {
                //删除数据库表字段
                bool DeleteFlag = ESCG.DATABASECOLUMNHelper.DeleteDATABASECOLUMN(transaction, DATABASECOLUMNId);

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

        #region 获取平台接口表列表
        /// <summary>
        /// 获取平台接口表列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("Interface/GetINTERFACEList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.INTERFACEModel>>))]
        public IHttpActionResult GetINTERFACEList(ESCM.SearchModel<ESCM.INTERFACEModel> searchModel)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(searchModel);
            try
            {
                int TotalCount = 0;
                //获取平台接口表列表
                List<ESCM.INTERFACEModel> INTERFACEList = ESCG.INTERFACEHelper.GetINTERFACEList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<ESCM.INTERFACEModel> jsonList = Models.JsonList<ESCM.INTERFACEModel>.Success(
                    INTERFACEList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取平台接口表明细
        /// <summary>
        /// 获取平台接口表明细
        /// </summary>
        /// <param name="INTERFACEId">平台接口表内码</param>
        /// <returns></returns>
        [Route("Interface/GetINTERFACEDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.INTERFACEModel>))]
        public IHttpActionResult GetINTERFACEDetail(int INTERFACEId)
        {
            string Parameter = "入参信息：平台接口表内码【" + INTERFACEId + "】";
            try
            {
                //获取平台接口表明细
                ESCM.INTERFACEModel interfaceModel = ESCG.INTERFACEHelper.GetINTERFACEDetail(transaction, INTERFACEId);

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

        #region 同步平台接口表
        /// <summary>
        /// 同步平台接口表
        /// </summary>
        /// <param name="interfaceModel"></param>
        /// <returns></returns>
        [Route("Interface/SynchroINTERFACE")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroINTERFACE(ESCM.INTERFACEModel interfaceModel)
        {
            try
            {
                //新增平台接口表
                bool SynchroFlag = ESCG.INTERFACEHelper.SynchroINTERFACE(transaction, interfaceModel);

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

        #region 删除平台接口表
        /// <summary>
        /// 删除平台接口表
        /// </summary>
        /// <param name="INTERFACEId">平台接口表内码</param>
        /// <returns></returns>
        [Route("Interface/DeleteINTERFACE")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteINTERFACE(int INTERFACEId)
        {
            string Parameter = "入参信息：平台接口表内码【" + INTERFACEId + "】";
            try
            {
                //删除平台接口表
                bool DeleteFlag = ESCG.INTERFACEHelper.DeleteINTERFACE(transaction, INTERFACEId);

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

        #region 获取参数对象表列表
        /// <summary>
        /// 获取参数对象表列表
        /// </summary>
        /// <param name="searchModel">查询条件对象</param>
        /// <returns></returns>
        [Route("Interface/GetINTERFACEMODELList")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.INTERFACEMODELModel>>))]
        public IHttpActionResult GetINTERFACEMODELList(ESCM.SearchModel<ESCM.INTERFACEMODELModel> searchModel)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(searchModel);
            try
            {
                int TotalCount = 0;
                //获取参数对象表列表
                List<ESCM.INTERFACEMODELModel> INTERFACEMODELList = ESCG.INTERFACEMODELHelper.GetINTERFACEMODELList(
                    transaction, ref TotalCount, searchModel);

                //转化json形式
                Models.JsonList<ESCM.INTERFACEMODELModel> jsonList = Models.JsonList<ESCM.INTERFACEMODELModel>.Success(
                    INTERFACEMODELList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        /// <summary>
        /// 获取参数对象表列表
        /// </summary>
        /// <param name="InterfaceId">接口内码</param>
        /// <returns></returns>
        [Route("Interface/GetINTERFACEMODELList")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.INTERFACEMODELModel>>))]
        public IHttpActionResult GetINTERFACEMODELList(int InterfaceId)
        {
            string Parameter = "入参信息：接口内码【" + InterfaceId + "】";
            try
            {
                ESCM.INTERFACEMODELModel PModel = new ESCM.INTERFACEMODELModel();
                //获取参数对象表列表
                List<ESCM.INTERFACEMODELModel> INTERFACEMODELList = ESCG.INTERFACEMODELHelper.GetINTERFACEMODELList(
                    transaction, InterfaceId, ref PModel);

                Models.JsonList<ESCM.INTERFACEMODELModel, ESCM.INTERFACEMODELModel> jsonList =
                    Models.JsonList<ESCM.INTERFACEMODELModel, ESCM.INTERFACEMODELModel>.Success(
                    INTERFACEMODELList, PModel, INTERFACEMODELList.Count, 1, INTERFACEMODELList.Count);

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

        #region 获取参数对象表明细
        /// <summary>
        /// 获取参数对象表明细
        /// </summary>
        /// <param name="INTERFACEMODELId">参数对象表内码</param>
        /// <returns></returns>
        [Route("Interface/GetINTERFACEMODELDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.INTERFACEMODELModel>))]
        public IHttpActionResult GetINTERFACEMODELDetail(int INTERFACEMODELId)
        {
            string Parameter = "入参信息：参数对象表内码【" + INTERFACEMODELId + "】";
            try
            {
                //获取参数对象表明细
                ESCM.INTERFACEMODELModel interfacemodelModel = ESCG.INTERFACEMODELHelper.GetINTERFACEMODELDetail(transaction, INTERFACEMODELId);

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

        #region 同步参数对象表
        /// <summary>
        /// 同步参数对象表
        /// </summary>
        /// <param name="interfacemodelModel"></param>
        /// <returns></returns>
        [Route("Interface/SynchroINTERFACEMODEL")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroINTERFACEMODEL(ESCM.INTERFACEMODELModel interfacemodelModel)
        {
            try
            {
                //新增参数对象表
                bool SynchroFlag = ESCG.INTERFACEMODELHelper.SynchroINTERFACEMODEL(transaction, interfacemodelModel);

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

        #region 删除参数对象表
        /// <summary>
        /// 删除参数对象表
        /// </summary>
        /// <param name="INTERFACEMODELId">参数对象表内码</param>
        /// <returns></returns>
        [Route("Interface/DeleteINTERFACEMODEL")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteINTERFACEMODEL(int INTERFACEMODELId)
        {
            string Parameter = "入参信息：参数对象表内码【" + INTERFACEMODELId + "】";
            try
            {
                //删除参数对象表
                bool DeleteFlag = ESCG.INTERFACEMODELHelper.DeleteINTERFACEMODEL(transaction, INTERFACEMODELId);

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

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

                //转化json形式
                Models.JsonList<ESCM.INTERFACEPARAMSModel> jsonList = Models.JsonList<ESCM.INTERFACEPARAMSModel>.Success(
                    INTERFACEPARAMSList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取接口入参表明细
        /// <summary>
        /// 获取接口入参表明细
        /// </summary>
        /// <param name="INTERFACEPARAMSId">接口入参表内码</param>
        /// <returns></returns>
        [Route("Interface/GetINTERFACEPARAMSDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.INTERFACEPARAMSModel>))]
        public IHttpActionResult GetINTERFACEPARAMSDetail(int INTERFACEPARAMSId)
        {
            string Parameter = "入参信息：接口入参表内码【" + INTERFACEPARAMSId + "】";
            try
            {
                //获取接口入参表明细
                ESCM.INTERFACEPARAMSModel interfaceparamsModel = ESCG.INTERFACEPARAMSHelper.GetINTERFACEPARAMSDetail(transaction, INTERFACEPARAMSId);

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

        #region 同步接口入参表
        /// <summary>
        /// 同步接口入参表
        /// </summary>
        /// <param name="interfaceparamsModel"></param>
        /// <returns></returns>
        [Route("Interface/SynchroINTERFACEPARAMS")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroINTERFACEPARAMS(ESCM.INTERFACEPARAMSModel interfaceparamsModel)
        {
            try
            {
                //新增接口入参表
                bool SynchroFlag = ESCG.INTERFACEPARAMSHelper.SynchroINTERFACEPARAMS(transaction, interfaceparamsModel);

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

        #region 删除接口入参表
        /// <summary>
        /// 删除接口入参表
        /// </summary>
        /// <param name="INTERFACEPARAMSId">接口入参表内码</param>
        /// <returns></returns>
        [Route("Interface/DeleteINTERFACEPARAMS")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteINTERFACEPARAMS(int INTERFACEPARAMSId)
        {
            string Parameter = "入参信息：接口入参表内码【" + INTERFACEPARAMSId + "】";
            try
            {
                //删除接口入参表
                bool DeleteFlag = ESCG.INTERFACEPARAMSHelper.DeleteINTERFACEPARAMS(transaction, INTERFACEPARAMSId);

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

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

                //转化json形式
                Models.JsonList<ESCM.INTERFACERESPONSEModel> jsonList = Models.JsonList<ESCM.INTERFACERESPONSEModel>.Success(
                    INTERFACERESPONSEList, TotalCount, searchModel.PageIndex, searchModel.PageSize);

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

        #region 获取接口返参表明细
        /// <summary>
        /// 获取接口返参表明细
        /// </summary>
        /// <param name="INTERFACERESPONSEId">接口返参表内码</param>
        /// <returns></returns>
        [Route("Interface/GetINTERFACERESPONSEDetail")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.INTERFACERESPONSEModel>))]
        public IHttpActionResult GetINTERFACERESPONSEDetail(int INTERFACERESPONSEId)
        {
            string Parameter = "入参信息：接口返参表内码【" + INTERFACERESPONSEId + "】";
            try
            {
                //获取接口返参表明细
                ESCM.INTERFACERESPONSEModel interfaceresponseModel = ESCG.INTERFACERESPONSEHelper.GetINTERFACERESPONSEDetail(transaction, INTERFACERESPONSEId);

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

        #region 同步接口返参表
        /// <summary>
        /// 同步接口返参表
        /// </summary>
        /// <param name="interfaceresponseModel"></param>
        /// <returns></returns>
        [Route("Interface/SynchroINTERFACERESPONSE")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroINTERFACERESPONSE(ESCM.INTERFACERESPONSEModel interfaceresponseModel)
        {
            try
            {
                //新增接口返参表
                bool SynchroFlag = ESCG.INTERFACERESPONSEHelper.SynchroINTERFACERESPONSE(transaction, interfaceresponseModel);

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

        #region 删除接口返参表
        /// <summary>
        /// 删除接口返参表
        /// </summary>
        /// <param name="INTERFACERESPONSEId">接口返参表内码</param>
        /// <returns></returns>
        [Route("Interface/DeleteINTERFACERESPONSE")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult DeleteINTERFACERESPONSE(int INTERFACERESPONSEId)
        {
            string Parameter = "入参信息：接口返参表内码【" + INTERFACERESPONSEId + "】";
            try
            {
                //删除接口返参表
                bool DeleteFlag = ESCG.INTERFACERESPONSEHelper.DeleteINTERFACERESPONSE(transaction, INTERFACERESPONSEId);

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

        #region 方法 -> 获取接口嵌套树
        /// <summary>
        /// 获取接口嵌套树
        /// </summary>
        /// <param name="AcceptVerbsType">接口响应方式（0：GET/POST，1：GET,2：POST）</param>
        /// <param name="StandardType">是否标准接口（0：否；1：是）</param>
        /// <param name="ShowChild">是否显示子集，默认显示</param>
        /// <param name="SearchValue">模糊查询条件</param>
        /// <returns></returns>
        [Route("Interface/GetNestingInterfaceTree")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<ESCM.NestingModel<ESCM.CommonTypeModel>>))]
        public IHttpActionResult GetNestingInterfaceTree(string StandardType = "",
            string AcceptVerbsType = "", bool ShowChild = false, string SearchValue = "")
        {
            try
            {
                //获取接口嵌套树
                List<ESCM.NestingModel<ESCM.CommonTypeModel>> InterfaceTree =
                    ESCG.INTERFACEHelper.GetNestingInterfaceTree(transaction, AcceptVerbsType, StandardType, ShowChild, SearchValue);

                Models.JsonList<ESCM.NestingModel<ESCM.CommonTypeModel>> jsonList =
                    Models.JsonList<ESCM.NestingModel<ESCM.CommonTypeModel>>.Success(
                    InterfaceTree, InterfaceTree.Count, 1, InterfaceTree.Count);

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

        #region 方法 -> 同步数据库表信息
        /// <summary>
        /// 同步数据库表信息
        /// </summary>
        /// <param name="dATABASEParams">数据库表信息字段入参类</param>
        /// <returns></returns>
        [Route("DataBase/SynchroDataBase")]
        [AcceptVerbs("POST")]
        [ResponseType(typeof(Models.JsonMsg<string>))]
        public IHttpActionResult SynchroDataBase(ESCM.DATABASEParamsModel dATABASEParams)
        {
            string Parameter = "入参信息：" + JsonConvert.SerializeObject(dATABASEParams);
            try
            {
                //同步数据库表信息
                bool result = ESCG.DATABASETABLEHelper.SynchroDataBase(transaction, dATABASEParams);
                if (result)
                {
                    return Ok(Method.Common.ReturnJson(100, "保存成功"));
                }
                else
                {
                    return Ok(Method.Common.ReturnJson(999, "保存失败"));
                }
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                LogUtil.WriteLog(null, "保存失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_SynchroDataBase");
                return Ok(Method.Common.ReturnJson(999, "保存失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 生成数据库表字段
        /// <summary>
        /// 数据库表管理新增页面，点击生成表字段返回的列表数据
        /// </summary>
        /// <param name="DataTableName">数据库表名称</param>
        /// <param name="OwnerName">数据库表所属用户</param>
        /// <returns></returns>
        [Route("Interface/CreateDataTableColumns")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.DATABASECOLUMNModel>>))]
        public IHttpActionResult CreateDataTableColumns(string DataTableName, string OwnerName)
        {
            string Parameter = "入参信息：数据库表名称【" + DataTableName + "】，数据库表所属用户【" + OwnerName + "】";
            try
            {
                //获取数据库表字段列表
                List<ESCM.DATABASECOLUMNModel> DATABASECOLUMNList = ESCG.DATABASECOLUMNHelper.CreateDataTableColumns(
                    DataTableName, OwnerName);

                Models.JsonList<ESCM.DATABASECOLUMNModel> jsonList = Models.JsonList<ESCM.DATABASECOLUMNModel>.Success(
                    DATABASECOLUMNList);

                return Ok(Models.JsonMsg<Models.JsonList<ESCM.DATABASECOLUMNModel>>.Success(jsonList, 100, "获取成功"));
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                LogUtil.WriteLog(null, "获取失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_CreateDataTableColumns");
                return Ok(Method.Common.ReturnJson(999, "获取失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 创建数据库表到数据库
        /// <summary>
        /// 创建数据库表到数据库
        /// </summary>
        /// <param name="DataBaseTable_ID">数据库表内码</param>
        /// <param name="ConnectionString">数据库连接字符串</param>
        /// <returns></returns>
        [Route("Interface/CreateDataBaseTable")]
        [AcceptVerbs("GET")]
        [ResponseType(typeof(Models.JsonMsg<Models.JsonList<ESCM.DATABASECOLUMNModel>>))]
        public IHttpActionResult CreateDataBaseTable(int DataBaseTable_ID, string ConnectionString)
        {
            string Parameter = "入参信息：数据库表内码【" + DataBaseTable_ID + "】，" +
                "数据库连接字符串【" + ConnectionString + "】";
            try
            {
                string ErrorMsg = "";
                //获取数据库表字段列表
                bool SynchroFlag = ESCG.DATABASETABLEHelper.CreateDataBaseTable(
                    transaction, DataBaseTable_ID, ConnectionString, ref ErrorMsg);

                if (SynchroFlag)
                {
                    return Ok(Method.Common.ReturnJson(100, "创建成功"));
                }
                else
                {
                    return Ok(Method.Common.ReturnJson(200, "创建失败！失败原因：" + ErrorMsg));
                }
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                LogUtil.WriteLog(null, "创建失败！失败原因：" + ex.Message + "\r\n" + Parameter,
                    DateTime.Now.ToString("yyyyMMdd") + "_CreateDataBaseTable");
                return Ok(Method.Common.ReturnJson(999, "创建失败！" + ex.Message));
            }
        }
        #endregion
    }
}