using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Text;
using SuperMap.RealEstate.ServiceModel;
using CMB = SuperMap.RealEstate.Coop.Merchant.Business;
using MSPB = SuperMap.RealEstate.MobileServicePlatform.Business;
using Business = SuperMap.RealEstate.FrameWork.Platform.Business;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using HZQR.Common;

namespace CodeBuilderApi.GeneralMethod
{
    /// <summary>
    /// 代码生成表相关方法
    /// 2022/10/18 11:36:31自动生成
    /// </summary>
    public class CodeBuilderHelper
    {
        #region 获取代码生成表列表
        /// <summary>
        /// 获取代码生成表列表
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="TotalCount">查询结果总数</param>
        /// <param name="searchModel">查询条件对象</param>
        public static List<Model.CODEBUILDERModel> GetCODEBUILDERList(Transaction transaction,
            ref int TotalCount, Model.SearchModel<Model.CODEBUILDERModel> searchModel)
        {
            List<Model.CODEBUILDERModel> CODEBUILDERList = new List<Model.CODEBUILDERModel>();

            string WhereSQL = "", RowFilterSQL = "";
            if (searchModel.SearchParameter != null)
            {
                WhereSQL = OperationDataHelper<Model.CODEBUILDERModel>.GetWhereSQL(searchModel.SearchParameter, searchModel.QueryType);
                if (WhereSQL != "")
                {
                    WhereSQL = "WHERE " + WhereSQL;
                }
            }

            DataTable dtCODEBUILDER = new Business.CODEBUILDER(transaction).FillDataTable(WhereSQL);
            //增加组合查询条件
            if (searchModel.keyWord != null && !string.IsNullOrWhiteSpace(searchModel.keyWord.Key))
            {
                foreach (string KeyName in searchModel.keyWord.Key.Split(','))
                {
                    RowFilterSQL += (RowFilterSQL == "" ? "" : " or ") +
                        KeyName + " like '%" + searchModel.keyWord.Value + "%'";
                }
            }
            if (RowFilterSQL != "")
            {
                dtCODEBUILDER.DefaultView.RowFilter = RowFilterSQL;
            }
            //排序：
            dtCODEBUILDER.DefaultView.Sort = searchModel.SortStr;
            dtCODEBUILDER = dtCODEBUILDER.DefaultView.ToTable();
            //获取查询结果总记录条数
            TotalCount = dtCODEBUILDER.Rows.Count;
            //根据传入的页码和每页显示条数返回结果
            dtCODEBUILDER = CommonHelper.GetDataTableWithPageSize(dtCODEBUILDER, searchModel.PageSize, searchModel.PageIndex);

            foreach (DataRow drCODEBUILDER in dtCODEBUILDER.Rows)
            {
                Model.CODEBUILDERModel codebuilderModel = new Model.CODEBUILDERModel();
                //绑定用户表数据对象
                BindDataRowToModel(drCODEBUILDER, codebuilderModel);

                CODEBUILDERList.Add(codebuilderModel);
            }

            return CODEBUILDERList;
        }

        #region 绑定model
        /// <summary>
        /// 绑定model
        /// </summary>
        /// <param name="drCODEBUILDER">datarow数据源</param>
        /// <param name="codebuilderModel">model对象</param>
        public static void BindDataRowToModel(DataRow drCODEBUILDER, Model.CODEBUILDERModel codebuilderModel)
        {
            if (drCODEBUILDER["CODEBUILDER_ID"].ToString() != "")
            {
                codebuilderModel.CODEBUILDER_ID = drCODEBUILDER["CODEBUILDER_ID"].TryParseToInt();    //代码生成内码
            }
            if (drCODEBUILDER["CODEBUILDER_PID"].ToString() != "")
            {
                codebuilderModel.CODEBUILDER_PID = drCODEBUILDER["CODEBUILDER_PID"].TryParseToInt();    //父级内码
            }
            if (drCODEBUILDER["CODEBUILDER_FORMAT"].ToString() != "")
            {
                codebuilderModel.CODEBUILDER_FORMAT = drCODEBUILDER["CODEBUILDER_FORMAT"].TryParseToShort();    //代码类型（1：接口；2：普通页面；3：小程序；4：报表页面）
            }
            codebuilderModel.FILE_NAME = drCODEBUILDER["FILE_NAME"].ToString();    //文件名称
            codebuilderModel.FILE_PATH = drCODEBUILDER["FILE_PATH"].ToString();    //文件路径
            if (drCODEBUILDER["INTERFACE_ID"].ToString() != "")
            {
                codebuilderModel.INTERFACE_ID = drCODEBUILDER["INTERFACE_ID"].TryParseToInt();    //主接口内码
            }
            if (drCODEBUILDER["INTERFACE_SUBID"].ToString() != "")
            {
                codebuilderModel.INTERFACE_SUBID = drCODEBUILDER["INTERFACE_SUBID"].TryParseToInt();    //附接口内码
            }
            codebuilderModel.CONTROL_ID = drCODEBUILDER["CONTROL_ID"].ToString();    //控件名称
            codebuilderModel.CONTROL_VALUE = drCODEBUILDER["CONTROL_VALUE"].ToString();    //控件内容
            if (drCODEBUILDER["CONTROL_INDEX"].ToString() != "")
            {
                codebuilderModel.CONTROL_INDEX = drCODEBUILDER["CONTROL_INDEX"].TryParseToInt();    //控件索引
            }
            if (drCODEBUILDER["CODEBUILDER_STATE"].ToString() != "")
            {
                codebuilderModel.CODEBUILDER_STATE = drCODEBUILDER["CODEBUILDER_STATE"].TryParseToShort();    //有效状态
            }
            if (drCODEBUILDER["OPERATE_DATE"].ToString() != "")
            {
                codebuilderModel.OPERATE_DATE = drCODEBUILDER["OPERATE_DATE"].TryParseToDateTime();    //操作时间
            }
            codebuilderModel.CODEBUILDER_DESC = drCODEBUILDER["CODEBUILDER_DESC"].ToString();    //备注说明
            codebuilderModel.CODEBUILDER_GUID = drCODEBUILDER["CODEBUILDER_GUID"].ToString();    //唯一标识
        }
        #endregion

        #endregion

        #region 获取代码生成表明细
        /// <summary>
        /// 获取代码生成表明细
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="CODEBUILDERId">代码生成表内码</param>
        public static Model.CODEBUILDERModel GetCODEBUILDERDetail(Transaction transaction, int CODEBUILDERId)
        {
            Model.CODEBUILDERModel codebuilderModel = new Model.CODEBUILDERModel();

            Business.CODEBUILDER _CODEBUILDER = new Business.CODEBUILDER(transaction);
            _CODEBUILDER.CODEBUILDER_ID = CODEBUILDERId;
            if (_CODEBUILDER.Select())
            {
                codebuilderModel.CODEBUILDER_ID = _CODEBUILDER.CODEBUILDER_ID;    //代码生成内码
                codebuilderModel.CODEBUILDER_PID = _CODEBUILDER.CODEBUILDER_PID;    //父级内码
                codebuilderModel.CODEBUILDER_FORMAT = _CODEBUILDER.CODEBUILDER_FORMAT;    //代码类型（1：接口；2：普通页面；3：小程序；4：报表页面）
                codebuilderModel.FILE_NAME = _CODEBUILDER.FILE_NAME;    //文件名称
                codebuilderModel.FILE_PATH = _CODEBUILDER.FILE_PATH;    //文件路径
                codebuilderModel.INTERFACE_ID = _CODEBUILDER.INTERFACE_ID;    //主接口内码
                codebuilderModel.INTERFACE_SUBID = _CODEBUILDER.INTERFACE_SUBID;    //附接口内码
                codebuilderModel.CONTROL_ID = _CODEBUILDER.CONTROL_ID;    //控件名称
                codebuilderModel.CONTROL_VALUE = _CODEBUILDER.CONTROL_VALUE;    //控件内容
                codebuilderModel.CONTROL_INDEX = _CODEBUILDER.CONTROL_INDEX;    //控件索引
                codebuilderModel.CODEBUILDER_STATE = _CODEBUILDER.CODEBUILDER_STATE;    //有效状态
                codebuilderModel.OPERATE_DATE = _CODEBUILDER.OPERATE_DATE;    //操作时间
                codebuilderModel.CODEBUILDER_DESC = _CODEBUILDER.CODEBUILDER_DESC;    //备注说明
                codebuilderModel.CODEBUILDER_GUID = _CODEBUILDER.CODEBUILDER_GUID;    //唯一标识
            }

            return codebuilderModel;
        }
        #endregion

        #region 同步代码生成表
        /// <summary>
        /// 赋值代码生成表数据对象
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="codebuilderModel">代码生成表数据对象</param>
        public static bool SynchroCODEBUILDER(Transaction transaction, Model.CODEBUILDERModel codebuilderModel)
        {
            bool SynchroFlag = true;

            Business.CODEBUILDER _CODEBUILDER = new Business.CODEBUILDER(transaction);
            if (codebuilderModel.CODEBUILDER_ID != null)
            {
                _CODEBUILDER.CODEBUILDER_ID = codebuilderModel.CODEBUILDER_ID;
                if (_CODEBUILDER.Select())
                {
                    SynchroModelToObject(_CODEBUILDER, codebuilderModel);
                    _CODEBUILDER.Update();
                }
                else
                {
                    SynchroFlag = false;
                }
            }
            else
            {
                SynchroModelToObject(_CODEBUILDER, codebuilderModel);
                _CODEBUILDER.Insert();
            }

            return SynchroFlag;
        }

        #region 赋值代码生成表数据对象
        /// <summary>
        /// 赋值代码生成表数据对象
        /// </summary>
        /// <param name="_CODEBUILDER"></param>
        /// <param name="codebuilderModel"></param>
        public static void SynchroModelToObject(Business.CODEBUILDER _CODEBUILDER, Model.CODEBUILDERModel codebuilderModel)
        {
            _CODEBUILDER.CODEBUILDER_PID = codebuilderModel.CODEBUILDER_PID;    //父级内码
            _CODEBUILDER.CODEBUILDER_FORMAT = codebuilderModel.CODEBUILDER_FORMAT;    //代码类型（1：接口；2：普通页面；3：小程序；4：报表页面）
            _CODEBUILDER.FILE_NAME = codebuilderModel.FILE_NAME;    //文件名称
            _CODEBUILDER.FILE_PATH = codebuilderModel.FILE_PATH;    //文件路径
            _CODEBUILDER.INTERFACE_ID = codebuilderModel.INTERFACE_ID;    //主接口内码
            _CODEBUILDER.INTERFACE_SUBID = codebuilderModel.INTERFACE_SUBID;    //附接口内码
            _CODEBUILDER.CONTROL_ID = codebuilderModel.CONTROL_ID;    //控件名称
            _CODEBUILDER.CONTROL_VALUE = codebuilderModel.CONTROL_VALUE;    //控件内容
            _CODEBUILDER.CONTROL_INDEX = codebuilderModel.CONTROL_INDEX;    //控件索引
            _CODEBUILDER.CODEBUILDER_STATE = codebuilderModel.CODEBUILDER_STATE;    //有效状态
            _CODEBUILDER.OPERATE_DATE = codebuilderModel.OPERATE_DATE;    //操作时间
            _CODEBUILDER.CODEBUILDER_DESC = codebuilderModel.CODEBUILDER_DESC;    //备注说明
            _CODEBUILDER.CODEBUILDER_GUID = codebuilderModel.CODEBUILDER_GUID;    //唯一标识
        }
        #endregion

        #endregion

        #region 删除代码生成表
        /// <summary>
        /// 删除代码生成表
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="CODEBUILDERId">代码生成表内码</param>
        public static bool DeleteCODEBUILDER(Transaction transaction, int? CODEBUILDERId)
        {
            bool DeleteFlag = false;

            if (CODEBUILDERId != null)
            {
                Business.CODEBUILDER _CODEBUILDER = new Business.CODEBUILDER(transaction);
                _CODEBUILDER.CODEBUILDER_ID = CODEBUILDERId;
                if (_CODEBUILDER.Select())
                {
                    _CODEBUILDER.CODEBUILDER_STATE = 0;
                    DeleteFlag = _CODEBUILDER.Update();
                }
            }

            return DeleteFlag;
        }
        #endregion

        #region 获取代码生成表嵌套列表
        /// <summary>
        /// 获取代码生成表嵌套列表
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="CODEBUILDER_PID">父级内码</param>
        /// <param name="CODEBUILDER_FORMAT">代码类型（1：接口；2：普通页面；3：小程序；4：报表页面）</param>
        /// <param name="CODEBUILDER_STATE">有效状态</param>
        /// <param name="SearchKey">模糊查询</param>
        /// <returns></returns>
        public static List<Model.NestingModel<Model.CODEBUILDERModel>> GetNestingCODEBUILDERList(Transaction transaction,
            string CODEBUILDER_PID, string CODEBUILDER_FORMAT, string CODEBUILDER_STATE, string SearchKey)
        {
            //申明嵌套列表集合
            List<Model.NestingModel<Model.CODEBUILDERModel>> nestingModelList = new List<Model.NestingModel<Model.CODEBUILDERModel>>();
            //赋值sql语句
            string WhereSQL = "";
            //查询父级内码
            if (!string.IsNullOrWhiteSpace(CODEBUILDER_PID))
            {
                WhereSQL += (WhereSQL == "" ? "WHERE " : " AND ") + "CODEBUILDER_PID IN (" + CODEBUILDER_PID + ")";
            }
            //查询代码类型（1：接口；2：普通页面；3：小程序；4：报表页面）
            if (!string.IsNullOrWhiteSpace(CODEBUILDER_FORMAT))
            {
                WhereSQL += (WhereSQL == "" ? "WHERE " : " AND ") + "CODEBUILDER_FORMAT IN (" + CODEBUILDER_FORMAT + ")";
            }
            //查询有效状态
            if (!string.IsNullOrWhiteSpace(CODEBUILDER_STATE))
            {
                WhereSQL += (WhereSQL == "" ? "WHERE " : " AND ") + "CODEBUILDER_STATE IN (" + CODEBUILDER_STATE + ")";
            }
            //查询代码生成表数据
            DataTable dtCODEBUILDER = new Business.CODEBUILDER(transaction).FillDataTable(WhereSQL);
            if (CODEBUILDER_PID == "-1")
            {
                //调用绑定数据的方法
                BindNestingList(nestingModelList, "-1", dtCODEBUILDER, SearchKey);
            }
            else
            {
                Business.CODEBUILDER _CODEBUILDER = new Business.CODEBUILDER(transaction);
                _CODEBUILDER.CODEBUILDER_ID_Encrypt = CODEBUILDER_PID.ToEncrypt();
                if (_CODEBUILDER.Select())
                {
                    //申明嵌套对象
                    Model.NestingModel<Model.CODEBUILDERModel> nestingModel = new Model.NestingModel<Model.CODEBUILDERModel>();
                    //申明代码生成表对象
                    Model.CODEBUILDERModel codebuilderModel = new Model.CODEBUILDERModel();
                    //将代码生成表赋值给代码生成表model
                    SynchroModelToObject(_CODEBUILDER, codebuilderModel);
                    //将代码生成表model添加到嵌套对象中去
                    nestingModel.node = codebuilderModel;
                    List<Model.NestingModel<Model.CODEBUILDERModel>> nestingModelListChild = new List<Model.NestingModel<Model.CODEBUILDERModel>>();
                    //调用绑定嵌套列表的方法
                    BindNestingList(nestingModelListChild, _CODEBUILDER.KeyID, dtCODEBUILDER, SearchKey);
                    //赋值子级
                    nestingModel.children = nestingModelListChild;
                    //过滤模糊查询条件
                    if (nestingModelListChild.Count > 0 || string.IsNullOrWhiteSpace(SearchKey))
                    {
                        nestingModelList.Add(nestingModel);
                    }
                }
            }
            dtCODEBUILDER.Clear();
            dtCODEBUILDER.Dispose();

            return nestingModelList;
        }

        #region 绑定嵌套列表
        /// <summary>
        /// 绑定嵌套列表
        /// </summary>
        /// <param name="CODEBUILDER_PID">上级分类</param>
        /// <param name="nestingModelList">嵌套列表</param>
        /// <param name="dtCODEBUILDER">代码生成表数据</param>
        /// <param name="SearchKey">模糊查询内容</param>
        public static void BindNestingList(List<Model.NestingModel<Model.CODEBUILDERModel>> nestingModelList,
            string CODEBUILDER_PID, DataTable dtCODEBUILDER, string SearchKey)
        {
            //遍历数据
            foreach (DataRow drCODEBUILDER in dtCODEBUILDER.Select("CODEBUILDER_PID = " +
                CODEBUILDER_PID, "CODEBUILDER_PID,CONTROL_INDEX"))
            {
                //申明嵌套对象
                Model.NestingModel<Model.CODEBUILDERModel> nestingModelChild = new Model.NestingModel<Model.CODEBUILDERModel>();
                //申明代码生成表对象
                Model.CODEBUILDERModel codebuilderModel = new Model.CODEBUILDERModel();
                //赋值代码生成表数据对象
                BindDataRowToModel(drCODEBUILDER, codebuilderModel);
                nestingModelChild.node = codebuilderModel;

                List<Model.NestingModel<Model.CODEBUILDERModel>> nestingModelListChild = new List<Model.NestingModel<Model.CODEBUILDERModel>>();
                //判断下一关系级下面是否还存在数据，没有则跳出遍历
                if (dtCODEBUILDER.Select("CODEBUILDER_PID = " + codebuilderModel.CODEBUILDER_ID).Length > 0)
                {
                    //调用绑定嵌套列表的方法
                    BindNestingList(nestingModelListChild, codebuilderModel.CODEBUILDER_ID.ToString(), dtCODEBUILDER, SearchKey);
                    //赋值子级
                    nestingModelChild.children = nestingModelListChild;
                }
                //过滤模糊查询条件
                if (nestingModelListChild.Count > 0 || string.IsNullOrWhiteSpace(SearchKey))
                {
                    nestingModelList.Add(nestingModelChild);
                }
            }
        }
        #endregion

        #endregion

        #region 获取代码生成表嵌套树
        /// <summary>
        /// 获取代码生成表嵌套树
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="CODEBUILDER_PID">父级内码</param>
        /// <param name="CODEBUILDER_FORMAT">代码类型（1：接口；2：普通页面；3：小程序；4：报表页面）</param>
        /// <param name="CODEBUILDER_STATE">有效状态</param>
        /// <param name="SearchKey">模糊查询</param>
        /// <returns></returns>
        public static List<Model.NestingModel<Model.CommonTypeModel>> GetNestingCODEBUILDERTree(Transaction transaction,
            string CODEBUILDER_PID, string CODEBUILDER_FORMAT, string CODEBUILDER_STATE, string SearchKey)
        {
            //申明嵌套树集合
            List<Model.NestingModel<Model.CommonTypeModel>> nestingModelList = new List<Model.NestingModel<Model.CommonTypeModel>>();
            //赋值sql语句
            string WhereSQL = "";
            //查询父级内码
            if (!string.IsNullOrWhiteSpace(CODEBUILDER_PID))
            {
                WhereSQL += (WhereSQL == "" ? "WHERE " : " AND ") + "CODEBUILDER_PID IN (" + CODEBUILDER_PID + ")";
            }
            //查询代码类型（1：接口；2：普通页面；3：小程序；4：报表页面）
            if (!string.IsNullOrWhiteSpace(CODEBUILDER_FORMAT))
            {
                WhereSQL += (WhereSQL == "" ? "WHERE " : " AND ") + "CODEBUILDER_FORMAT IN (" + CODEBUILDER_FORMAT + ")";
            }
            //查询有效状态
            if (!string.IsNullOrWhiteSpace(CODEBUILDER_STATE))
            {
                WhereSQL += (WhereSQL == "" ? "WHERE " : " AND ") + "CODEBUILDER_STATE IN (" + CODEBUILDER_STATE + ")";
            }
            //查询代码生成表数据
            DataTable dtCODEBUILDER = new Business.CODEBUILDER(transaction).FillDataTable(WhereSQL);
            if (CODEBUILDER_PID == "-1")
            {
                //调用绑定数据的方法
                BindNestingTree(nestingModelList, "-1", dtCODEBUILDER, SearchKey);
            }
            else
            {
                Business.CODEBUILDER _CODEBUILDER = new Business.CODEBUILDER(transaction);
                _CODEBUILDER.CODEBUILDER_ID_Encrypt = CODEBUILDER_PID.ToEncrypt();
                if (_CODEBUILDER.Select())
                {
                    //申明嵌套对象
                    Model.NestingModel<Model.CommonTypeModel> nestingModel = new Model.NestingModel<Model.CommonTypeModel>();
                    //申明代码生成表对象
                    Model.CommonTypeModel commonTypeModel = new Model.CommonTypeModel();
                    //将代码生成表赋值给CommonTypeModel
                    //绑定控件名称
                    commonTypeModel.label = _CODEBUILDER.CONTROL_ID;
                    //绑定代码生成内码
                    commonTypeModel.value = _CODEBUILDER.KeyID;
                    commonTypeModel.type = 1;//标识为子级节点
                    commonTypeModel.key = commonTypeModel.type + "-" + commonTypeModel.value;
                    //绑定唯一标识
                    if (!string.IsNullOrWhiteSpace(_CODEBUILDER.CODEBUILDER_GUID))
                    {
                        commonTypeModel.ico = _CODEBUILDER.CODEBUILDER_GUID;
                    }
                    //将commonTypeModel添加到嵌套对象中去
                    nestingModel.node = commonTypeModel;
                    List<Model.NestingModel<Model.CommonTypeModel>> nestingModelListChild = new List<Model.NestingModel<Model.CommonTypeModel>>();
                    //调用绑定数据的方法
                    BindNestingTree(nestingModelListChild, _CODEBUILDER.KeyID, dtCODEBUILDER, SearchKey);
                    //赋值子级
                    nestingModel.children = nestingModelListChild;
                    //过滤模糊查询条件
                    if (nestingModelListChild.Count > 0 || string.IsNullOrWhiteSpace(SearchKey))
                    {
                        nestingModelList.Add(nestingModel);
                    }
                }
            }
            dtCODEBUILDER.Clear();
            dtCODEBUILDER.Dispose();

            return nestingModelList;
        }

        #region 绑定嵌套树
        /// <summary>
        /// 绑定嵌套树
        /// </summary>
        /// <param name="CODEBUILDER_PID">上级分类</param>
        /// <param name="nestingModelList">嵌套列表</param>
        /// <param name="dtCODEBUILDER">代码生成表数据</param>
        /// <param name="SearchKey">模糊查询内容</param>
        public static void BindNestingTree(List<Model.NestingModel<Model.CommonTypeModel>> nestingModelList,
            string CODEBUILDER_PID, DataTable dtCODEBUILDER, string SearchKey)
        {
            //遍历数据
            foreach (DataRow drCODEBUILDER in dtCODEBUILDER.Select("CODEBUILDER_PID = " +
                CODEBUILDER_PID, "CODEBUILDER_PID,CONTROL_INDEX"))
            {
                //申明嵌套对象
                Model.NestingModel<Model.CommonTypeModel> nestingModelChild = new Model.NestingModel<Model.CommonTypeModel>();
                //申明代码生成表对象
                Model.CommonTypeModel commonTypeModel = new Model.CommonTypeModel();
                //将代码生成表赋值给CommonTypeModel
                //绑定控件名称
                commonTypeModel.label = drCODEBUILDER["CONTROL_ID"].ToString();
                //绑定代码生成内码
                commonTypeModel.value = drCODEBUILDER["CODEBUILDER_ID"].ToString();
                commonTypeModel.type = 1;//标识为子级节点
                commonTypeModel.key = commonTypeModel.type + "-" + commonTypeModel.value;
                //绑定唯一标识
                if (!string.IsNullOrWhiteSpace(drCODEBUILDER["CODEBUILDER_GUID"].ToString()))
                {
                    commonTypeModel.ico = drCODEBUILDER["CODEBUILDER_GUID"].ToString();
                }
                nestingModelChild.node = commonTypeModel;

                List<Model.NestingModel<Model.CommonTypeModel>> nestingModelListChild = new List<Model.NestingModel<Model.CommonTypeModel>>();
                //判断下一关系级下面是否还存在数据，没有则跳出遍历
                if (dtCODEBUILDER.Select("CODEBUILDER_PID = " + drCODEBUILDER["CODEBUILDER_ID"]).Length > 0)
                {
                    //调用绑定嵌套列表的方法
                    BindNestingTree(nestingModelListChild, drCODEBUILDER["CODEBUILDER_ID"].ToString(), dtCODEBUILDER, SearchKey);
                    //赋值子级
                    nestingModelChild.children = nestingModelListChild;
                }
                //过滤模糊查询条件
                if (nestingModelListChild.Count > 0 || string.IsNullOrWhiteSpace(SearchKey))
                {
                    nestingModelList.Add(nestingModelChild);
                }
            }
        }
        #endregion

        #endregion

        #region 方法 -> 生成接口代码
        /// <summary>
        /// 生成接口代码
        /// </summary>
        /// <param name="interfaceCodeModel"></param>
        /// <returns></returns>
        public static Model.InterfaceCodeResModel BuildInterfaceCode(Model.InterfaceCodeModel interfaceCodeModel)
        {
            Model.InterfaceCodeResModel interfaceCodeResModel = new Model.InterfaceCodeResModel();
            //获取接口传入的SQL条件语句、SQL查询语句
            string txtSearchParams = interfaceCodeModel.txtSearchParams, txtSQLString = interfaceCodeModel.txtSQLString;
            DataTable dtInterfaceModel = null, dtNewTable = null;
            JObject AdvancedConfig = null;
            //解析接口字段数据源
            if (!string.IsNullOrWhiteSpace(interfaceCodeModel.str_dtInterfaceModel))
            {
                dtInterfaceModel = JsonConvert.DeserializeObject<DataTable>(interfaceCodeModel.str_dtInterfaceModel);

                if (dtInterfaceModel.Select("ShowResponse = 1").Length == 0) return null;

                //如果字段没有设置过重命名，则重命名的字段和字段名称一致
                foreach (DataRow drIM in dtInterfaceModel.Rows)
                {
                    if (drIM["ColumnParamsRename"].ToString() == "")
                    {
                        drIM["ColumnParamsRename"] = drIM["INTERFACEMODEL_NAME"];
                    }
                    if (drIM["ColumnResponseRename"].ToString() == "")
                    {
                        drIM["ColumnResponseRename"] = drIM["INTERFACEMODEL_NAME"];
                    }
                }
            }
            //解析额外新增的数据表命名空间
            if (!string.IsNullOrWhiteSpace(interfaceCodeModel.str_dtNewTable))
            {
                dtNewTable = JsonConvert.DeserializeObject<DataTable>(interfaceCodeModel.str_dtNewTable);
            }
            //解析传入的接口中的合计项字段、按照日/月/年统计的时间字段
            if (!string.IsNullOrWhiteSpace(interfaceCodeModel.str_AdvancedConfig))
            {
                AdvancedConfig = JObject.Parse(interfaceCodeModel.str_AdvancedConfig);
            }
            //申明变量，是否为商品相关的接口
            bool CommController = false;
            if (interfaceCodeModel.HostWholetableName == "HIGHWAY_STORAGE.T_COMMODITY" ||
                interfaceCodeModel.SubWholetableName == "HIGHWAY_STORAGE.T_COMMODITY")
            {
                CommController = true;
            }

            //生成接口代码
            interfaceCodeResModel.Controller_cs = InterfaceCodeHelper.GetController(interfaceCodeModel.InterfaceDomainName,
                interfaceCodeModel.InterfaceController, interfaceCodeModel.InterfaceRoute, interfaceCodeModel.InterfaceName,
                interfaceCodeModel.CombineModelField, interfaceCodeModel.HeaderRequest, interfaceCodeModel.ListModelField,
                dtInterfaceModel, interfaceCodeModel.InterfaceDesc, CommController).ToString();
            //获取主表和附表的命名空间，存储格式：主表命名空间,附表命名空间
            string HostnameSpace = interfaceCodeModel.HostnameSpace, SubnameSpace = "";
            if (!string.IsNullOrWhiteSpace(HostnameSpace))
            {
                HostnameSpace = interfaceCodeModel.HostnameSpace.Split(',')[0];
                if (interfaceCodeModel.HostnameSpace.Contains(","))
                {
                    SubnameSpace = interfaceCodeModel.HostnameSpace.Split(',')[1];
                }
            }
            //生成接口相关方法代码
            interfaceCodeResModel.Helper_cs = InterfaceCodeHelper.GetHelper(interfaceCodeModel.HostClassName,
                HostnameSpace, interfaceCodeModel.HostWholetableName, interfaceCodeModel.SubWholetableName,
                interfaceCodeModel.Hostfield, interfaceCodeModel.Subfield, interfaceCodeModel.SubclassName, SubnameSpace,
                interfaceCodeModel.InterfaceController, interfaceCodeModel.InterfaceRoute, interfaceCodeModel.CombineModelField,
                interfaceCodeModel.ListModelField, interfaceCodeModel.InterfaceName, ref txtSearchParams, ref txtSQLString,
                dtInterfaceModel, dtNewTable, AdvancedConfig, interfaceCodeModel.InterfaceDesc, CommController).ToString();
            //生成接口相关对象代码
            interfaceCodeResModel.Model_cs = InterfaceCodeHelper.GetDataModel(interfaceCodeModel.InterfaceName,
                interfaceCodeModel.CombineModelField, interfaceCodeModel.ListModelField, interfaceCodeModel.SubtableName,
                interfaceCodeModel.SubclassName, dtInterfaceModel, AdvancedConfig).ToString();
            //生成接口where查询条件语句
            interfaceCodeResModel.txtSearchParams = txtSearchParams;
            //生成接口SQL查询语句
            interfaceCodeResModel.txtSQLString = txtSQLString;

            return interfaceCodeResModel;
        }
        #endregion

        #region 方法 -> 生成前端页面代码
        /// <summary>
        /// 生成前端页面代码
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="webPageCodeModel">生成前端页面代码的控件内容相关类</param>
        public static Model.WebPageCodeResModel BuildWebPageCode(Transaction transaction, Model.WebPageCodeModel webPageCodeModel)
        {
            Model.WebPageCodeResModel webPageCodeResModel = new Model.WebPageCodeResModel();

            Business.INTERFACE INTERFACEHost = new Business.INTERFACE(transaction);
            INTERFACEHost.INTERFACE_ID = webPageCodeModel.HostInterfaceId;
            if (INTERFACEHost.Select())
            {
                //查询接口入参数据
                DataTable dtInterfaceParams = Business.INTERFACE.GetInterfaceDatas(transaction, 2, INTERFACEHost.INTERFACE_ID);
                //查询接口入参对象数据
                DataTable dtInterfaceParamsModel = Business.INTERFACE.GetInterfaceDatas(transaction, 4, INTERFACEHost.INTERFACE_ID);
                //查询接口返参数据
                DataTable dtInterfaceResponse = Business.INTERFACE.GetInterfaceDatas(transaction, 3, INTERFACEHost.INTERFACE_ID);
                //查询接口返参对象数据
                DataTable dtInterfaceResponseModel = Business.INTERFACE.GetInterfaceDatas(transaction, 5, INTERFACEHost.INTERFACE_ID);

                //获取主接口类型
                webPageCodeModel.InterfaceType = INTERFACEHost.INTERFACE_TYPE;
                //获取主接口类名称
                webPageCodeModel.HostClassName = CommonHelper.GetInterfaceClassName(
                    INTERFACEHost.INTERFACE_TYPE.Value, INTERFACEHost.INTERFACE_ROUTE);
                //获取主接口相关对象名称
                webPageCodeModel.HostModelName = CommonHelper.GetClassModelName(webPageCodeModel.HostClassName);

                #region 获取接口服务代码
                //主接口相关数据源
                DataTable dtInterface;
                if (INTERFACEHost.INTERFACE_TYPE == 0)
                {
                    dtInterface = INTERFACEHost.FillDataTable("WHERE INTERFACE_PID = '" + INTERFACEHost.INTERFACE_ID + "'");
                    if (dtInterface.Select("INTERFACE_NAME like '获取列表【%'").Length > 0)
                    {
                        dtInterfaceResponseModel = Business.INTERFACE.GetInterfaceDatas(transaction, 5,
                            dtInterface.Select("INTERFACE_NAME like '获取列表【%'")[0]["INTERFACE_ID"].TryParseToInt());
                    }
                }
                else
                {
                    dtInterface = INTERFACEHost.FillDataTable("WHERE INTERFACE_ID = '" + INTERFACEHost.INTERFACE_ID + "'");

                    if (INTERFACEHost.INTERFACE_TYPE > 1)
                    {
                        //非标准接口的唯一键值取curIndex
                        if (webPageCodeModel.interfaceNameSpaceModel != null && string.IsNullOrWhiteSpace(
                            webPageCodeModel.interfaceNameSpaceModel.DDLUniqueName))
                        {
                            webPageCodeModel.interfaceNameSpaceModel.DDLUniqueName = "curIndex";
                        }
                    }
                }
                //获取接口入参对象名称
                string ParamsName = webPageCodeModel.interfaceNameSpaceModel != null ?
                    webPageCodeModel.interfaceNameSpaceModel.txtParamsName : "";

                //申明关联接口返参字段数据源
                DataTable dtGridViewExRelate = null;
                //获取关联接口字段数据源
                if (webPageCodeModel.relateInterfaceModel != null)
                {
                    //关联接口相关数据源
                    DataTable dtInterfaceRelate;
                    if (webPageCodeModel.relateInterfaceModel.RelateInterfaceId != null)
                    {
                        Business.INTERFACE INTERFACERelate = new Business.INTERFACE(transaction);
                        INTERFACERelate.INTERFACE_ID = webPageCodeModel.relateInterfaceModel.RelateInterfaceId;
                        if (INTERFACERelate.Select())
                        {
                            //申明接口入参字段数据源
                            DataTable ParamsTable = null;

                            if (INTERFACERelate.INTERFACE_TYPE == 0)
                            {
                                //获取关联表相关接口
                                dtInterfaceRelate = INTERFACERelate.FillDataTable(
                                    "WHERE INTERFACE_PID = '" + INTERFACERelate.INTERFACE_ID + "'");
                                //关联接口-查询获取明细接口
                                if (dtInterfaceRelate.Select("INTERFACE_NAME like '获取明细%'").Length > 0)
                                {
                                    DataRow _DataRow = dtInterfaceRelate.Select("INTERFACE_NAME like '获取明细%'")[0];
                                    ParamsTable = new Business.INTERFACEPARAMS(transaction).FillDataTable(
                                        "WHERE INTERFACE_ID = " + _DataRow["INTERFACE_ID"] + " AND INTERFACEPARAMS_NAME = '" +
                                            webPageCodeModel.relateInterfaceModel.RelateField + "'");
                                    dtGridViewExRelate = Business.INTERFACE.GetInterfaceDatas(transaction, 5,
                                        _DataRow["INTERFACE_ID"].TryParseToInt());
                                }

                                webPageCodeModel.relateInterfaceModel.RelateClassName = INTERFACERelate.INTERFACE_ROUTE;
                                webPageCodeModel.relateInterfaceModel.RelateModelName = CommonHelper.GetClassModelName(
                                    webPageCodeModel.relateInterfaceModel.RelateClassName);
                            }
                            else
                            {
                                dtInterfaceRelate = INTERFACERelate.FillDataTable(
                                    "WHERE INTERFACE_ID = '" + INTERFACERelate.INTERFACE_ID + "'");
                                dtGridViewExRelate = Business.INTERFACE.GetInterfaceDatas(
                                    transaction, 5, INTERFACERelate.INTERFACE_ID);

                                webPageCodeModel.relateInterfaceModel.RelateClassName =
                                    CommonHelper.GetInterfaceClassName(transaction, INTERFACERelate.INTERFACE_ID.Value);
                                webPageCodeModel.relateInterfaceModel.RelateModelName = CommonHelper.GetClassModelName(
                                    webPageCodeModel.relateInterfaceModel.RelateClassName);
                            }

                            //生成前端页面的接口文件
                            webPageCodeResModel.txtservice_ts = WebPageCodeHelper.GetService(transaction,
                                dtInterface, ParamsTable, ParamsName, webPageCodeModel.HostClassName, webPageCodeModel.HostModelName,
                                dtInterfaceRelate, webPageCodeModel.relateInterfaceModel.RelateClassName,
                                webPageCodeModel.relateInterfaceModel.RelateModelName).ToString();
                        }
                    }
                }
                else
                {
                    //生成前端页面的接口文件
                    webPageCodeResModel.txtservice_ts = WebPageCodeHelper.GetService(transaction, dtInterface, null,
                        ParamsName, webPageCodeModel.HostClassName, webPageCodeModel.HostModelName).ToString();
                }
                #endregion

                //获取页面引用对象代码
                webPageCodeResModel.txtdata_d_ts = WebPageCodeHelper.GetDataModel(dtInterfaceParams,
                    dtInterfaceParamsModel, ParamsName, dtInterfaceResponseModel, dtGridViewExRelate).ToString();

                //获取列表页面代码
                webPageCodeResModel.txtIndex_tsx = WebPageCodeHelper.GetIndex(webPageCodeModel, dtInterfaceParams).ToString();

                //获取antd框架路由代码
                if (webPageCodeModel.CreateRoute == null || webPageCodeModel.CreateRoute.Value)
                {
                    StringBuilder sbRoute = new StringBuilder();
                    if (WebPageCodeHelper.GetRoute(ref sbRoute, 0, Config.AppSettings.IndexPageDir, "",
                        "/" + Config.AppSettings.IndexPageDir + "/" + webPageCodeModel.HostClassName, "", 0, null, false, 3000))
                    {
                        webPageCodeResModel.txtroutes_ts = sbRoute.ToString();
                    }
                }
            }

            return webPageCodeResModel;
        }
        #endregion

        #region 方法 -> 执行SQL语句，返回Datatable数据集
        /// <summary>
        /// 执行SQL语句，返回Datatable数据集
        /// </summary>
        /// <param name="transaction"></param>
        /// <param name="exSQLParam">执行SQL语句入参对象：<br/>
        /// HostInterfaceId：主表接口内码<br/>
        /// SubInterfaceId：附表接口内码<br/>
        /// txtSQLString：SQL语句内容<br/>
        /// AdvancedConfig：额外的配置项
        /// </param>
        /// <returns></returns>
        public static DataTable ExcuteSQLString(Transaction transaction, Model.ExSQLParam exSQLParam)
        {
            DataTable dtSQLResultClone = null;

            string InterfaceModelId = "";
            Business.INTERFACE _INTERFACE = new Business.INTERFACE(transaction);
            _INTERFACE.INTERFACE_ID = exSQLParam.HostInterfaceId;
            if (!_INTERFACE.Select())
            {
                return dtSQLResultClone;
            }

            Business.INTERFACEMODEL _INTERFACEMODEL = new Business.INTERFACEMODEL(transaction);
            if (_INTERFACE.INTERFACE_TYPE == 0)
            {
                _INTERFACEMODEL.AddSearchParameter("INTERFACEMODEL_NAME", _INTERFACE.INTERFACE_ROUTE + "Model");
                _INTERFACEMODEL.AddSearchParameter("INTERFACEMODEL_PID", -1);
                _INTERFACEMODEL.AddSearchParameter("INTERFACEMODEL_FORMAT", 4);
                if (_INTERFACEMODEL.Search())
                {
                    InterfaceModelId = _INTERFACEMODEL.KeyID;
                }
            }
            else
            {
                Business.INTERFACERESPONSE _INTERFACERESPONSE = new Business.INTERFACERESPONSE(transaction);
                _INTERFACERESPONSE.AddSearchParameter("INTERFACE_ID", exSQLParam.HostInterfaceId);
                if (_INTERFACERESPONSE.Search() && _INTERFACERESPONSE.INTERFACEMODEL_ID != null)
                {
                    _INTERFACEMODEL.INTERFACEMODEL_ID = _INTERFACERESPONSE.INTERFACEMODEL_ID;
                    if (_INTERFACEMODEL.Select())
                    {
                        InterfaceModelId = _INTERFACEMODEL.KeyID;
                    }
                }
            }
            if (string.IsNullOrWhiteSpace(InterfaceModelId))
            {
                return dtSQLResultClone;
            }

            //获取session中的高级配置信息
            JObject AdvancedConfig = null;
            if (!string.IsNullOrWhiteSpace(exSQLParam.AdvancedConfig))
            {
                AdvancedConfig = JObject.Parse(exSQLParam.AdvancedConfig);
            }
            //定义SQL语句执行结果
            DataTable dtSQLResult = null;
            //去除SQL语句中的和查询无关的字符
            string SQLString = exSQLParam.txtSQLString.Replace("{0}", "").Replace(
                "\", WhereSQL);", "").Replace("string SQLString = string.Format(@\"", "");
            //根据关联的数据库表，匹配查询对象
            if (_INTERFACEMODEL.DATABASETABLE_ID != null)
            {
                Business.DATABASETABLE _DATABASETABLE = new Business.DATABASETABLE(transaction);
                _DATABASETABLE.DATABASETABLE_ID = _INTERFACEMODEL.DATABASETABLE_ID;
                if (_DATABASETABLE.Select())
                {
                    switch (_DATABASETABLE.DATABASEINFO_NAME)
                    {
                        case "云平台正式库":
                            dtSQLResult = new Business.ANTDROUTE(transaction).ExecuteDataTable(SQLString);
                            break;
                        case "合作商户平台":
                            dtSQLResult = new CMB.AUTOTYPE(transaction).ExecuteDataTable(SQLString);
                            break;
                        default:
                            dtSQLResult = new MSPB.AUTOTYPE(transaction).ExecuteDataTable(SQLString);
                            break;
                    }
                }
            }
            else
            {
                dtSQLResult = new Business.ANTDROUTE(transaction).ExecuteDataTable(SQLString);
            }
            dtSQLResult = CommonHelper.GetDataTableWithPageSize(dtSQLResult, 10, 1);

            //定义查询结果的字段注解
            dtSQLResultClone = dtSQLResult.Clone();

            #region 显示每个字段的中文解释
            //获取列表上设置的字段内容
            //DataTable dtInterfaceModel = GetGridViewDataSet();
            ////遍历返参字段列表，获取字段中文释义
            //DataRow drComment = dtSQLResultClone.NewRow();
            //foreach (DataColumn dcComment in dtSQLResultClone.Columns)
            //{
            //    //查询返参字段的中文释义
            //    if (dtInterfaceModel.Select("ColumnResponseRename = '" + dcComment.ColumnName + "'").Length > 0)
            //    {
            //        DataRow drInterfaceModel = dtInterfaceModel.Select("ColumnResponseRename = '" + dcComment.ColumnName + "'")[0];
            //        //绑定中文释义
            //        drComment[dcComment] = drInterfaceModel["INTERFACEMODEL_COMMENT"].ToString().Split('(')[0].Split('（')[0];
            //        if (drInterfaceModel["DataSummary"].ToString() == "1")
            //        {
            //            drComment[dcComment] = drComment[dcComment].ToString() + "合计值";
            //        }
            //        else if (drInterfaceModel["DataSummary"].ToString() == "2")
            //        {
            //            drComment[dcComment] = drComment[dcComment].ToString() + "总数量";
            //        }
            //    }
            //    else if (AdvancedConfig != null && AdvancedConfig.ToString().Contains(dcComment.ColumnName))
            //    {
            //        drComment[dcComment] = AdvancedConfig.ToString().Split(dcComment.ColumnName)[1].Split("\"")[4].Trim('\\');
            //    }
            //}
            ////添加字段注解到第一行
            //dtSQLResultClone.Rows.InsertAt(drComment, 0);
            #endregion

            //遍历查询结果，添加到克隆的数据源中
            int RowCount = 0;
            foreach (DataRow drSQLResult in dtSQLResult.Rows)
            {
                //默认返回100行数据
                if (RowCount == 100) break;

                DataRow drData = dtSQLResultClone.NewRow();
                for (int CellCount = 0; CellCount < drSQLResult.ItemArray.Length; CellCount++)
                {
                    drData[CellCount] = drSQLResult[CellCount];
                }
                dtSQLResultClone.Rows.Add(drData);
            }

            return dtSQLResultClone;
        }
        #endregion

        #region 方法 -> 发布接口代码文件
        /// <summary>
        /// 发布接口代码文件
        /// </summary>
        /// <param name="transaction"></param>
        /// <param name="createFileParam">接口代码文件入参</param>
        /// <param name="RebuildslnLogName">重新编译解决方案的日志文件名称</param>
        public static bool CreateInterfaceFile(Transaction transaction, Model.CreateITFFileParam createFileParam, string RebuildslnLogName)
        {
            //生成具体页面文件
            CreateFile(createFileParam.InterfaceController, createFileParam.UniqueCode, createFileParam.str_Controller_cs,
                createFileParam.str_Helper_cs, createFileParam.str_Model_cs, RebuildslnLogName);

            DataTable dtInterfaceModel = JsonConvert.DeserializeObject<DataTable>(createFileParam.str_dtInterfaceModel);

            if (dtInterfaceModel.Select("ShowResponse = 1").Length == 0) return false;

            //如果字段没有设置过重命名，则重命名的字段和字段名称一致
            foreach (DataRow drIM in dtInterfaceModel.Rows)
            {
                if (drIM["ColumnParamsRename"].ToString() == "")
                {
                    drIM["ColumnParamsRename"] = drIM["INTERFACEMODEL_NAME"];
                }
                if (drIM["ColumnResponseRename"].ToString() == "")
                {
                    drIM["ColumnResponseRename"] = drIM["INTERFACEMODEL_NAME"];
                }
            }
            //获取session中的高级配置信息 判断是否有存了合计的分类值
            JObject AdvancedConfig = null;
            if (!string.IsNullOrWhiteSpace(createFileParam.str_AdvancedConfig))
            {
                AdvancedConfig = JObject.Parse(createFileParam.str_AdvancedConfig);
            }

            #region 添加集合表数据对象
            Business.INTERFACEMODEL INTERFACEMODELCombine = new Business.INTERFACEMODEL(transaction);
            INTERFACEMODELCombine.AddSearchParameter("INTERFACEMODEL_PID", -1);
            INTERFACEMODELCombine.AddSearchParameter("INTERFACEMODEL_FORMAT", 4);
            INTERFACEMODELCombine.AddSearchParameter("INTERFACEMODEL_NAME", createFileParam.CombineModelField);
            if (!INTERFACEMODELCombine.Search())
            {
                INTERFACEMODELCombine.ResetProperty();
                INTERFACEMODELCombine.INTERFACEMODEL_PID = -1;
                INTERFACEMODELCombine.INTERFACEMODEL_FORMAT = 4;
                INTERFACEMODELCombine.INTERFACEMODEL_NAME = createFileParam.CombineModelField;
                INTERFACEMODELCombine.INTERFACEMODEL_COMMENT = createFileParam.InterfaceName.Split(',')[0] + "相关类";
                INTERFACEMODELCombine.Insert();
            }
            else
            {
                INTERFACEMODELCombine.ExecuteNonQuery("DELETE FROM T_INTERFACEMODEL WHERE INTERFACEMODEL_PID = " +
                    INTERFACEMODELCombine.KeyID, null);
            }
            //绑定集合接口参数对象
            DataRow[] dataRowCombine = dtInterfaceModel.Select("ShowResponse = 1",
                "ColumnResponseIndex,ModelDataType,INTERFACEMODEL_ID");
            Business.INTERFACE.SaveModelToOracle(transaction, dataRowCombine, INTERFACEMODELCombine.INTERFACEMODEL_ID, AdvancedConfig);
            #endregion

            Business.INTERFACEMODEL INTERFACEMODELList = new Business.INTERFACEMODEL(transaction);

            //如果有第二个接口（也就是主附表列表接口），则保存对应的参数对象
            if (createFileParam.InterfaceName.Split(',').Length > 1)
            {
                #region 添加列表数据对象

                #region 添加附表数据对象
                Business.INTERFACEMODEL INTERFACEMODELSub = new Business.INTERFACEMODEL(transaction);
                INTERFACEMODELSub.AddSearchParameter("INTERFACEMODEL_PID", -1);
                INTERFACEMODELSub.AddSearchParameter("INTERFACEMODEL_FORMAT", 4);
                INTERFACEMODELSub.AddSearchParameter("INTERFACEMODEL_NAME", createFileParam.SubClassName + "SubModel");
                if (!INTERFACEMODELSub.Search())
                {
                    INTERFACEMODELSub.ResetProperty();
                    INTERFACEMODELSub.INTERFACEMODEL_PID = -1;
                    INTERFACEMODELSub.INTERFACEMODEL_FORMAT = 4;
                    INTERFACEMODELSub.INTERFACEMODEL_NAME = createFileParam.SubClassName + "SubModel";
                    INTERFACEMODELSub.INTERFACEMODEL_COMMENT = createFileParam.InterfaceName.Split(',')[1] + "附表相关类";
                    INTERFACEMODELSub.Insert();
                }
                else
                {
                    INTERFACEMODELSub.ExecuteNonQuery("DELETE FROM T_INTERFACEMODEL WHERE INTERFACEMODEL_PID = " + INTERFACEMODELSub.KeyID, null);
                }
                //绑定列表接口附表参数对象
                DataRow[] dataRowSub = dtInterfaceModel.Select("ShowResponse = 1 and ModelDataType = 2",
                    "ColumnResponseIndex,ModelDataType,INTERFACEMODEL_ID");
                Business.INTERFACE.SaveModelToOracle(transaction, dataRowSub, INTERFACEMODELSub.INTERFACEMODEL_ID, AdvancedConfig);
                #endregion

                #region 添加列表数据对象
                INTERFACEMODELList.AddSearchParameter("INTERFACEMODEL_PID", -1);
                INTERFACEMODELList.AddSearchParameter("INTERFACEMODEL_FORMAT", 4);
                INTERFACEMODELList.AddSearchParameter("INTERFACEMODEL_NAME", createFileParam.ListModelField);
                if (!INTERFACEMODELList.Search())
                {
                    INTERFACEMODELList.ResetProperty();
                    INTERFACEMODELList.INTERFACEMODEL_PID = -1;
                    INTERFACEMODELList.INTERFACEMODEL_FORMAT = 4;
                    INTERFACEMODELList.INTERFACEMODEL_NAME = createFileParam.ListModelField;
                    INTERFACEMODELList.INTERFACEMODEL_COMMENT = createFileParam.InterfaceName.Split(',')[1] + "相关类";
                    INTERFACEMODELList.Insert();
                }
                else
                {
                    INTERFACEMODELList.ExecuteNonQuery("DELETE FROM T_INTERFACEMODEL WHERE INTERFACEMODEL_PID = " + INTERFACEMODELList.KeyID, null);
                }

                //绑定列表接口主表参数对象
                DataRow[] dataRowList = dtInterfaceModel.Select("ShowResponse = 1 and ModelDataType in (1,3)",
                    "ColumnResponseIndex,ModelDataType,INTERFACEMODEL_ID");
                Business.INTERFACE.SaveModelToOracle(transaction, dataRowList, INTERFACEMODELList.INTERFACEMODEL_ID, AdvancedConfig);
                //添加主表对象中的附表集合
                Business.INTERFACEMODEL SubListModel = new Business.INTERFACEMODEL(transaction);
                SubListModel.INTERFACEMODEL_PID = INTERFACEMODELList.INTERFACEMODEL_ID;
                SubListModel.INTERFACEMODEL_FORMAT = 5;
                SubListModel.INTERFACEMODEL_USEDID = INTERFACEMODELSub.INTERFACEMODEL_ID;
                SubListModel.INTERFACEMODEL_NAME = createFileParam.SubClassName + "SubList";
                SubListModel.INTERFACEMODEL_COMMENT = createFileParam.SubTableName + "集合";
                SubListModel.Insert();

                #endregion

                #endregion
            }

            #region 保存接口表、入参表、返参表、接口数据库表关联数据
            int RouteCount = 0;
            foreach (string Route in createFileParam.InterfaceRoute.Split(','))
            {
                Business.INTERFACE _INTERFACE = new Business.INTERFACE(transaction);
                _INTERFACE.AddSearchParameter("INTERFACE_ROUTE", Route);
                if (!_INTERFACE.Search())
                {
                    //插入接口主表
                    _INTERFACE.ResetProperty();
                    _INTERFACE.INTERFACE_NAME = createFileParam.InterfaceName.Split(',')[RouteCount];
                    _INTERFACE.INTERFACE_ROUTE = Route;
                    _INTERFACE.INTERFACE_DOMAINNAME = "https://api.eshangtech.com/" + createFileParam.InterfaceDomainName;
                    _INTERFACE.INTERFACE_ACCEPTVERBS = 1;
                    _INTERFACE.INTERFACE_CONTROLLER = createFileParam.InterfaceController;
                    _INTERFACE.PARAMS_FORMAT = 0;
                    _INTERFACE.RESPONSE_FORMAT = 2;
                    _INTERFACE.STANDARD_TYPE = 0;
                    _INTERFACE.INTERFACE_PID = -1;
                    _INTERFACE.INTERFACE_TYPE = createFileParam.InterfaceType.TryParseToShort();
                    _INTERFACE.INTERFACE_DESC = createFileParam.InterfaceDesc;
                    _INTERFACE.Insert();
                }
                else
                {
                    //更新接口表数据
                    _INTERFACE.INTERFACE_NAME = createFileParam.InterfaceName.Split(',')[RouteCount];
                    _INTERFACE.INTERFACE_ROUTE = Route;
                    _INTERFACE.INTERFACE_DOMAINNAME = "https://api.eshangtech.com/" + createFileParam.InterfaceDomainName;
                    _INTERFACE.INTERFACE_CONTROLLER = createFileParam.InterfaceController;
                    _INTERFACE.INTERFACE_TYPE = createFileParam.InterfaceType.TryParseToShort();
                    _INTERFACE.INTERFACE_DESC = createFileParam.InterfaceDesc;
                    _INTERFACE.Update();
                    //删除接口相关的表，需要重新插入
                    _INTERFACE.ExecuteNonQuery("DELETE FROM T_RTINTERFACETABLE WHERE INTERFACE_ID = " + _INTERFACE.KeyID, null);
                    _INTERFACE.ExecuteNonQuery("DELETE FROM T_INTERFACEPARAMS WHERE INTERFACE_ID = " + _INTERFACE.KeyID, null);
                    _INTERFACE.ExecuteNonQuery("DELETE FROM T_INTERFACERESPONSE WHERE INTERFACE_ID = " + _INTERFACE.KeyID, null);
                    _INTERFACE.ExecuteNonQuery("DELETE FROM T_RTINTERFACESQL WHERE INTERFACE_ID = " + _INTERFACE.KeyID, null);
                }

                //插入接口数据库表关联
                if (!string.IsNullOrWhiteSpace(createFileParam.HostModelId))
                {
                    Business.INTERFACEMODEL _INTERFACEMODEL = new Business.INTERFACEMODEL(transaction);
                    _INTERFACEMODEL.INTERFACEMODEL_ID_Encrypt = createFileParam.HostModelId.ToEncrypt();
                    if (_INTERFACEMODEL.Select() && _INTERFACEMODEL.DATABASETABLE_ID != null)
                    {
                        Business.RTINTERFACETABLE _RTINTERFACETABLE = new Business.RTINTERFACETABLE(transaction);
                        _RTINTERFACETABLE.DATABASETABLE_ID = _INTERFACEMODEL.DATABASETABLE_ID;
                        _RTINTERFACETABLE.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                        //_RTINTERFACETABLE.STAFF_ID = PassportInfo.ID;
                        //_RTINTERFACETABLE.STAFF_NAME = PassportInfo.Name;
                        _RTINTERFACETABLE.OPERATE_DATE = DateTime.Now;
                        _RTINTERFACETABLE.RTINTERFACETABLE_DESC = createFileParam.InterfaceDesc;
                        _RTINTERFACETABLE.Insert();
                    }
                }
                //插入接口和数据库表关联关系
                if (!string.IsNullOrWhiteSpace(createFileParam.SubModelId))
                {
                    Business.INTERFACEMODEL _INTERFACEMODEL = new Business.INTERFACEMODEL(transaction);
                    _INTERFACEMODEL.INTERFACEMODEL_ID_Encrypt = createFileParam.SubModelId.ToEncrypt();
                    if (_INTERFACEMODEL.Select() && _INTERFACEMODEL.DATABASETABLE_ID != null)
                    {
                        Business.RTINTERFACETABLE _RTINTERFACETABLE = new Business.RTINTERFACETABLE(transaction);
                        _RTINTERFACETABLE.DATABASETABLE_ID = _INTERFACEMODEL.DATABASETABLE_ID;
                        _RTINTERFACETABLE.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                        //_RTINTERFACETABLE.STAFF_ID = PassportInfo.ID;
                        //_RTINTERFACETABLE.STAFF_NAME = PassportInfo.Name;
                        _RTINTERFACETABLE.OPERATE_DATE = DateTime.Now;
                        _RTINTERFACETABLE.RTINTERFACETABLE_DESC = createFileParam.InterfaceDesc;
                        _RTINTERFACETABLE.Insert();
                    }
                }
                //获取session中的其他数据库表信息
                if (!string.IsNullOrWhiteSpace(createFileParam.str_dtOtherTable))
                {
                    DataTable dtNewTable = JsonConvert.DeserializeObject<DataTable>(createFileParam.str_dtOtherTable);
                    if (dtNewTable.Rows.Count > 0)
                    {
                        foreach (DataRow drNewTable in dtNewTable.Rows)
                        {
                            Business.RTINTERFACETABLE _RTINTERFACETABLE = new Business.RTINTERFACETABLE(transaction);
                            _RTINTERFACETABLE.DATABASETABLE_ID = drNewTable["DATABASETABLE_ID"].TryParseToInt();
                            _RTINTERFACETABLE.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                            //_RTINTERFACETABLE.STAFF_ID = PassportInfo.ID;
                            //_RTINTERFACETABLE.STAFF_NAME = PassportInfo.Name;
                            _RTINTERFACETABLE.OPERATE_DATE = DateTime.Now;
                            _RTINTERFACETABLE.RTINTERFACETABLE_DESC = createFileParam.InterfaceDesc;
                            _RTINTERFACETABLE.Insert();
                        }
                    }
                }
                //插入接口入参
                foreach (DataRow _DataRow in dtInterfaceModel.Select("ShowParams = 1",
                    "ColumnParamsIndex,ModelDataType,INTERFACEMODEL_INDEX,INTERFACEMODEL_ID"))
                {
                    if (_DataRow["DATE_FIELD"].ToString() == "1" && _DataRow["SEARCH_FIELD"].ToString() != "")
                    {
                        int FieldCount = 0;
                        //如果是日期字段，且有多查询条件，则将对应查询条件字段添加到入参中
                        foreach (string DateSearchField in _DataRow["SEARCH_FIELD"].ToString().Split(','))
                        {
                            Business.INTERFACEPARAMS _INTERFACEPARAMS = new Business.INTERFACEPARAMS(transaction);
                            _INTERFACEPARAMS.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                            _INTERFACEPARAMS.INTERFACEPARAMS_FORMAT = 0;
                            _INTERFACEPARAMS.INTERFACEPARAMS_NAME = DateSearchField;
                            _INTERFACEPARAMS.INTERFACEPARAMS_COMMENT = _DataRow["INTERFACEMODEL_COMMENT"].ToString() +
                                (FieldCount == 0 ? "（开始时间）" : "（结束时间）");
                            _INTERFACEPARAMS.DATE_FIELD = 1;
                            _INTERFACEPARAMS.Insert();
                            FieldCount++;
                        }
                    }
                    else
                    {
                        Business.INTERFACEPARAMS _INTERFACEPARAMS = new Business.INTERFACEPARAMS(transaction);
                        _INTERFACEPARAMS.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                        _INTERFACEPARAMS.INTERFACEPARAMS_FORMAT = 0;
                        _INTERFACEPARAMS.INTERFACEPARAMS_NAME = _DataRow["INTERFACEMODEL_NAME"].ToString();
                        _INTERFACEPARAMS.INTERFACEPARAMS_COMMENT = _DataRow["INTERFACEMODEL_COMMENT"].ToString();
                        _INTERFACEPARAMS.DATE_FIELD = _DataRow["DATE_FIELD"].TryParseToShort();
                        _INTERFACEPARAMS.ENUM_FIELD = _DataRow["ENUM_FIELD"].ToString();
                        _INTERFACEPARAMS.Insert();
                    }
                }

                #region 插入“查询页码数”、“每页显示行数”、“排序内容”字段
                Business.INTERFACEPARAMS PageIndexParams = new Business.INTERFACEPARAMS(transaction);
                PageIndexParams.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                PageIndexParams.INTERFACEPARAMS_FORMAT = 1;
                PageIndexParams.INTERFACEPARAMS_NAME = "PageIndex";
                PageIndexParams.INTERFACEPARAMS_COMMENT = "查询页码数";
                PageIndexParams.Insert();

                Business.INTERFACEPARAMS PageSizeParams = new Business.INTERFACEPARAMS(transaction);
                PageSizeParams.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                PageSizeParams.INTERFACEPARAMS_FORMAT = 1;
                PageSizeParams.INTERFACEPARAMS_NAME = "PageSize";
                PageSizeParams.INTERFACEPARAMS_COMMENT = "每页显示行数";
                PageSizeParams.Insert();

                Business.INTERFACEPARAMS SortStrParams = new Business.INTERFACEPARAMS(transaction);
                SortStrParams.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                SortStrParams.INTERFACEPARAMS_FORMAT = 0;
                SortStrParams.INTERFACEPARAMS_NAME = "SortStr";
                SortStrParams.INTERFACEPARAMS_COMMENT = "排序内容";
                SortStrParams.Insert();
                #endregion

                //插入接口返参
                Business.INTERFACERESPONSE _INTERFACERESPONSE = new Business.INTERFACERESPONSE(transaction);
                _INTERFACERESPONSE.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                _INTERFACERESPONSE.INTERFACEMODEL_ID = RouteCount == 0 ?
                    INTERFACEMODELCombine.INTERFACEMODEL_ID : INTERFACEMODELList.INTERFACEMODEL_ID;
                _INTERFACERESPONSE.INTERFACERESPONSE_FORMAT = 5;
                _INTERFACERESPONSE.INTERFACERESPONSE_NAME = Route.Split('/')[2].Substring(3);
                _INTERFACERESPONSE.INTERFACERESPONSE_COMMENT = _INTERFACE.INTERFACE_NAME;
                _INTERFACERESPONSE.Insert();

                //添加接口关联的SQL语句
                if (!string.IsNullOrWhiteSpace(createFileParam.txtSearchParams))
                {
                    Business.RTINTERFACESQL _RTINTERFACESQL = new Business.RTINTERFACESQL(transaction);
                    _RTINTERFACESQL.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                    _RTINTERFACESQL.SQLSTRING_TYPE = 1; //查询条件
                    _RTINTERFACESQL.SQLSTRING_CONTENT = createFileParam.txtSearchParams;
                    //_RTINTERFACESQL.STAFF_ID = PassportInfo.ID;
                    //_RTINTERFACESQL.STAFF_NAME = PassportInfo.Name;
                    _RTINTERFACESQL.OPERATE_DATE = DateTime.Now;
                    _RTINTERFACESQL.Insert();
                }
                if (!string.IsNullOrWhiteSpace(createFileParam.txtSQLString))
                {
                    Business.RTINTERFACESQL _RTINTERFACESQL = new Business.RTINTERFACESQL(transaction);
                    _RTINTERFACESQL.INTERFACE_ID = _INTERFACE.INTERFACE_ID;
                    _RTINTERFACESQL.SQLSTRING_TYPE = 2; //SQL执行语句
                    _RTINTERFACESQL.SQLSTRING_CONTENT = createFileParam.txtSQLString;
                    //_RTINTERFACESQL.STAFF_ID = PassportInfo.ID;
                    //_RTINTERFACESQL.STAFF_NAME = PassportInfo.Name;
                    _RTINTERFACESQL.OPERATE_DATE = DateTime.Now;
                    _RTINTERFACESQL.Insert();
                }
                RouteCount++;
            }
            #endregion

            return true;
        }

        #region 生成接口代码文件方法
        /// <summary>
        /// 生成接口代码文件方法
        /// </summary>
        /// <param name="InterfaceController">接口文件目录</param>
        /// <param name="CombineModel">接口文件命名</param>
        /// <param name="str_Controller_cs">主接口代码</param>
        /// <param name="str_Helper_cs">接口方法代码</param>
        /// <param name="str_Model_cs">接口类代码</param>
        /// <param name="RebuildslnLogName">重新编译解决方案的日志文件名称</param>
        public static void CreateFile(string InterfaceController, string CombineModel,
            string str_Controller_cs, string str_Helper_cs, string str_Model_cs, string RebuildslnLogName)
        {
            //生成接口代码文件目录
            string _ControllerFilePath = Config.AppSettings.ControllerPath + "\\AutoTest";
            if (!Directory.Exists(_ControllerFilePath))
            {
                Directory.CreateDirectory(_ControllerFilePath);
            }
            //如果有新的接口生成，则生成接口文件
            if (str_Controller_cs != "")
            {
                CommonHelper.SaveFile(_ControllerFilePath + "\\" + CombineModel + "Controller.cs", str_Controller_cs);
            }

            //生成接口相关方法代码文件目录
            string _HelperFilePath = Config.AppSettings.HelperPath + "\\AutoTest";
            if (!Directory.Exists(_HelperFilePath))
            {
                Directory.CreateDirectory(_HelperFilePath);
            }
            //如果有新的接口相关方法生成，则生成接口相关方法文件
            if (str_Helper_cs != "")
            {
                CommonHelper.SaveFile(_HelperFilePath + "\\" + CombineModel + "Helper.cs", str_Helper_cs);
            }

            //生成接口相关对象代码文件目录
            string _ModelFilePath = Config.AppSettings.ModelPath + "\\AutoTest";
            if (!Directory.Exists(_ModelFilePath))
            {
                Directory.CreateDirectory(_ModelFilePath);
            }
            //如果有新的数据对象生成，则生成数据对象文件
            if (str_Model_cs != "")
            {
                CommonHelper.SaveFile(_ModelFilePath + "\\" + CombineModel + "Model.cs", str_Model_cs);
            }

            //异步执行重新编译解决方案
            CommonHelper.Rebuildsln(Config.AppSettings.msbuildPath, Config.AppSettings.slnPath, RebuildslnLogName);
        }
        #endregion

        #endregion

        #region 方法 -> 监听接口代码生成结果
        /// <summary>
        /// 监听接口代码生成结果
        /// </summary>
        /// <param name="RebuildslnLogName">重新编译解决方案的日志文件名称</param>
        /// <param name="resMsg">编辑结果异常日志</param>
        /// <returns></returns>
        public static bool ListenRebuildRes(string RebuildslnLogName, ref string resMsg)
        {
            if (File.Exists(Config.AppSettings.CodeBuilderLogAbsUrl + "\\" + RebuildslnLogName + ".txt"))
            {
                string ErrorLogPath = Config.AppSettings.CodeBuilderLogAbsUrl + "\\" + RebuildslnLogName + "Error.txt";
                if (File.Exists(ErrorLogPath))
                {
                    resMsg = File.ReadAllText(ErrorLogPath, Encoding.UTF8);
                }

                return true;
            }

            return false;
        }
        #endregion

        #region 方法 -> 发布前端代码文件
        /// <summary>
        /// 发布前端代码文件
        /// </summary>
        /// <param name="transaction"></param>
        /// <param name="createWebFileParam"></param>
        public static void CreateWebFile(Transaction transaction, Model.CreateWebFileParam createWebFileParam)
        {
            string resMsg = "";

            string pushlishPath = string.IsNullOrWhiteSpace(createWebFileParam.SavePath) ?
                Config.AppSettings.SolutionPath : createWebFileParam.SavePath + "\\src\\pages\\";
            string routePath = string.IsNullOrWhiteSpace(createWebFileParam.SavePath) ?
                Config.AppSettings.RoutePath : createWebFileParam.SavePath + "\\config";
            //生成前端代码文件目录
            string FileName = createWebFileParam.FileName;
            if (FileName.Split('/').Length > 0)
            {
                FileName = FileName.Split('/')[FileName.Split('/').Length - 1];
            }
            string _FilePath = pushlishPath + Config.AppSettings.IndexPageDir + "\\" + FileName;
            if (!Directory.Exists(_FilePath))
            {
                Directory.CreateDirectory(_FilePath);
            }
            //如果有新的页面生成，则生成页面文件
            if (!string.IsNullOrWhiteSpace(createWebFileParam.txtIndex_tsx))
            {
                CommonHelper.SaveFile(_FilePath, "Index.tsx", createWebFileParam.txtIndex_tsx, ref resMsg, createWebFileParam.SaveServer);
                //存储页面和接口的关联关系
                Business.RTPAGEINTERFACE _RTPAGEINTERFACE = new Business.RTPAGEINTERFACE(transaction);
                _RTPAGEINTERFACE.AddSearchParameter("PAGE_URL", _FilePath + "\\Index.tsx");
                _RTPAGEINTERFACE.AddSearchParameter("INTERFACE_ID", createWebFileParam.InterfaceId);
                if (!_RTPAGEINTERFACE.Search())
                {
                    _RTPAGEINTERFACE.ResetProperty();
                    _RTPAGEINTERFACE.PAGE_NAME = createWebFileParam.TableTitle;
                    _RTPAGEINTERFACE.PAGE_URL = _FilePath + "\\Index.tsx";
                    _RTPAGEINTERFACE.PAGE_ROUTE = "/" + Config.AppSettings.IndexPageDir.ToLower() + "/" + FileName;
                    _RTPAGEINTERFACE.INTERFACE_ID = createWebFileParam.InterfaceId.TryParseToInt();
                    //_RTPAGEINTERFACE.STAFF_ID = PassportInfo.ID;
                    //_RTPAGEINTERFACE.STAFF_NAME = PassportInfo.Name;
                    _RTPAGEINTERFACE.OPERATE_DATE = DateTime.Now;
                    _RTPAGEINTERFACE.Insert();
                }
            }
            //如果有新的接口服务生成，则生成接口服务文件
            if (!string.IsNullOrWhiteSpace(createWebFileParam.txtdata_d_ts))
            {
                CommonHelper.SaveFile(_FilePath, "data.d.ts", createWebFileParam.txtdata_d_ts,
                    ref resMsg, createWebFileParam.SaveServer);
            }
            //如果有新的数据对象生成，则生成数据对象文件
            if (!string.IsNullOrWhiteSpace(createWebFileParam.txtservice_ts))
            {
                CommonHelper.SaveFile(_FilePath, "service.ts", createWebFileParam.txtservice_ts,
                    ref resMsg, createWebFileParam.SaveServer);
            }
            //生成前端路由代码文件目录
            if (!string.IsNullOrWhiteSpace(routePath))
            {
                if (!Directory.Exists(routePath))
                {
                    Directory.CreateDirectory(routePath);
                }
                if (!string.IsNullOrWhiteSpace(createWebFileParam.txtroutes_ts))
                {
                    CommonHelper.SaveFile(routePath, "routes.ts", createWebFileParam.txtroutes_ts,
                        ref resMsg, createWebFileParam.SaveServer);
                }
            }
        }
        #endregion

        #region 方法 -> 发布前端模块
        /// <summary>
        /// 发布前端模块
        /// </summary>
        /// <param name="UserId">系统用户内码</param>
        /// <param name="UserPassport">用户登录账号</param>
        /// <param name="DirName">原文件所在目录</param>
        /// <param name="ModuleName">模块名称</param>
        /// <param name="ModuleGuid">模块唯一标识</param>
        /// <param name="SystemMenuId">系统菜单内码</param>
        /// <param name="SystemRoleId">系统角色内码</param>
        /// <param name="SaveServer">文件发布地址</param>
        /// <param name="SolutionPath">原文件夹目录</param>
        public static void PublishWebFile(string UserId, string UserPassport, string DirName, string ModuleName,
            string ModuleGuid, int SystemMenuId, int? SystemRoleId, string SaveServer, string SolutionPath)
        {
            string resMsg = "";
            string destDir = "a" + DateTime.Now.ToString("yyMMddHHmmssff");
            try
            {
                UserId = UserId.ToDecrypt();
            }
            catch { }
            if (string.IsNullOrWhiteSpace(ModuleGuid))
            {
                ModuleGuid = Guid.NewGuid().ToString();
            }

            StringBuilder sbRoute = new StringBuilder();
            string SystemModuleURL = "/" + UserPassport.ToLower() + "/" + destDir;
            WebPageCodeHelper.GetRoute(ref sbRoute, UserId.TryParseToInt(), UserPassport, ModuleName,
                SystemModuleURL, ModuleGuid, SystemMenuId, SystemRoleId, true, 1000);
            //存储框架路由文件路径
            CommonHelper.SaveFile(Config.AppSettings.RoutePath, "routes.ts", sbRoute.ToString(), ref resMsg, SaveServer);
            //迁移模块文件
            if (string.IsNullOrWhiteSpace(SolutionPath))
            {
                SolutionPath = Config.AppSettings.SolutionPath.Replace("\\\\", "\\");
            }
            string publishPath = Config.AppSettings.SolutionPath.Replace("\\\\", "\\");
            //目标路径文件夹不存在，则先新建文件夹
            if (!Directory.Exists(publishPath + UserPassport.ToLower()))
            {
                Directory.CreateDirectory(publishPath + UserPassport.ToLower());
            }
            CommonHelper.CopyFilesAndDirs(SolutionPath + Config.AppSettings.IndexPageDir + "\\" + DirName + "\\",
                publishPath + UserPassport.ToLower() + "\\" + destDir + "\\", true);
        }
        #endregion

        #region 方法 -> 保存图形代码文件
        /// <summary>
        /// 保存图形代码文件
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="chartSession">图形配置session</param>
        /// <param name="chartTitle">图形标题</param>
        /// <param name="txtChart_tsx">图形代码</param>
        /// <param name="fileDir">文件路径</param>
        /// <param name="fileName">文件名称</param>
        /// <param name="passportInfoID">操作人内码</param>
        /// <param name="passportInfoName">操作人名称</param>
        /// <param name="postUrl">传输地址</param>
        public static void SaveChartFile(Transaction transaction, string chartSession, string chartTitle, string txtChart_tsx,
            string fileDir, string fileName, int? passportInfoID = null, string passportInfoName = "", string postUrl = "")
        {
            string resMsg = "";

            Model.ChartSettingModel _ChartSettingModel = JsonConvert.DeserializeObject<Model.ChartSettingModel>(chartSession);
            if (_ChartSettingModel != null && !string.IsNullOrWhiteSpace(_ChartSettingModel.InterfaceId))
            {
                Business.RTPAGEINTERFACE _RTPAGEINTERFACE = new Business.RTPAGEINTERFACE(transaction);
                _RTPAGEINTERFACE.AddSearchParameter("PAGE_URL", fileDir + "\\" + fileName);
                _RTPAGEINTERFACE.AddSearchParameter("INTERFACE_ID", _ChartSettingModel.InterfaceId);
                if (!_RTPAGEINTERFACE.Search())
                {
                    _RTPAGEINTERFACE.ResetProperty();
                    _RTPAGEINTERFACE.PAGE_NAME = chartTitle;
                    _RTPAGEINTERFACE.PAGE_URL = fileDir + "\\" + fileName;
                    _RTPAGEINTERFACE.INTERFACE_ID = _ChartSettingModel.InterfaceId.TryParseToInt();
                    _RTPAGEINTERFACE.STAFF_ID = passportInfoID;
                    _RTPAGEINTERFACE.STAFF_NAME = passportInfoName;
                    _RTPAGEINTERFACE.OPERATE_DATE = DateTime.Now;
                    _RTPAGEINTERFACE.Insert();
                }
            }
            if (string.IsNullOrWhiteSpace(postUrl))
            {
                if (!Directory.Exists(fileDir))
                {
                    Directory.CreateDirectory(fileDir);
                }
                CommonHelper.SaveFile(fileDir + "\\" + fileName, txtChart_tsx);
            }
            else
            {
                CommonHelper.SaveFile(fileDir, "SChart.tsx", txtChart_tsx, ref resMsg, postUrl);
            }
        }
        #endregion
    }
}