using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using SuperMap.RealEstate.ServiceModel;
using CMB = SuperMap.RealEstate.Coop.Merchant.Business;
using Aliyun.Acs.Dysmsapi.Model.V20170525;
using Aliyun.Acs.Core.Profile;
using Aliyun.Acs.Core;
using HCC = HZQR.Common.Common;
using HZQR.Common;

namespace EShang.Common
{
    /// <summary>
    /// 公共方法
    /// </summary>
    public class CommonHelper
    {
        /// <summary>
        /// 数字数组
        /// </summary>
        public const string charSet = "0,1,2,3,4,5,6,7,8,9";

        #region 方法 -> 将DateTime类型转换为long类型
        /// <summary>
        /// 将DateTime类型转换为long类型
        /// </summary>
        /// <param name="dt">时间</param>
        /// <returns></returns>
        public static long ConvertDataTimeLong(DateTime dt)
        {
            DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            TimeSpan toNow = dt.Subtract(dtStart);
            long timeStamp = toNow.Ticks;
            timeStamp = long.Parse(timeStamp.ToString().Substring(0, timeStamp.ToString().Length - 7));
            return timeStamp;
        }
        #endregion

        #region 方法 -> 将Long类型转换为DateTime类型
        /// <summary>
        /// 将Long类型转换为DateTime类型
        /// </summary>
        /// <param name="d">long</param>
        /// <returns></returns>s
        public static DateTime ConvertLongDateTime(long d)
        {
            DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            long lTime = long.Parse(d + "0000000");
            TimeSpan toNow = new TimeSpan(lTime);
            DateTime dtResult = dtStart.Add(toNow);
            return dtResult;
        }

        /// <summary>
        /// 时间戳(毫秒值)String转换为DateTime类型转换
        /// </summary>
        /// <param name="time">毫秒时间戳</param>
        /// <returns></returns>
        public static DateTime TicksToDate(string time)
        {
            return new DateTime((Convert.ToInt64(time) * 10000) + 621355968000000000);
        }
        #endregion

        #region 方法 -> 比较两个日期大小，并返回相应日期
        /// <summary>
        /// 比较两个日期大小，并返回较大日期
        /// </summary>
        /// <param name="FirstDate"></param>
        /// <param name="SecondDate"></param>
        /// <returns></returns>s
        public static string GetLargerDate(string FirstDate, string SecondDate)
        {
            if (!FirstDate.Contains("/") && !FirstDate.Contains("-"))
            {
                FirstDate = HCC.Common.TranslateDateTime(FirstDate);
            }
            if (!SecondDate.Contains("/") && !SecondDate.Contains("-"))
            {
                SecondDate = HCC.Common.TranslateDateTime(SecondDate);
            }

            return DateTime.Parse(FirstDate) > DateTime.Parse(SecondDate) ?
                DateTime.Parse(FirstDate).ToShortDateString() : DateTime.Parse(SecondDate).ToShortDateString();
        }

        /// <summary>
        /// 比较两个日期大小，并返回较大时间
        /// </summary>
        /// <param name="FirstTime"></param>
        /// <param name="SecondTime"></param>
        /// <returns></returns>s
        public static string GetLargerTime(string FirstTime, string SecondTime)
        {
            if (!FirstTime.Contains("/") && !FirstTime.Contains("-"))
            {
                FirstTime = HCC.Common.TranslateDateTime(FirstTime);
            }
            if (!SecondTime.Contains("/") && !SecondTime.Contains("-"))
            {
                SecondTime = HCC.Common.TranslateDateTime(SecondTime);
            }

            return DateTime.Parse(FirstTime) > DateTime.Parse(SecondTime) ?
                DateTime.Parse(FirstTime).ToString() : DateTime.Parse(SecondTime).ToString();
        }

        /// <summary>
        /// 比较两个日期大小，并返回较小日期
        /// </summary>
        /// <param name="FirstDate"></param>
        /// <param name="SecondDate"></param>
        /// <returns></returns>s
        public static string GetSmallerDate(string FirstDate, string SecondDate)
        {
            if (!FirstDate.Contains("/") && !FirstDate.Contains("-"))
            {
                FirstDate = HCC.Common.TranslateDateTime(FirstDate);
            }
            if (!SecondDate.Contains("/") && !SecondDate.Contains("-"))
            {
                SecondDate = HCC.Common.TranslateDateTime(SecondDate);
            }

            return DateTime.Parse(FirstDate) > DateTime.Parse(SecondDate) ?
                DateTime.Parse(SecondDate).ToShortDateString() : DateTime.Parse(FirstDate).ToShortDateString();
        }

        /// <summary>
        /// 比较两个日期大小，并返回较小时间
        /// </summary>
        /// <param name="FirstTime"></param>
        /// <param name="SecondTime"></param>
        /// <returns></returns>s
        public static string GetSmallerTime(string FirstTime, string SecondTime)
        {
            if (!FirstTime.Contains("/") && !FirstTime.Contains("-"))
            {
                FirstTime = HCC.Common.TranslateDateTime(FirstTime);
            }
            if (!SecondTime.Contains("/") && !SecondTime.Contains("-"))
            {
                SecondTime = HCC.Common.TranslateDateTime(SecondTime);
            }

            return DateTime.Parse(FirstTime) > DateTime.Parse(SecondTime) ?
                DateTime.Parse(SecondTime).ToString() : DateTime.Parse(FirstTime).ToString();
        }
        #endregion

        #region 方法 -> 枚举参数过滤处理
        /// <summary>
        /// 枚举参数过滤处理，解决麻烦的SQL拼接
        /// （对照数据表给定添加、更新的参数枚举类型ValueType）
        /// </summary>
        /// <param name="_Type">数据类型</param>
        /// <param name="_String">数据值</param>
        /// <returns></returns>
        public static string IsArrayType(ValueType _Type, object _String = null)
        {
            if (_String != null && _String.ToString() != "")
            {
                switch (_Type)
                {
                    case ValueType.String:
                        return string.Format("'{0}'", _String.ToString().Replace("'", " "));
                    case ValueType.Int:
                    case ValueType.Double:
                    case ValueType.Boolean:
                        return _String.ToString();
                    case ValueType.DateTime:
                        return string.Format("TO_DATE('{0}','YYYY/MM/DD HH24:MI:SS')", _String);
                }
            }
            return "null";
        }

        /// <summary>
        /// 枚举参数过滤处理，解决麻烦的SQL拼接
        /// （对照数据表给定添加、更新的参数枚举类型ValueType）
        /// </summary>
        /// <param name="_Type">数据类型</param>
        /// <param name="_DefaultValue">是否使用缺省值</param>
        /// <returns></returns>
        private static string IsArrayType(ValueType _Type, bool _DefaultValue = false)
        {
            if (_DefaultValue)
            {
                switch (_Type)
                {
                    case ValueType.String:
                        return "''";
                    case ValueType.Int:
                    case ValueType.Double:
                    case ValueType.Boolean:
                        return "0";
                    case ValueType.DateTime:
                        return string.Format("TO_DATE('{0}','YYYY/MM/DD HH24:MI:SS')", DateTime.Now.ToString());
                }
            }
            return "null";
        }
        #endregion

        #region 方法 -> 定义5个类型的枚举
        /// <summary>
        /// 定义5个类型的枚举
        /// </summary>
        public enum ValueType
        {
            /// <summary>
            /// 字符串
            /// </summary>
            String = 0,
            /// <summary>
            /// 整型
            /// </summary>
            Int = 1,
            /// <summary>
            /// 双精度
            /// </summary>
            Double = 2,
            /// <summary>
            /// true或false
            /// </summary>
            Boolean = 3,
            /// <summary>
            /// 日期
            /// </summary>
            DateTime = 4
        }
        #endregion

        #region 方法 -> SQL语句分页
        /// <summary>
        /// SQL语句分页
        /// </summary>
        /// <param name="sql">SQL语句</param>
        /// <param name="rn">开始的行号</param>
        /// <param name="rowNum">结束的行号</param>
        /// <returns></returns>
        public static string GetPageSql(string sql, int? rn = null, int? rowNum = null)
        {
            if (rn != null && rowNum != null)
            {
                //分页查询
                sql = string.Format(@"
                    SELECT * FROM (
                        SELECT ROWNUM RN,N.* FROM ({0}) N   WHERE ROWNUM<={1} 
                    ) M WHERE M.RN>={2}", sql, rowNum, rn);
            }

            return sql;
        }
        #endregion

        #region 方法 -> 添加图片   
        /// <summary>
        /// 添加图片
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="imgArr">图片路径数组</param>
        /// <param name="tableId">业务关联表Id</param>
        /// <param name="tableName">业务关联表名称</param>
        /// <param name="imageType">图片类型</param>
        /// <returns></returns>
        public static string AddImageByFile(Transaction transaction, string imgArr,
            int tableId, string tableName, int imageType)
        {
            string imageids = string.Empty;         //图片集合
            try
            {
                #region 图片信息保存
                foreach (string imagePath in imgArr.Split(","))
                {
                    using (CMB.IMAGE _IMAGE = new CMB.IMAGE(transaction))
                    {
                        _IMAGE.IMAGE_PATH = imagePath;
                        _IMAGE.IMAGE_DATE = DateTime.Now;
                        _IMAGE.TABLE_ID = tableId;
                        _IMAGE.TABLE_NAME = tableName;
                        _IMAGE.IMAGE_TYPE = (short)imageType;
                        _IMAGE.ISVALID = 1;
                        _IMAGE.Insert();
                        imageids += (string.IsNullOrEmpty(imageids) ? "" : ",") + _IMAGE.IMAGE_ID;
                    }
                }
                #endregion
            }
            catch { }
            return imageids;
        }
        #endregion

        #region 方法 -> 查询图片   
        /// <summary>
        /// 添加图片
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="tableName">表名</param>
        /// <param name="tableId">表内码</param>
        /// <param name="imgType">图片类型</param>
        /// <returns></returns>
        public static DataTable ImageList(Transaction transaction, string tableName, int? tableId = null, int? imgType = null)
        {
            //根据业务表查询图库
            DataTable dtImage = new CMB.IMAGE(transaction).FillDataTable(
                        "WHERE TABLE_NAME = '" + tableName + "'" + " AND TABLE_ID = '" + tableId + "'" + " AND IMAGE_TYPE = '" + imgType + "'");
            return dtImage;
        }
        #endregion

        #region 方法 -> 为属性赋值
        /// <summary>
        /// 为属性赋值
        /// </summary>
        /// <typeparam name="T">源单类</typeparam>
        /// <typeparam name="S">需要转换的实体类</typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static S EntityConvert<T, S>(T source)
        {
            S target = Activator.CreateInstance<S>();
            var sType = source.GetType();
            var dType = typeof(S);
            foreach (PropertyInfo now in sType.GetProperties())
            {
                var name = dType.GetProperty(now.Name);
                if (name == null)
                    continue;
                dType.GetProperty(now.Name).SetValue(target, now.GetValue(source));
            }
            return target;
        }
        #endregion

        #region 方法 -> 获取指定页码Datatable数据
        /// <summary>
        /// 获取指定页码Datatable数据
        /// </summary>
        /// <param name="dtOrigin">源数据</param>
        /// <param name="pageSize">每页返回的数量</param>
        /// <param name="pageIndex">返回第几页数据</param>
        /// <returns>Datatable数据格式</returns>
        public static DataTable GetDataTableWithPageSize(DataTable dtOrigin, int pageSize, int pageIndex)
        {
            if (pageIndex == 0)
            {
                pageIndex = 1;
            }
            if (pageSize == 0)
            {
                pageSize = 10;
            }
            //克隆数据源
            DataTable dtClone = dtOrigin.Clone();
            dtClone.Columns.Add("RN", typeof(int));
            //开始插入数据源
            for (int RowCount = 0; RowCount < pageSize; RowCount++)
            {
                //获取当前数据源行数
                int RN = pageSize * (pageIndex - 1) + RowCount;
                //如果行数大于数据源实际数量，则直接跳过
                if (RN >= dtOrigin.Rows.Count)
                {
                    break;
                }
                //获取当前数据源内容
                DataRow EndAccountDataRow = dtOrigin.Rows[RN];
                //创建一个新 System.Data.DataRow 具有与表相同的架构
                DataRow _DataRow = dtClone.NewRow();
                //开始插入数据
                for (int ColumnsCount = 0; ColumnsCount < dtOrigin.Columns.Count; ColumnsCount++)
                {
                    _DataRow[ColumnsCount] = EndAccountDataRow[ColumnsCount];
                }
                _DataRow["RN"] = RN + 1;
                //将数据加入到克隆的DataTable中
                dtClone.Rows.Add(_DataRow);
            }

            return dtClone;
        }
        #endregion

        #region 方法 -> 生成验证码
        /// <summary>    
        /// 生成验证码          
        /// <param name="n">位数</param>   
        /// <returns>验证码字符串</returns>   
        public static string CreateRandomCode(int n)
        {
            string[] CharArray = charSet.Split(',');
            string randomCode = "";
            int temp = -1;
            Random rand = new Random();
            for (int i = 0; i < n; i++)
            {
                if (temp != -1)
                {
                    rand = new Random(i * temp * ((int)DateTime.Now.Ticks));
                }
                int t = rand.Next(CharArray.Length - 1);
                if (temp == t)
                {
                    return CreateRandomCode(n);
                }
                temp = t;
                randomCode += CharArray[t];
            }
            return randomCode;
        }
        #endregion

        #region 方法 -> 获取短信验证码
        /// <summary>
        /// 获取短信验证码
        /// </summary>
        /// <param name="_Transaction">事务管理器</param>
        /// <param name="PhoneNumber">手机号码</param>
        /// <param name="SignName">短信签名</param>
        /// <param name="BusinessName">商家名称</param>
        /// <returns></returns>
        public static string GetSMSIdentityCode(Transaction _Transaction, string PhoneNumber, string SignName, string BusinessName)
        {
            string identityCode = CreateRandomCode(4);
            string product = "Dysmsapi";//短信API产品名称（短信产品名固定，无需修改）
            string domain = "dysmsapi.aliyuncs.com";//短信API产品域名（接口地址固定，无需修改）
            string accessKeyId = Config.AppSettings.accessKeyId;//你的accessKeyId，参考本文档步骤2
            string accessKeySecret = Config.AppSettings.accessKeySecret;//你的accessKeySecret，参考本文档步骤2

            IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", accessKeyId, accessKeySecret);
            //IAcsClient client = new DefaultAcsClient(profile);
            // SingleSendSmsRequest request = new SingleSendSmsRequest();
            //初始化ascClient,暂时不支持多region（请勿修改）
            DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);

            IAcsClient acsClient = new DefaultAcsClient(profile);

            SendSmsRequest request = new SendSmsRequest
            {
                //必填:待发送手机号。支持以逗号分隔的形式进行批量调用，批量上限为1000个手机号码,
                //批量调用相对于单条调用及时性稍有延迟,验证码类型的短信推荐使用单条调用的方式
                PhoneNumbers = PhoneNumber,
                //必填:短信签名-可在短信控制台中找到
                SignName = string.IsNullOrEmpty(SignName) ? "驿商科技" : SignName,
                //必填:短信模板-可在短信控制台中找到
                TemplateCode = "SMS_65150085",
                //可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
                TemplateParam = "{\"code\":\"" + identityCode + "\",\"product\":\"" +
                (string.IsNullOrEmpty(BusinessName) ? "驿商云平台" : BusinessName) + "\"}"
            };
            //可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
            SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
            if (sendSmsResponse.Code.ToLower() == "ok")
            {
                string SQLString = string.Format(@"INSERT INTO HIGHWAY_EXCHANGE.T_SMSIDENTITY (
                        SMSIDENTITY_ID,CELLPHONE_NUMBER,IDENTITY_DATE,IDENTITY_CODE) 
                    VALUES (HIGHWAY_EXCHANGE.SEQ_SMSIDENTITY.NEXTVAL,'{0}',SYSDATE,'{1}')", PhoneNumber, identityCode);
                new CMB.AUTOTYPE(_Transaction).ExecuteNonQuery(SQLString, null);
            }

            return identityCode;
        }
        #endregion

        #region 方法 -> 合并Datatable中某个字符串的值
        /// <summary>
        /// 合并Datatable中某个字符串的值，返回list
        /// </summary>
        /// <param name="dataTable">数据源</param>
        /// <param name="FieldName">字段名称</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        public static List<string> JoinListFromDataTable(DataTable dataTable, string FieldName, string SortStr = "")
        {
            List<string> JoinStr = new List<string>();

            foreach (DataRow dataRow in dataTable.DefaultView.ToTable(true, FieldName).Select("", SortStr))
            {
                if (dataRow[FieldName].ToString() != "")
                {
                    JoinStr.Add(dataRow[FieldName].ToString());
                }
            }

            return JoinStr;
        }

        /// <summary>
        /// 合并Datatable中某个字符串的值，返回string
        /// </summary>
        /// <param name="dataTable">数据源</param>
        /// <param name="FieldName">字段名称</param>
        /// <param name="SeparateStr">分隔符，默认为,</param>
        /// <param name="SortStr">排序字段</param>
        /// <returns></returns>
        public static string JoinStrFromDataTable(DataTable dataTable, string FieldName,
            string SeparateStr = ",", string SortStr = "")
        {
            string JoinStr = "";

            foreach (DataRow dataRow in dataTable.DefaultView.ToTable(true, FieldName).Select("", SortStr))
            {
                if (dataRow[FieldName].ToString() != "")
                {
                    JoinStr += (JoinStr == "" ? "" : SeparateStr) + dataRow[FieldName];
                }
            }

            return JoinStr;
        }
        #endregion

        #region 方法 -> 计算中位数
        /// <summary>
        /// 计算中位数
        /// </summary>
        /// <param name="datas">Datatable数据源</param>
        /// <param name="fieldName">要计算的字段名称</param>
        /// <returns></returns>
        public static string getMedian(DataTable datas, string fieldName)
        {
            string median;

            if (datas.Rows.Count == 0)
            {
                median = "";
            }
            else if (datas.Rows.Count == 1)
            {
                median = datas.Rows[0][fieldName].ToString();
            }
            else if (datas.Rows.Count % 2 == 0)
            {
                //如果数据源的行数为偶数，则取中间两个数据的平均值作为返回值
                int index = datas.Rows.Count / 2;

                median = ((datas.Rows[index - 1][fieldName].TryParseToDecimal() +
                    datas.Rows[index][fieldName].TryParseToDecimal()) / 2).ToString();
            }
            else
            {
                //如果数据源的行数为奇数，则取中间的数据作为返回值
                median = datas.Rows[datas.Rows.Count / 2][fieldName].ToString();
            }

            return median;
        }
        #endregion

        #region 方法 -> 存储数字型数据至oracle数据库
        /// <summary>
        /// 存储数字型数据至oracle数据库
        /// </summary>
        /// <param name="OriValue">源数据值</param>
        /// <returns></returns>
        public static string GetNumberIntoOra(object OriValue)
        {
            if (OriValue == null)
            {
                return "NULL";
            }
            else
            {
                return GetNumberIntoOra(OriValue.ToString());
            }
        }

        /// <summary>
        /// 存储数字型数据至oracle数据库
        /// </summary>
        /// <param name="OriValue">源数据值</param>
        /// <returns></returns>
        public static string GetNumberIntoOra(string OriValue)
        {
            if (string.IsNullOrWhiteSpace(OriValue))
            {
                return "NULL";
            }
            else
            {
                return OriValue;
            }
        }
        #endregion

        #region 方法 -> 存储日期格式型数据至oracle数据库
        /// <summary>
        /// 存储日期格式型数据至oracle数据库
        /// </summary>
        /// <param name="OriValue">源数据值</param>
        /// <returns></returns>
        public static string GetDateTimeIntoOra(string OriValue)
        {
            string SQLValue = "";

            if (string.IsNullOrWhiteSpace(OriValue))
            {
                SQLValue = "NULL";
            }
            else
            {
                SQLValue = "TO_DATE('" + OriValue + "', 'YYYY/MM/DD HH24:MI:SS')";
            }

            return SQLValue;
        }
        #endregion

        #region 方法 -> 获取当月的第一天
        /// <summary>
        /// 获取当月的第一天
        /// </summary>
        /// <param name="Month">月份，格式yyyyMM</param>
        /// <returns>返回结果：日期字符串，格式yyyy-MM-dd</returns>
        public static string GetFirstDayOfMonth(string Month)
        {
            return Month.Substring(0, 4) + "-" + Month.Substring(4, 2) + "-01";
        }
        #endregion

        #region 方法 -> 获取当月的最后一天
        /// <summary>
        /// 获取当月的最后一天
        /// </summary>
        /// <param name="Month">月份，格式yyyyMM</param>
        /// <param name="ContainToday">最后一天是否包含今天，如果是则返回今天，否则返回昨天</param>
        /// <returns>返回结果：日期字符串，格式yyyy-MM-dd</returns>
        public static string GetLastDayOfMonth(string Month, bool ContainToday = true)
        {
            //获取当月的第一天
            string FirstDay = GetFirstDayOfMonth(Month);
            //当月最后一天=当月第一天+1个月-1天
            DateTime LastDay = DateTime.Parse(FirstDay).AddMonths(1).AddDays(-1);
            //如果最后一天比今天大，则按今天的日期返回，否则返回最后一天的日期
            if (LastDay >= DateTime.Now.Date)
            {
                if (ContainToday)
                {
                    return DateTime.Now.ToString("yyyy-MM-dd");
                }
                else
                {
                    return DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd");
                }
            }
            else
            {
                return LastDay.ToString("yyyy-MM-dd");
            }
        }
        #endregion

        #region 方法 -> 获取下一个月
        /// <summary>
        /// 获取下一个月
        /// </summary>
        /// <param name="Month">月份，格式yyyyMM</param>
        /// <returns>返回结果：日期字符串，格式yyyyMM</returns>
        public static string GetNextMonth(string Month)
        {
            if (Month.EndsWith("12"))
            {
                return int.Parse(Month.Substring(0, 4)) + 1 + "01";
            }

            return (int.Parse(Month) + 1).ToString("00");
        }
        #endregion

        #region 方法 -> 获取上一个月
        /// <summary>
        /// 获取上一个月
        /// </summary>
        /// <param name="Month">月份，格式yyyyMM</param>
        /// <param name="AddMonth">扣减月数</param>
        /// <returns>返回结果：日期字符串，格式yyyyMM</returns>
        public static string GetLastMonth(string Month, int AddMonth = -1)
        {
            if (AddMonth != -1)
            {
                return DateTime.Parse(HCC.Common.TranslateDateTime(Month)).AddMonths(AddMonth).ToString("yyyyMM");
            }

            if (Month.EndsWith("01"))
            {
                return (int.Parse(Month.Substring(0, 4)) - 1) + "12";
            }

            return Month.Substring(0, 4) + (int.Parse(Month.Substring(4, 2)) - 1).ToString("00");
        }
        #endregion

        #region 方法 -> 根据开始结束时间计算月数
        /// <summary>
        /// 根据开始结束时间计算月数
        /// </summary>
        /// <param name="StartDate">开始日期</param>
        /// <param name="EndDate">结束日期</param>
        /// <returns></returns>
        public static decimal calcMonthCount(DateTime StartDate, DateTime EndDate)
        {
            //计算第一个月的月数，1-10计算为1个月，11-20计算为0.5个月，20之后不计算
            decimal startCount = StartDate.Day < 11 ? 1 : StartDate.Day < 21 ? (decimal)0.5 : 0;
            startCount -= EndDate.Day < 11 ? 1 : EndDate.Day < 21 ? (decimal)0.5 : 0;

            return (EndDate.Year - StartDate.Year) * 12 + EndDate.Month - StartDate.Month + startCount;
        }
        #endregion

        #region 方法 -> 获取嵌套列表最低一级数据集
        /// <summary>
        /// 获取嵌套列表最低一级数据集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="nestingList">原嵌套列表</param>
        /// <param name="DataList">转换后的数据集</param>
        public static void GetNestingData<T>(List<Model.NestingModel<T>> nestingList, List<T> DataList)
        {
            foreach (Model.NestingModel<T> nestingModel in nestingList)
            {
                if (nestingModel.children == null || nestingModel.children.Count == 0)
                {
                    DataList.Add(nestingModel.node);
                }
                else
                {
                    GetNestingData(nestingModel.children, DataList);
                }
            }
        }
        #endregion

        #region 方法 -> 计算标准差
        /// <summary>
        /// 样本标准差和总体标准差计算
        /// </summary>
        /// <param name="arrData">数据数组</param>
        /// <param name="std_dev">样本标准差：sqrt(sum((xn-x)^2)/(n-1))</param>
        /// <param name="STDP">总体标准差：sqrt(sum((xn-x)^2)/n)</param>
        public static void CalcStandardDeviation(List<decimal> arrData, out double std_dev, out double STDP) //计算标准偏差
        {
            decimal xAvg = arrData.Average();//样本平均值
            double sSum = 0;//方差的分子
            int arrNum = arrData.Count;//得到样本数量，分母

            foreach (decimal data in arrData)//得到方差的分子
            {
                sSum += Math.Pow((double)(data - xAvg), 2);
            }

            std_dev = Math.Sqrt(sSum / (arrNum - 1));//样本标准差
            STDP = Math.Sqrt(sSum / arrNum);//总体标准差
        }
        #endregion

        #region 方法 -> 将字符串编码为 Base64
        /// <summary>
        /// 将字符串编码为 Base64
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static string Base64Encode(string text)
        {
            return (Convert.ToBase64String(Encoding.UTF8.GetBytes(text)));
        }
        #endregion

        //------------------以下是低代码平台的相关方法--------------------------//

        #region 方法 -> 文本内容增加空格，数量由入参控制
        /// <summary>
        /// 文本内容增加空格，数量由入参控制
        /// </summary>
        /// <param name="TabCount">空格数量</param>
        /// <returns></returns>
        public static string GetTabChar(int TabCount)
        {
            StringBuilder _TabChar = new StringBuilder();
            int _Count = TabCount * 4;
            for (int i = 0; i < _Count; i++)
            {
                _TabChar.Append(" ");
            }
            return _TabChar.ToString(); ;
        }
        #endregion

        #region 方法 -> 增加代码注解
        /// <summary>
        /// 增加代码注解<br/>
        /// 在代码里面生成的中文释义
        /// </summary>
        /// <param name="stringBuilder">字符串</param>
        /// <param name="SummaryContent">注解内容</param>
        /// <param name="StartIndex">内容缩进格数</param>
        /// <param name="parameters">方法中的参数注解，可以为空</param>
        public static void BuildCodeSummary(StringBuilder stringBuilder, string SummaryContent,
            int StartIndex = 0, Dictionary<string, string> parameters = null)
        {
            stringBuilder.AppendLine(GetTabChar(StartIndex) + "/// <summary>");
            stringBuilder.AppendLine(GetTabChar(StartIndex) + "/// " + SummaryContent);
            stringBuilder.AppendLine(GetTabChar(StartIndex) + "/// </summary>");

            if (parameters != null)
            {
                foreach (string key in parameters.Keys)
                {
                    stringBuilder.AppendLine(GetTabChar(2) + "/// <param name=\"" + key + "\">" + parameters[key] + "</param>");
                }
            }
        }
        #endregion

        #region 方法 -> 增加catch方法代码
        /// <summary>
        /// 增加catch方法代码
        /// </summary>
        /// <param name="stringBuilder">字符串</param>
        /// <param name="FailName">失败命名：例如“查询”失败</param>
        /// <param name="LogName">日志名称</param>
        /// <param name="StartIndex">内容缩进格数</param>
        public static void BuildCatchCode(StringBuilder stringBuilder, string FailName, string LogName, int StartIndex = 0)
        {
            stringBuilder.AppendLine(GetTabChar(StartIndex) + "catch (Exception ex)");
            stringBuilder.AppendLine(GetTabChar(StartIndex) + "{");
            stringBuilder.AppendLine(GetTabChar(StartIndex + 1) + "//事务回滚");
            stringBuilder.AppendLine(GetTabChar(StartIndex + 1) + "transaction.Rollback();");
            //记录异常日志
            stringBuilder.AppendLine(GetTabChar(StartIndex + 1) + "LogUtil.WriteLog(null, " +
                "\"" + FailName + "失败！失败原因：\" + ex.Message + \"\\r\\n\" + Parameter,");
            stringBuilder.AppendLine(GetTabChar(StartIndex + 2) + "DateTime.Now.ToString(\"yyyyMMdd\") + \"_" + LogName + "\");");
            stringBuilder.AppendLine(GetTabChar(StartIndex + 1) + "return Ok(Method.Common.ReturnJson(999, \"查询失败\" + ex.Message));");
            stringBuilder.AppendLine(GetTabChar(StartIndex) + "}");
        }
        #endregion

        #region 方法 -> 获取命名空间简写
        /// <summary>
        /// 获取命名空间简写
        /// </summary>
        /// <param name="WholeNameSpace">命名空间全称</param>
        /// <returns></returns>
        public static string GetNameSpaceShortName(string WholeNameSpace)
        {
            string ShortName = "";

            foreach (string NameSpace in WholeNameSpace.Split('.'))
            {
                ShortName += NameSpace.Substring(0, 1);
            }

            return ShortName;
        }
        #endregion

        #region 方法 -> 转换字符串大小写
        /// <summary>
        /// 返回首字母大写、其余字符小写的字符串model对象
        /// </summary>
        /// <param name="className">字符串</param>
        /// <returns>原字符串CLASS_NAME，返回Class_nameModel</returns>
        public static string GetClassModelName(string className)
        {
            return className + "Model";
        }

        /// <summary>
        /// 返回首字母大写、其余字符小写的字符串
        /// </summary>
        /// <param name="className">字符串</param>
        /// <returns>原字符串CLASS_NAME，返回Class_name</returns>
        public static string GetULClassName(string className)
        {
            return className.Substring(0, 1).ToUpper() + className.Substring(1, className.Length - 1).ToLower();
        }

        /// <summary>
        /// 返回小写字符串，如果有_，则_后面的第一个字符大写
        /// </summary>
        /// <param name="className">字符串</param>
        /// <returns>原字符串CLASS_NAME，返回class_Name</returns>
        public static string GetLUName(string className)
        {
            string resName = className.Split('_')[0].ToLower();
            //以_分割字符串，从第一个_之后的字符串开始遍历，每段字符串首字母大写其余字母小写
            for (int SplitLength = 1; SplitLength < className.Split('_').Length; SplitLength++)
            {
                resName += GetULClassName(className.Split('_')[SplitLength]);
            }

            return resName;
        }

        /// <summary>
        /// 返回首字母小写的字符串
        /// 如原字符串CLASS_NAME，返回cLASS_NAME
        /// </summary>
        /// <param name="name">字符串</param>
        /// <returns></returns>
        public static string GetFLName(string name)
        {
            return name.Substring(0, 1).ToLower() + name.Substring(1, name.Length - 1);
        }
        #endregion

        #region 方法 -> 设置时间参数默认值
        /// <summary>
        /// 设置时间参数默认值
        /// </summary>
        /// <param name="stringBuilder">字符串</param>
        /// <param name="DefaultDateValueType">时间参数默认值</param>
        /// <param name="DateFormat">时间参数格式</param>
        /// <param name="IsDateRange">是否是时间段选择</param>
        public static void SetDateInitialValue(StringBuilder stringBuilder, string DefaultDateValueType, string DateFormat, bool IsDateRange)
        {
            switch (DefaultDateValueType)
            {
                case "1":   //默认显示最近一天
                    stringBuilder.AppendLine(GetTabChar(3) + "initialValue: " + (!IsDateRange ?
                        "moment().add(-1, 'day').format('" + DateFormat + "')" : "[moment().add(-1, 'day').format('" +
                        DateFormat + "'), moment().add(-1, 'day').format('" + DateFormat + "')],"));
                    break;
                case "2":   //默认显示最近一周
                    stringBuilder.AppendLine(GetTabChar(3) + "initialValue: " + (!IsDateRange ?
                        "moment().add(-1, 'week').format('" + DateFormat + "')" : "[moment().add(-1, 'week').format('" +
                        DateFormat + "'), moment().add(-1, 'day').format('" + DateFormat + "')],"));
                    break;
                case "3":   //默认显示最近一月
                    stringBuilder.AppendLine(GetTabChar(3) + "initialValue: " + (!IsDateRange ?
                        "moment().add(-1, 'month').format('" + DateFormat + "')" : "[moment().add(-1, 'month').format('" +
                        DateFormat + "'), moment().add(-1, 'day').format('" + DateFormat + "')],"));
                    break;
                case "4":   //默认显示最近三月
                    stringBuilder.AppendLine(GetTabChar(3) + "initialValue: " + (!IsDateRange ?
                        "moment().add(-3, 'month').format('" + DateFormat + "')" : "[moment().add(-3, 'month').format('" +
                        DateFormat + "'), moment().add(-1, 'day').format('" + DateFormat + "')],"));
                    break;
                case "5":   //默认显示最近半年
                    stringBuilder.AppendLine(GetTabChar(3) + "initialValue: " + (!IsDateRange ?
                        "moment().add(-6, 'month').format('" + DateFormat + "')" : "[moment().add(-6, 'month').format('" +
                        DateFormat + "'), moment().add(-1, 'day').format('" + DateFormat + "')],"));
                    break;
                case "6":   //默认显示最近一年
                    stringBuilder.AppendLine(GetTabChar(3) + "initialValue: " + (!IsDateRange ?
                        "moment().add(-1, 'year').format('" + DateFormat + "')" : "[moment().add(-1, 'year').format('" +
                        DateFormat + "'), moment().add(-1, 'day').format('" + DateFormat + "')],"));
                    break;
            }
        }
        #endregion

        #region 方法 -> 设置字段默认排序
        /// <summary>
        /// 设置字段默认排序
        /// </summary>
        /// <param name="stringBuilder">生成代码的字符串</param>
        /// <param name="OrderByType">排序方式</param>
        /// <param name="StartIndex">代码缩进格数</param>
        public static void SetFieldSort(StringBuilder stringBuilder, string OrderByType, int StartIndex = 3)
        {
            switch (OrderByType)
            {
                case "1"://增加排序效果，但不设置默认排序
                    stringBuilder.AppendLine(GetTabChar(StartIndex) + "sorter: true,");
                    break;
                case "2"://增加排序效果，默认按正序显示
                    stringBuilder.AppendLine(GetTabChar(StartIndex) + "sorter: true,");
                    stringBuilder.AppendLine(GetTabChar(StartIndex) + "defaultSortOrder: 'ascend',");
                    break;
                case "3"://增加排序效果，默认按倒序显示
                    stringBuilder.AppendLine(GetTabChar(StartIndex) + "sorter: true,");
                    stringBuilder.AppendLine(GetTabChar(StartIndex) + "defaultSortOrder: 'descend',");
                    break;
            }
        }
        #endregion
    }
}