using System;
using System.Collections.Generic;
using System.Data;
using System.Web;
using System.Web.UI.WebControls;
using SuperMap.RealEstate.Identity;
using SuperMap.RealEstate.ServiceModel;
using SuperMap.RealEstate.CoreFrameWork;
using SuperMap.RealEstate.Web.UI.WebControls;
using SuperMap.RealEstate.FrameWork.Business;
using SuperMap.RealEstate.CoreFrameWork.Dictionary.Business;

namespace HZQR.Common.Common
{
    /// <summary>
    /// 业务相关方法
    /// </summary>
    public class BusinessHelper
    {
        #region 记录数据表变更日志
        /// <summary>
        /// 记录数据表变更日志
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="TableID">变更表主键值</param>
        /// <param name="TableName">变更表名称</param>
        /// <param name="OwnerName">变更用户名称</param>
        /// <param name="_PassportInfo">综管平台用户对象</param>
        /// <param name="OperateDesc">操作说明</param>
        public static void RecordDataChangeLog(Transaction _Transaction, int TableID,
            string TableName, string OwnerName, PassportInfo _PassportInfo, string OperateDesc)
        {
            string SQLString = string.Format(@"INSERT INTO PLATFORM_FRAMEWORK.T_DATACHANGE (
                    DATACHANGE_ID,TABLE_ID,TABLE_NAME,OWNER_NAME,
                    STAFF_ID,STAFF_NAME,OPERATE_DATE,OPERATE_DESC) 
                VALUES (
                    PLATFORM_FRAMEWORK.SEQ_DATACHANGE.NEXTVAL,
                    {0},'{1}','{2}',{3},'{4}',SYSDATE,'{5}')",
                TableID, TableName, OwnerName, _PassportInfo.ID, _PassportInfo.Name, OperateDesc);

            new User(_Transaction).ExecuteNonQuery(SQLString, null);
        }
        #endregion

        #region 记录业务办理日志
        /// <summary>
        /// 记录业务办理日志
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="BusinessLogType">业务类型</param>
        /// <param name="BusinessID">业务ID</param>
        /// <param name="TableName">数据表名称</param>
        /// <param name="OwnerName">数据表用户</param>
        /// <param name="BusinessLogContent">日志内容</param>
        /// <param name="PassportInfoID">操作人内码</param>
        /// <param name="PassportInfoName">操作人名称</param>
        public static void RecordBusinessLog(Transaction _Transaction, int BusinessLogType, int BusinessID,
            string TableName, string OwnerName, string BusinessLogContent, int? PassportInfoID, string PassportInfoName)
        {
            if (BusinessLogType == 209000)
            {
                return;
            }
            RecordBusinessLog(_Transaction, BusinessLogType, BusinessID, TableName, OwnerName, BusinessLogContent, 1, 1);
        }

        /// <summary>
        /// 记录业务办理日志
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="BusinessLogType">业务类型</param>
        /// <param name="BusinessID">业务ID</param>
        /// <param name="TableName">数据表名称</param>
        /// <param name="OwnerName">数据表用户</param>
        /// <param name="BusinessLogContent">日志内容</param>
        /// <param name="Data_Consistency">数据一致性（0：不一致；1：一致）</param>
        /// <param name="Check_State">反查标识（0：后续需要干预处理的日志，1：纯记录，作为定时删除日志的标记）</param>
        public static void RecordBusinessLog(Transaction _Transaction, int BusinessLogType, int BusinessID,
            string TableName, string OwnerName, string BusinessLogContent, int Data_Consistency, int Check_State)
        {
            if (BusinessLogType == 209000)
            {
                return;
            }
            RecordBusinessLog(_Transaction, BusinessLogType, BusinessID, TableName, OwnerName,
                BusinessLogContent, Data_Consistency, Check_State, "");
        }

        /// <summary>
        /// 记录业务办理日志
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="BusinessLogType">业务类型
        /// 进销存业务：
        /// 201000：进销存入库
        /// 202000：进销存调拨
        /// 203000：进销存退货
        /// 204000：进销存领用
        /// 205000：进销存销售
        /// 206000：进销存盘点结存
        /// 206001：进销存盘点损溢
        /// 207000：补充本期无库存有销售的新商品
        /// 209000：用户查询信息
        /// 总仓统配业务：
        /// 501000：总仓入库
        /// 502000：总仓调拨
        /// 503000：总仓退货
        /// 504000：总仓领用
        /// 505000：总仓损溢
        /// 506000：总仓盘点结存
        /// 506001：总仓盘点损溢
        /// 507000：总仓异常实时库存
        /// 508000：总仓配送
        /// 509000：总仓异常退货
        /// </param>
        /// <param name="BusinessID">业务表主键值</param>
        /// <param name="TableName">变更表名称</param>
        /// <param name="OwnerName">变更用户名称</param>
        /// <param name="BusinessLogContent">日志内容</param>
        /// <param name="Data_Consistency">数据一致性（0：不一致；1：一致）</param>
        /// <param name="Check_State">反查标识（0：后续需要干预处理的日志，1：纯记录，作为定时删除日志的标记）</param>
        /// <param name="UniqueCode">日结账单唯一标识，格式：服务区编码|门店编码|结账时间|机器编码|销售金额</param>
        public static void RecordBusinessLog(Transaction _Transaction, int BusinessLogType, int BusinessID, string TableName,
            string OwnerName, string BusinessLogContent, int Data_Consistency, int Check_State, string UniqueCode)
        {
            string SQLString = "";
            try
            {
                SQLString = string.Format(@"INSERT INTO PLATFORM_FRAMEWORK.T_BUSINESSLOG (
                        BUSINESSLOG_ID,BUSINESSLOG_TYPE,BUSINESS_ID,TABLE_NAME,OWNER_NAME,
                        BUSINESSLOG_CONTENT,OPERATE_DATE,DATA_CONSISTENCY,CHECK_STATE,UNIQUECODE) 
                    VALUES (
                        PLATFORM_FRAMEWORK.SEQ_BUSINESSLOG.NEXTVAL,
                        {0},{1},'{2}','{3}','{4}',{5},{6},{7},'{8}')",
                    BusinessLogType, BusinessID, TableName, OwnerName, BusinessLogContent,
                    DateTime.Now.ToString("yyyyMMddHHmmss"), Data_Consistency, Check_State, UniqueCode);
                new User(_Transaction).ExecuteNonQuery(SQLString, null);
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog(ex, "记录业务办理日志失败！执行语句：" + SQLString,
                    DateTime.Now.ToString("yyyyMMdd") + "_BusinessLog");
            }
        }

        /// <summary>
        /// 记录业务办理日志
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="businessLogModel">业务日志数据对象</param>
        public static void RecordBusinessLog(Transaction _Transaction, Models.BusinessLogModel businessLogModel)
        {
            string SQLString = string.Format(@"INSERT INTO PLATFORM_FRAMEWORK.T_BUSINESSLOG (
                    BUSINESSLOG_ID,BUSINESSLOG_TYPE,BUSINESS_ID,TABLE_NAME,OWNER_NAME,
                    BUSINESSLOG_CONTENT,OPERATE_DATE,DATA_CONSISTENCY,CHECK_STATE,UNIQUECODE,
                    SERVERPARTCODE,SHOPCODE,MACHINECODE,BUSINESSTYPE,
                    SALE_AMOUNT,CASHPAY_AMOUNT,DAILY_AMOUNT,CHANNEL_AMOUNT,
                    ENDACCOUNT_ID,STATISTICS_DATE)
                VALUES (
                    PLATFORM_FRAMEWORK.SEQ_BUSINESSLOG.NEXTVAL,
                    {0},{1},'{2}','{3}','{4}',{5},{6},{7},'{8}',
                    '{9}','{10}','{11}',{12},{13},{14},{15},{16},{17},{18})",
                businessLogModel.BUSINESSLOG_TYPE == null ? "NULL" : businessLogModel.BUSINESSLOG_TYPE.ToString(),
                businessLogModel.BUSINESS_ID == null ? "NULL" : businessLogModel.BUSINESS_ID.ToString(),
                businessLogModel.TABLE_NAME, businessLogModel.OWNER_NAME,
                businessLogModel.BUSINESSLOG_CONTENT, DateTime.Now.ToString("yyyyMMddHHmmss"),
                businessLogModel.DATA_CONSISTENCY == null ? "NULL" : businessLogModel.DATA_CONSISTENCY.ToString(),
                businessLogModel.CHECK_STATE == null ? "NULL" : businessLogModel.CHECK_STATE.ToString(),
                businessLogModel.UNIQUECODE, businessLogModel.SERVERPARTCODE, businessLogModel.SHOPCODE, businessLogModel.MACHINECODE,
                businessLogModel.BUSINESSTYPE == null ? "NULL" : businessLogModel.BUSINESSTYPE.ToString(),
                businessLogModel.SALE_AMOUNT == null ? "NULL" : businessLogModel.SALE_AMOUNT.ToString(),
                businessLogModel.CASHPAY_AMOUNT == null ? "NULL" : businessLogModel.CASHPAY_AMOUNT.ToString(),
                businessLogModel.DAILY_AMOUNT == null ? "NULL" : businessLogModel.DAILY_AMOUNT.ToString(),
                businessLogModel.CHANNEL_AMOUNT == null ? "NULL" : businessLogModel.CHANNEL_AMOUNT.ToString(),
                businessLogModel.ENDACCOUNT_ID == null ? "NULL" : businessLogModel.ENDACCOUNT_ID.ToString(),
                businessLogModel.STATISTICS_DATE == null ? "NULL" : businessLogModel.STATISTICS_DATE.ToString());

            new User(_Transaction).ExecuteNonQuery(SQLString, null);
        }
        #endregion

        #region 更新日志表反查标识
        /// <summary>
        /// 更新日志表反查标识
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="BusinessLogType">日志类型</param>
        /// <param name="BusinessID">业务ID</param>
        /// <param name="TableName">业务表名称</param>
        /// <param name="OwnerName">业务表用户</param>
        /// <param name="BusinessLogContent">日志内容</param>
        /// <param name="Data_Consistency">数据一致性</param>
        /// <param name="Check_State">反查标识（0：后续需要干预处理的日志，1：纯记录，作为定时删除日志的标记）</param>
        public static void UpdateBusinessLogCheckState(Transaction _Transaction, int BusinessLogType, int BusinessID,
            string TableName, string OwnerName, string BusinessLogContent, int? Data_Consistency, int? Check_State)
        {
            string SQLString = "", UpdateSQL = "";
            try
            {
                if (BusinessLogContent != null)
                {
                    UpdateSQL += (UpdateSQL == "" ? "" : ",") + "BUSINESSLOG_CONTENT = '" + BusinessLogContent + "'";
                }
                if (Data_Consistency != null)
                {
                    UpdateSQL += (UpdateSQL == "" ? "" : ",") + "DATA_CONSISTENCY = " + Data_Consistency;
                }
                if (Check_State != null)
                {
                    UpdateSQL += (UpdateSQL == "" ? "" : ",") + "CHECK_STATE = " + Check_State;
                }
                SQLString = string.Format(@"UPDATE PLATFORM_FRAMEWORK.T_BUSINESSLOG SET {0} 
                    WHERE BUSINESSLOG_TYPE = {1} AND BUSINESS_ID = {2} AND 
                        TABLE_NAME = '{3}' AND OWNER_NAME = '{4}'",
                    UpdateSQL, BusinessLogType, BusinessID, TableName, OwnerName);
                new User(_Transaction).ExecuteNonQuery(SQLString, null);
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog(ex, "记录业务办理日志失败！执行语句：" + SQLString,
                    DateTime.Now.ToString("yyyyMMdd") + "_BusinessLog");
            }
        }

        /// <summary>
        /// 更新日志表反查标识
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="BusinessLogID">日志内码</param>
        /// <param name="BusinessLogContent">日志内容</param>
        /// <param name="Data_Consistency">数据一致性</param>
        /// <param name="Check_State">反查标识（0：后续需要干预处理的日志，1：纯记录，作为定时删除日志的标记）</param>
        public static void UpdateBusinessLogCheckState(Transaction _Transaction, int BusinessLogID,
            string BusinessLogContent, int? Data_Consistency, int? Check_State)
        {
            UpdateBusinessLogCheckState(_Transaction, BusinessLogID, BusinessLogContent, Data_Consistency, Check_State, null);
        }

        /// <summary>
        /// 更新日志表反查标识
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="BusinessLogID">日志内码</param>
        /// <param name="BusinessLogContent">日志内容</param>
        /// <param name="Data_Consistency">数据一致性</param>
        /// <param name="Check_State">反查标识（0：后续需要干预处理的日志，1：纯记录，作为定时删除日志的标记）</param>
        /// <param name="Daily_Amount">自然日移动支付金额</param>
        /// <param name="Endaccount_Id">日结账单内码</param>
        public static void UpdateBusinessLogCheckState(Transaction _Transaction, int BusinessLogID,
            string BusinessLogContent, int? Data_Consistency, int? Check_State,
            decimal? Daily_Amount, int? Endaccount_Id = null)
        {
            string SQLString = "", UpdateSQL = "";
            try
            {
                if (BusinessLogContent != null)
                {
                    UpdateSQL += (UpdateSQL == "" ? "" : ",") + "BUSINESSLOG_CONTENT = '" + BusinessLogContent + "'";
                }
                if (Data_Consistency != null)
                {
                    UpdateSQL += (UpdateSQL == "" ? "" : ",") + "DATA_CONSISTENCY = " + Data_Consistency;
                }
                if (Check_State != null)
                {
                    UpdateSQL += (UpdateSQL == "" ? "" : ",") + "CHECK_STATE = " + Check_State;
                }
                if (Daily_Amount != null)
                {
                    UpdateSQL += (UpdateSQL == "" ? "" : ",") + "DAILY_AMOUNT = " + Daily_Amount;
                }
                if (Endaccount_Id != null)
                {
                    UpdateSQL += (UpdateSQL == "" ? "" : ",") + "ENDACCOUNT_ID = " + Endaccount_Id;
                }
                SQLString = string.Format(@"UPDATE PLATFORM_FRAMEWORK.T_BUSINESSLOG 
                    SET {0} WHERE BUSINESSLOG_ID = {1}", UpdateSQL, BusinessLogID);
                new User(_Transaction).ExecuteNonQuery(SQLString, null);
            }
            catch (Exception ex)
            {
                LogUtil.WriteLog(ex, "记录业务办理日志失败！执行语句：" + SQLString,
                    DateTime.Now.ToString("yyyyMMdd") + "_BusinessLog");
            }
        }
        #endregion

        #region 获取用户session
        /// <summary>
        /// 获取用户session
        /// </summary>
        public static void GetPassportInfoSession(Transaction _Transaction, HttpContext context, string UserID)
        {
            if (string.IsNullOrWhiteSpace(UserID)) return;

            DataTable dtUser = new User(_Transaction).ExecuteDataTable(
                "SELECT * FROM PLATFORM_FRAMEWORK.T_USER WHERE USER_ID = " + UserID);
            if (dtUser.Rows.Count > 0)
            {
                context.Session[ConstStringHelper.RequestQueryString_PassportUserName] = dtUser.Rows[0]["USER_PASSPORT"];
                context.Session["User_ID"] = dtUser.Rows[0]["USER_ID"];
                context.Session["User_Name"] = dtUser.Rows[0]["USER_NAME"];
                context.Session["User_Authenticated"] = true;
                context.Session[ConstStringHelper.RequestQueryString_PassportGuid] = Guid.NewGuid().ToString();
                context.Session["User_EnabledCityAuthority"] = "USER_ENABLEDCITYAUTHORITY";
                context.Session["User_CityAuthority"] = dtUser.Rows[0]["USER_CITYAUTHORITY"];
                context.Session["User_EnabledLicense"] = dtUser.Rows[0]["USER_ENABLEDLICENSE"];
                context.Session["User_License"] = dtUser.Rows[0]["USER_LICENSE"];
                context.Session["User_UserMobilephone"] = dtUser.Rows[0]["USER_MOBILEPHONE"];
                context.Session["User_ProvinceCode"] = dtUser.Rows[0]["USER_PROVINCE"];
                context.Session["User_ProvinceUnit"] = dtUser.Rows[0]["PROVINCE_UNIT"];
            }
        }
        #endregion

        #region 根据模块id获取系统模块数据表对象
        /// <summary>
        /// 根据模块id获取系统模块数据表对象
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="ModuleId">模块id</param>
        /// <returns></returns>
        public static Module GetModuleByModuleId(Transaction transaction, string ModuleId)
        {
            Module module = new Module(transaction);

            if (!string.IsNullOrWhiteSpace(ModuleId))
            {
                module.Module_ID_Encrypt = ModuleId.ToEncrypt();
                module.Select();
            }

            return module;
        }
        #endregion

        #region 获取系统模块数据表对象
        /// <summary>
        /// 获取系统模块数据表对象
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="ModuleGuid">模块guid</param>
        /// <returns></returns>
        public static Module GetModuleByModuleGuid(Transaction transaction, string ModuleGuid)
        {
            Module module = new Module(transaction);

            if (!string.IsNullOrWhiteSpace(ModuleGuid))
            {
                module.AddSearchParameter("MODULE_GUID", ModuleGuid);
                module.Search();
            }

            return module;
        }
        #endregion

        #region 方法 -> 获取枚举及其子集
        /// <summary>
        /// 获取枚举及其子集
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="FieldExplain_Field">枚举字段内码</param>
        /// <param name="RetString"></param>
        /// <param name="Pid">当前枚举的内码，顶层为-1</param>
        /// <param name="obscureName">其他检索条件,枚举名称</param>
        /// <param name="_SearchDataTable">枚举数据源</param>
        /// <returns></returns>
        public static void GetSubFieldEnum(Transaction transaction, string FieldExplain_Field, ref string RetString,
            string Pid, string obscureName, DataTable _SearchDataTable = null)
        {

            //由于数据量商品类别不可能太多，所以一次性全部取出
            if (_SearchDataTable == null)
            {
                _SearchDataTable = GetFieldEnumDataSource(transaction, FieldExplain_Field);
            }
            string SearchString = "FIELDENUM_PID = '" + Pid + "'" + (obscureName == "" ? "" : " AND FIELDENUM_NAME LIKE '" + obscureName + "'");

            DataRow[] _DataRowList = _SearchDataTable.Select(SearchString);
            if (_DataRowList.Length == 0)
            {
                return;
            }
            else
            {
                foreach (DataRow _CurrRow in _DataRowList)
                {
                    RetString += (RetString == "" ? "" : ",") + _CurrRow["FIELDENUM_VALUE"].ToString();
                    GetSubFieldEnum(transaction, FieldExplain_Field, ref RetString,
                        _CurrRow["FIELDENUM_ID"].ToString(), obscureName, _SearchDataTable);
                }
            }
        }

        private static DataTable GetFieldEnumDataSource(Transaction transaction, string FieldExplain_Field)
        {
            string StrSql = "SELECT * FROM V_FIELDENUM WHERE FIELDEXPLAIN_FIELD = '" + FieldExplain_Field + "'";
            DataTable _DataTable = new FieldEnum(transaction).ExecuteDataTable(StrSql);
            _DataTable.DefaultView.Sort = "FIELDENUM_PID,FIELDENUM_INDEX,FIELDENUM_VALUE";

            return _DataTable.DefaultView.ToTable();
        }

        #endregion

        #region 方法 -> 绑定枚举树
        /// <summary>
        /// 绑定枚举树
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="treeNodeCollection">树集合</param>
        /// <param name="FieldExplain_Field">字段名称</param>
        /// <param name="pid">父级枚举</param>
        /// <param name="dataStatus">枚举状态筛选条件</param>
        /// <param name="showType">显示模式：0【枚举值】，1【枚举内码】</param>
        /// <param name="dtEnum">枚举数据源</param>
        /// <param name="ShowTarget">点击节点是否跳转页面</param>
        /// <param name="NavigateUrl">页面跳转地址</param>
        public static void BindingEnumTreeView(Transaction transaction, TreeNodeCollection treeNodeCollection,
            string FieldExplain_Field, string pid, string dataStatus = "", int showType = 0, DataTable dtEnum = null,
            bool ShowTarget = false, string NavigateUrl = "javascript:void(0);")
        {
            BindingEnumTreeView(transaction, treeNodeCollection, FieldExplain_Field,
                pid, dataStatus, showType, dtEnum, ShowTarget, NavigateUrl, false);
        }

        /// <summary>
        /// 绑定枚举树
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="treeNodeCollection">树集合</param>
        /// <param name="FieldExplain_Field">字段名称</param>
        /// <param name="pid">父级枚举</param>
        /// <param name="dataStatus">枚举状态筛选条件</param>
        /// <param name="showType">显示模式：0【枚举值】，1【枚举内码】</param>
        /// <param name="dtEnum">枚举数据源</param>
        /// <param name="ShowTarget">点击节点是否跳转页面</param>
        /// <param name="NavigateUrl">页面跳转地址</param>
        /// <param name="ShowIndex">树节点是否显示索引</param>
        public static void BindingEnumTreeView(Transaction transaction, TreeNodeCollection treeNodeCollection,
            string FieldExplain_Field, string pid, string dataStatus, int showType, DataTable dtEnum,
            bool ShowTarget, string NavigateUrl, bool ShowIndex)
        {
            if (dtEnum == null)
            {
                string WhereSQL = "";
                if (!string.IsNullOrEmpty(dataStatus))
                {
                    WhereSQL = " AND FIELDENUM_STATUS IN (" + dataStatus + ")";
                }
                //获取枚举信息
                FieldExplain fieldExplain = DictionaryHelper.GetFieldExplain(FieldExplain_Field, transaction);
                dtEnum = new FieldEnum(transaction).FillDataTable("WHERE FIELDEXPLAIN_ID = " + fieldExplain.KeyID + WhereSQL);
            }

            foreach (DataRow drEnum in dtEnum.Select("FIELDENUM_PID = " + pid, "FIELDENUM_INDEX,FIELDENUM_VALUE"))
            {
                TreeNode treeNode = new TreeNode();
                treeNode.Text = (ShowIndex ? "【" + drEnum["FIELDENUM_INDEX"] + "】" : "") + drEnum["FIELDENUM_NAME"].ToString();
                treeNode.Value = showType == 0 ? drEnum["FIELDENUM_VALUE"].ToEncrypt() : drEnum["FIELDENUM_ID"].ToEncrypt();
                if (ShowTarget)
                {
                    if (string.IsNullOrWhiteSpace(NavigateUrl) || NavigateUrl == "javascript:void(0);")
                    {
                        treeNode.NavigateUrl = "javascript:void(0);";
                    }
                    else
                    {
                        treeNode.NavigateUrl = NavigateUrl + (NavigateUrl.Contains("?") ? "&" : "?") +
                            "FIELDENUMID=" + drEnum["FIELDENUM_ID"].ToEncrypt() + "&FIELDENUMVALUE=" + drEnum["FIELDENUM_VALUE"].ToEncrypt();
                    }
                }
                else
                {
                    treeNode.NavigateUrl = "javascript:void(0);";
                }

                if (dtEnum.Select("FIELDENUM_PID = " + drEnum["FIELDENUM_ID"]).Length > 0)
                {
                    BindingEnumTreeView(transaction, treeNode.ChildNodes, FieldExplain_Field, drEnum["FIELDENUM_ID"].ToString(),
                        dataStatus, showType, dtEnum, ShowTarget, NavigateUrl, ShowIndex);
                }

                treeNodeCollection.Add(treeNode);
            }
        }
        #endregion

        #region 方法 -> 绑定枚举字典下拉框
        /// <summary>
        /// 绑定枚举字典类别下拉框
        /// </summary>
        /// <param name="transaction"></param>
        /// <param name="items"></param>
        /// <param name="disabledValue"></param>
        public static void BindingFieldExplainDDL(Transaction transaction, List<ListItemEx> items, string disabledValue)
        {
            DataTable _DataTable = GetFieldExplainTypeDataSource(transaction, string.Empty, string.Empty);
            BindingFieldExplainDDL(transaction, _DataTable, "-1", items, disabledValue, 0, true);
        }

        /// <summary>
        /// 绑定枚举字典下拉框
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="dtFieldExplainType">数据字典类型数据源</param>
        /// <param name="pid">父级枚举字典</param>
        /// <param name="items">枚举字典下拉框</param>
        /// <param name="disabledValue">不可加载的数值</param>
        /// <param name="level">显示级别</param>
        /// <param name="disabled">字典类型是否可以选择</param>
        /// <param name="ShowFieldExplain">显示数据字典</param>
        /// <param name="dtFieldExplain">数据字典数据源</param>
        /// <param name="valueType">下拉框值类型：0【字典内码】，1【字典英文】</param>
        public static void BindingFieldExplainDDL(Transaction transaction, DataTable dtFieldExplainType, string pid,
            List<ListItemEx> items, string disabledValue, int level, bool disabled, bool ShowFieldExplain = false,
            DataTable dtFieldExplain = null, int valueType = 0)
        {
            BindingFieldExplainDDL(transaction, dtFieldExplainType, pid, items, disabledValue,
                level, disabled, ShowFieldExplain, dtFieldExplain, valueType, false);
        }

        /// <summary>
        /// 绑定枚举字典下拉框
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="dtFieldExplainType">数据字典类型数据源</param>
        /// <param name="pid">父级枚举字典</param>
        /// <param name="items">枚举字典下拉框</param>
        /// <param name="disabledValue">不可加载的数值</param>
        /// <param name="level">显示级别</param>
        /// <param name="disabled">字典类型是否可以选择</param>
        /// <param name="ShowFieldExplain">显示数据字典</param>
        /// <param name="dtFieldExplain">数据字典数据源</param>
        /// <param name="valueType">下拉框值类型：0【字典内码】，1【字典英文】</param>
        /// <param name="showDataTableEnum">是否显示数据库表枚举</param>
        public static void BindingFieldExplainDDL(Transaction transaction, DataTable dtFieldExplainType, string pid,
            List<ListItemEx> items, string disabledValue, int level, bool disabled, bool ShowFieldExplain,
            DataTable dtFieldExplain, int valueType, bool showDataTableEnum)
        {
            //获取枚举字段类型数据源
            if (dtFieldExplainType == null)
            {
                dtFieldExplainType = GetFieldExplainTypeDataSource(transaction, string.Empty, string.Empty);
            }
            //获取枚举字段数据源
            if (ShowFieldExplain && dtFieldExplain == null)
            {
                dtFieldExplain = new FieldExplain(transaction).FillDataTable("");
            }
            //加载数据库表枚举
            if (showDataTableEnum)
            {
                FieldExplain fieldExplain = DictionaryHelper.GetFieldExplain("DATATABLE_ENUM", transaction);

                ListItemEx listItemExType = new ListItemEx();
                listItemExType.Value = "0";
                listItemExType.Text = "常用数据库表枚举";
                listItemExType.Level = level;
                if (!disabled)
                {
                    listItemExType.Enabled = false;
                }
                items.Add(listItemExType);

                if (ShowFieldExplain)
                {
                    foreach (DataRow drFieldEnum in new FieldEnum(transaction).FillDataTable("WHERE FIELDEXPLAIN_ID = " +
                        fieldExplain.FieldExplain_ID).Select("", "FIELDENUM_INDEX,FIELDENUM_VALUE"))
                    {
                        ListItemEx ListItemField = new ListItemEx();
                        ListItemField.Value = valueType == 0 ? drFieldEnum["FIELDENUM_ID"].ToString() :
                            drFieldEnum["FIELDENUM_VALUE"].ToString(); //0【字典内码】，1【字典英文】
                        ListItemField.Text = drFieldEnum["FIELDENUM_NAME"].ToString() +
                            "[" + drFieldEnum["FIELDENUM_VALUE"] + "]";       //字典中文名称[字典英文]
                        ListItemField.Level = level + 1;
                        items.Add(ListItemField);
                    }
                }
            }

            foreach (DataRow _Row in dtFieldExplainType.Select("ExplainType_PID = '" + pid + "'",
                "EXPLAINTYPE_INDEX,EXPLAINTYPE_NAME,EXPLAINTYPE_ID"))
            {
                ListItemEx _ListItem = new ListItemEx();
                _ListItem.Value = _Row["ExplainType_ID"].ToString();
                _ListItem.Text = _Row["ExplainType_Name"].ToString();
                _ListItem.Level = level;
                if (_ListItem.Value == disabledValue)
                {
                    continue;
                }
                if (!disabled)
                {
                    _ListItem.Enabled = false;
                }
                items.Add(_ListItem);
                BindingFieldExplainDDL(transaction, dtFieldExplainType, _Row["ExplainType_ID"].ToString(), items,
                    disabledValue, level + 1, disabled, ShowFieldExplain, dtFieldExplain, valueType);

                if (ShowFieldExplain)
                {
                    foreach (DataRow drFieldExplain in dtFieldExplain.Select("EXPLAINTYPE_ID = " +
                        _Row["ExplainType_ID"].ToString(), "FIELDEXPLAIN_INDEX,FIELDEXPLAIN_FIELD"))
                    {
                        ListItemEx ListItemField = new ListItemEx();
                        ListItemField.Value = valueType == 0 ? drFieldExplain["FIELDEXPLAIN_ID"].ToString() :
                            drFieldExplain["FIELDEXPLAIN_FIELD"].ToString(); //0【字典内码】，1【字典英文】
                        ListItemField.Text = drFieldExplain["FIELDEXPLAIN_NAME"].ToString() +
                            "[" + drFieldExplain["FIELDEXPLAIN_FIELD"] + "]";       //字典中文名称[字典英文]
                        ListItemField.Level = level + 1;
                        items.Add(ListItemField);
                    }
                }
            }
        }
        #endregion

        #region 方法 -> 获取枚举字典数据源
        /// <summary />
        public static DataTable GetFieldExplainTypeDataSource(Transaction transaction, string pid)
        {
            return GetFieldExplainTypeDataSource(transaction, pid, string.Empty);
        }

        /// <summary />
        public static DataTable GetFieldExplainTypeDataSource(Transaction transaction, string pid, string obscureName)
        {
            string whereSQL = string.IsNullOrEmpty(pid) ? "" : "WHERE EXPLAINTYPE_PID = " + pid;
            DataTable dtExplainType = new ExplainType(transaction).FillDataTable(whereSQL);
            if (!string.IsNullOrWhiteSpace(obscureName))
            {
                dtExplainType.DefaultView.RowFilter = "EXPLAINTYPE_NAME like '%" + obscureName + "%'";
            }
            dtExplainType.DefaultView.Sort = "EXPLAINTYPE_INDEX,EXPLAINTYPE_NAME,EXPLAINTYPE_ID";

            return dtExplainType.DefaultView.ToTable();
        }
        #endregion
    }
}