mes-client/UAS-出货标签管理/PublicMethod/BaseUtil.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Text;
using System.Windows.Forms;
using UAS_LabelMachine.CustomControl;
using UAS_LabelMachine.CustomControl.GroupBoxWithBorder;
using static System.Windows.Forms.Control;
using System.Text.RegularExpressions;

namespace UAS_LabelMachine
{
    class BaseUtil
    {

        static string SysDisc;

        public static string lpad(int length, string number)
        {
            while (number.Length < length)
            {
                number = "0" + number;
            }
            number = number.Substring(number.Length - length, length);
            return number;
        }

        public static string SysDisc1
        {
            get
            {
                return SysDisc = Environment.GetEnvironmentVariable("windir").Substring(0, 1);
            }

            set
            {
                SysDisc = value;
            }
        }

        public static string DToAny(double DB, int Type)
        {
            string H = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            long D;
            double B;
            string tempD = "", tempB = "";
            D = (long)DB;
            B = DB - D;
            if (D == 0)
            {
                tempD = "0";
            }
            while (D != 0)
            {
                tempD = H[(((int)D % Type))] + tempD;
                D = D / Type;
            }
            for (int i = 0; i < 7; i++)
            {
                if (B == 0)
                {
                    break;
                }
                tempB += H[((int)(B * Type))];
                B = B * Type - (int)(B * Type);
            }
            if (tempB == "")
            {
                return tempD;
            }
            else
            {
                return tempD + "." + tempB;
            }
        }

        public static DataTable GetExportDataTable(DataGridView dgv)
        {
            DataTable dt = ((DataTable)dgv.DataSource).Copy();
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                for (int j = 0; j < dgv.Columns.Count; j++)
                {
                    if (dt.Columns[i].ColumnName.ToLower() == dgv.Columns[j].DataPropertyName.ToLower())
                    {
                        dt.Columns[i].ColumnName = dgv.Columns[j].HeaderText;
                    }
                }
            }
            return dt;
        }

        /// <summary>
        /// 通过DataTable的ColumnName和Caption来拼接一条语句
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        public static string GetGridViewSelectContent(DataGridView d)
        {
            StringBuilder selectConetnt = new StringBuilder();
            DataTable dt = (DataTable)d.DataSource;
            if (dt == null)
            {
                foreach (DataGridViewColumn dc in d.Columns)
                {
                    if (dc.DataPropertyName != "" && dc.DataPropertyName != null)
                    {
                        selectConetnt.Append(dc.DataPropertyName + " as " + dc.DataPropertyName + ",");
                    }
                }
            }
            else
            {
                foreach (DataColumn dc in dt.Columns)
                {
                    selectConetnt.Append(dc.Caption + " as " + dc.ColumnName + ",");
                }
            }
            return selectConetnt.Remove(selectConetnt.Length - 1, 1).ToString();
        }
        /// <summary>
        /// 通过字段和其展示的中文值获取查询的内容
        /// </summary>
        /// <param name="field"></param>
        /// <param name="cnfield"></param>
        /// <returns></returns>
        public static string GetSelectContentByStringArray(string[] field, string[] cnfield)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < field.Length; i++)
            {
                sb.Append(field[i] + " as " + cnfield[i] + ",");
            }
            //去掉多余的逗号
            sb.Remove(sb.Length - 1, 1);
            return sb.ToString();
        }
        /// <summary>
        ///  传入控件的集合和DataTable，通过判断控件的名称和数据源的列的描述来匹配，支持单层的GroupBox和Panel
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="dt"></param>
        public static void SetFormValue(ControlCollection collection, DataTable dt)
        {
            //DataTable存在数据才进行赋值操作
            if (dt.Rows.Count > 0)
            {
                for (int i = 0; i < collection.Count; i++)
                {
                    string controlName = collection[i].Name;
                    //默认给TextBox和Label赋值
                    if (collection[i] is TextBox || collection[i] is Label || collection[i] is SearchTextBox)
                    {
                        for (int j = 0; j < dt.Columns.Count; j++)
                        {
                            if (controlName.ToUpper() == dt.Columns[j].Caption.ToUpper())
                            {
                                //字段含有Status内容的才进行转换
                                if (controlName.ToUpper().Contains("STATUS"))
                                {
                                    //对审批状态进行判断
                                    switch (dt.Rows[0][j].ToString().ToUpper())
                                    {
                                        case "ENTERING":
                                            collection[i].Text = "在录入";
                                            break;
                                        case "UNAPPROVED":
                                            collection[i].Text = "未批准";
                                            break;
                                        case "COMMITED":
                                            collection[i].Text = "已提交";
                                            break;
                                        case "APPROVE":
                                            collection[i].Text = "已批准";
                                            break;
                                        case "AUDITED":
                                            collection[i].Text = "已审核";
                                            break;
                                        case "STARTED":
                                            collection[i].Text = "已下发";
                                            break;
                                        case "UNCHECK":
                                            collection[i].Text = "待检验";
                                            break;
                                        case "CHECKING":
                                            collection[i].Text = "检验中";
                                            break;
                                        default:
                                            collection[i].Text = dt.Rows[0][j].ToString();
                                            break;
                                    }
                                }
                                else
                                {
                                    collection[i].Text = dt.Rows[0][j].ToString();
                                }
                            }
                        }
                    }
                    //对封装在GroupBox的和Panel的控件进行批量赋值
                    if (collection[i] is GroupBox || collection[i] is Panel || collection[i] is GroupBoxWithBorder)
                    {
                        for (int j = 0; j < collection[i].Controls.Count; j++)
                        {
                            controlName = collection[i].Controls[j].Name;
                            if (collection[i].Controls[j] is TextBox || collection[i].Controls[j] is Label || collection[i].Controls[j] is SearchTextBox)
                            {
                                for (int k = 0; k < dt.Columns.Count; k++)
                                {
                                    if (controlName.ToUpper() == dt.Columns[k].Caption.ToUpper())
                                    {
                                        collection[i].Controls[j].Text = dt.Rows[0][k].ToString();
                                    }
                                }
                            }
                        }
                    }
                }
            }
            //如果没有记录的话，将dt中含有的列的对应值设置为空
            else
            {
                for (int i = 0; i < collection.Count; i++)
                {
                    if (collection[i] is TextBox || collection[i] is Label || collection[i] is SearchTextBox)
                    {
                        for (int j = 0; j < dt.Columns.Count; j++)
                        {
                            if (collection[i].Name.ToUpper() == dt.Columns[j].Caption.ToUpper())
                            {
                                collection[i].Text = "";
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 获取标签的路径
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="LabelName"></param>
        /// <returns></returns>
        public static string GetLabelUrl(string URL, string LabelName, DateTime time)
        {
            //如果是传入的数据是从FTP取的文件
            if (URL.Contains("ftp:"))
            {
                ftpOperater ftp = new ftpOperater(Properties.Settings.Default.FTPModel);
                return ftp.Download(LabelName, time);
            }
            else
            {
                return URL;
            }
        }

        /// <summary>
        /// 从DGV获取指定的列的数据形式是数组的形式
        /// </summary>
        public static ArrayList[] GetColumnDataFromDGV(DataGridView dgv, string[] ColumnName)
        {
            ArrayList[] array = new ArrayList[ColumnName.Length];
            //实例化和查询参数个数一样的ArrayList
            for (int i = 0; i < ColumnName.Length; i++)
            {
                array[i] = new ArrayList();
            }
            DataTable dt = (DataTable)dgv.DataSource;
            //如果第一列是否选框的话
            if (dgv.Columns[0] is DataGridViewCheckBoxColumn)
            {
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    if (dgv.Rows[i].Cells[0].FormattedValue.ToString() == "True")
                    {

                        for (int j = 0; j < ColumnName.Length; j++)
                        {
                            array[j].Add(dt.Rows[i][ColumnName[j]]);
                        }
                    }
                }
            }
            //否则直接获取全部的数据
            else
            {
                for (int i = 0; i < dgv.RowCount; i++)
                {
                    for (int j = 0; j < ColumnName.Length; j++)
                    {
                        array[j].Add(dt.Rows[i][ColumnName[j]]);
                    }
                }
            }
            return array;
        }

        /// <summary>
        /// 通过DataGridView和需要隐藏的字段的数组来对字段进行隐藏
        /// </summary>
        /// <param name="dgv"></param>
        /// <param name="field"></param>
        public static void HideField(DataGridView dgv, string[] field)
        {
            DataTable dt = (DataTable)dgv.DataSource;
            foreach (DataColumn dc in dt.Columns)
            {
                foreach (string s in field)
                {
                    if (dc.Caption == s)
                    {
                        dgv.Columns[dc.ColumnName].Visible = false;
                    }
                }
            }
        }

        /// <summary>
        /// 通过查询的内容获取到字段的描述
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public static string[] GetCaptionFromField(string field)
        {
            string[] caption = field.Split(',');
            for (int i = 0; i < caption.Length; i++)
            {
                caption[i] = caption[i].Substring(0, caption[i].LastIndexOf("as")).Trim();
            }
            return caption;
        }

        /// <summary>
        /// 通过查询的语句获取查询的字段
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public static string[] GetField(string field)
        {
            string[] fields = field.Split(',');
            for (int i = 0; i < fields.Length; i++)
            {
                fields[i] = fields[i].Substring(fields[i].LastIndexOf("as") + 2, fields[i].Length - fields[i].LastIndexOf("as") - 2).Trim();
            }
            return fields;
        }


        /// <summary>
        /// 将DataTable转换为List的键值对
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static List<Dictionary<string, string>> DataTableToListDictionary(DataTable dt)
        {
            List<Dictionary<string, string>> list = new List<Dictionary<string, string>>();
            foreach (DataRow dr in dt.Rows)
            {
                Dictionary<string, string> dictionary = new Dictionary<string, string>();
                foreach (DataColumn dc in dt.Columns)
                {
                    dictionary.Add(dc.Caption, dr[dt.Columns.IndexOf(dc)].ToString());
                }
                list.Add(dictionary);
            }
            return list;
        }

        /// <summary>
        /// 通过描述取DataTable的列名，主要用于从配置中取数据
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="caption"></param>
        /// <returns></returns>
        public static string GetColumnNameByCaption(DataTable dt, string caption)
        {
            foreach (DataColumn dc in dt.Columns)
            {
                if (dc.Caption.ToLower() == caption)
                {
                    return dc.ColumnName;
                }
            }
            return null;
        }

        //用于封装异常，也可以用于错误的提示
        public static void ShowError(string errorMessage)
        {
            throw new Exception(errorMessage);
        }

        /// <summary>
        /// 清除DataTable的结构和数据,清除列结构时需要从最后的一列开始删
        /// </summary>
        /// <param name="dt"></param>
        public static void CleanDataTable(DataTable dt)
        {
            for (int i = dt.Columns.Count - 1; i >= 0; i--)
            {
                dt.Columns.Remove(dt.Columns[i]);
            }
        }

        /// <summary>
        /// 不清楚表结构，只清楚数据
        /// </summary>
        /// <param name="dt"></param>
        public static void CleanDataTableData(DataTable dt)
        {
            for (int i = dt.Rows.Count - 1; i >= 0; i--)
            {
                dt.Rows.Remove(dt.Rows[i]);
            }
        }
        /// <summary>
        /// 获取拼接的字段
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static string GetFieldFromDataTable(DataTable dt)
        {
            StringBuilder sb = new StringBuilder();
            foreach (DataColumn dc in dt.Columns)
            {
                sb.Append(dc.Caption + ",");
            }
            return sb.ToString().Substring(sb.ToString().Length - 1, 1);
        }

        /// <summary>
        /// 已经定义好的DataGridView绑定数据,operate是用来添加操作列的
        /// </summary>
        /// <param name="dgv"></param>
        /// <param name="dt"></param>
        /// <param name="AddOpetateColumn"></param>
        /// <param name="operate"></param>
        public static void FillDgvWithDataTable(DataGridView dgv, DataTable dt, params DataGridViewImageColumn[] operate)
        {
            dgv.AutoGenerateColumns = false;
            dgv.DataSource = dt;
            if (operate.Length > 0)
            {
                if (dgv.Columns[operate[0].Name] != null)
                {
                    dgv.Columns.Remove(dgv.Columns[operate[0].Name]);
                }
                dgv.Columns.Add(operate[0]);
            }
            //纯英文的列不予展示
            //Regex regEnglish = new Regex("^[_][a-z]$");
            //foreach (DataGridViewColumn dgvc in dgv.Columns)
            //{
            //    if (dgvc.HeaderText.IndexOf("_id") > 0)
            //    {
            //        dgvc.Visible = false;
            //    }
            //}
        }
        /// <summary>
        /// 清除DataGridView的数据
        /// </summary>
        /// <param name="dgv"></param>
        public static void CleanDGVData(DataGridView dgv)
        {
            for (int i = dgv.Rows.Count - 1; i >= 0; i--)
            {
                dgv.Rows.RemoveAt(i);
            }
        }

        /// <summary>
        /// 清除Form的指定类型的数据
        /// </summary>
        /// <param name="Form"></param>
        public static void CleanForm(Form Form)
        {
            for (int i = 0; i < Form.Controls.Count; i++)
            {
                if (Form.Controls[i] is EnterTextBox || Form.Controls[i] is TextBox || Form.Controls[i] is RichTextBox || Form.Controls[i] is SearchTextBox)
                    Form.Controls[i].Text = "";
                if (Form.Controls[i] is DataGridView)
                    CleanDGVData((DataGridView)Form.Controls[i]);
            }
        }



        /// <summary>
        /// 用于给DGV中的Combox列赋静态值
        /// </summary>
        /// <param name="dgvc"></param>
        /// <param name="displayField"></param>
        /// <param name="valueField"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public static void SetDgvColumnComboxData(DataGridViewComboBoxColumn dgvc, string DataPropertyName, string displayField, string valueField, string[] Value)
        {
            DataTable dt = new DataTable();
            dt.Columns.Add(displayField);
            dt.Columns.Add(valueField);
            for (int i = 0; i < Value.Length; i++)
            {
                DataGridViewRow row = new DataGridViewRow();
                dt.Rows.Add(row);
                dt.Rows[i][displayField] = Value[i].Split('#')[0];
                dt.Rows[i][valueField] = Value[i].Split('#')[1];
            }
            dgvc.DataPropertyName = DataPropertyName;
            dgvc.DataSource = dt;
            dgvc.DisplayMember = displayField;
            dgvc.ValueMember = valueField;
        }

        /// <summary>
        /// 用于给DGV中的ComboxCell赋静态值
        /// </summary>
        /// <param name="dgvcc"></param>
        /// <param name="displayField"></param>
        /// <param name="valueField"></param>
        /// <param name="Value"></param>
        public static void SetDGVCellComboxData(DataGridViewComboBoxCell dgvcc, string displayField, string valueField, string[] Value)
        {
            DataTable dt = new DataTable();
            dt.Columns.Add(displayField);
            dt.Columns.Add(valueField);
            for (int i = 0; i < Value.Length; i++)
            {
                DataRow dr = dt.NewRow();
                dr[displayField] = Value[i].Split('#')[0];
                dr[valueField] = Value[i].Split('#')[1];
                dt.Rows.Add(dr);
            }
            dgvcc.DisplayMember = displayField;
            dgvcc.ValueMember = valueField;
            dgvcc.DataSource = dt;
        }

        /// <summary>
        /// 用于给DGV中的ComboxCell赋静态值
        /// </summary>
        /// <param name="dgvcc"></param>
        /// <param name="displayField"></param>
        /// <param name="valueField"></param>
        /// <param name="Value"></param>
        public static void SetComboxData(ComboBox dgvcc, string displayField, string valueField, string[] Value)
        {
            DataTable dt = new DataTable();
            dt.Columns.Add(displayField);
            dt.Columns.Add(valueField);
            for (int i = 0; i < Value.Length; i++)
            {
                DataRow dr = dt.NewRow();
                dr[displayField] = Value[i].Split('#')[0];
                dr[valueField] = Value[i].Split('#')[1];
                dt.Rows.Add(dr);
            }
            dgvcc.DisplayMember = displayField;
            dgvcc.ValueMember = valueField;
            dgvcc.DataSource = dt;
        }

        /// <summary>
        /// 获取刷选的SQL语句，传入的是TextBox的Control，传入的SQL不带Where条件
        /// </summary>
        /// <param name="SQL"></param>
        /// <param name="Condition"></param>
        /// <returns></returns>
        public static string GetScreenSqlCondition(params Control[] Condition)
        {
            string condition = " where ";
            for (int i = 0; i < Condition.Length; i++)
            {
                if (i != Condition.Length - 1)
                {
                    if (Condition[i] is ComboBox)
                    {
                        condition += "(" + Condition[i].Tag + " like " + "'%" + (Condition[i] as ComboBox).SelectedValue + "%' or " + Condition[i].Tag + " is null)  and ";
                    }
                    else
                    {
                        condition += "(" + Condition[i].Tag + " like " + "'%" + Condition[i].Text + "%' or " + Condition[i].Tag + " is null) and ";
                    }
                }
                else
                {
                    if (Condition[i] is ComboBox)
                    {
                        condition += "(" + Condition[i].Tag + " like " + "'%" + (Condition[i] as ComboBox).SelectedValue + "%' or " + Condition[i].Tag + " is null)";
                    }
                    else
                    {
                        condition += "(" + Condition[i].Tag + " like " + "'%" + Condition[i].Text + "%' or " + Condition[i].Tag + " is null)";
                    }
                }
            }
            return condition;
        }

        public static void CleanDataGridView(DataGridView dgv)
        {
            for (int i = dgv.Columns.Count - 1; i >= 0; i--)
            {
                dgv.Columns.RemoveAt(i);
            }
        }

        /// <summary>
        /// 取出SQL中的参数占位符
        /// </summary>
        /// <param name="SQL"></param>
        /// <returns></returns>
        public static string[] GetParamFromSQL(string SQL)
        {
            string[] par = SQL.Split(':');
            //用来存参数的数组
            StringBuilder[] addpar = new StringBuilder[par.Length - 1];
            string[] param = new string[par.Length - 1];
            for (int i = 0; i < par.Length - 1; i++)
            {
                //新建一个char类型的数组用来存储每个字节的变量
                char[] c = par[i + 1].ToCharArray();
                addpar[i] = new StringBuilder();
                for (int j = 0; j < c.Length; j++)
                {
                    if (c[j] != ' ' && c[j] != ',' && c[j] != ')')
                    {
                        addpar[i].Append(c[j]);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            for (int i = 0; i < par.Length - 1; i++)
            {
                param[i] = addpar[i].ToString();
            }
            return param;
        }

        public static void SetFormCenter(Form form)
        {
            form.StartPosition = FormStartPosition.CenterParent;
        }

        /// <summary>
        /// 设置DataGridView的指定列可编辑
        /// </summary>
        /// <param name="DGV"></param>
        /// <param name="EditAbleField"></param>
        public static void SetDataGridViewReadOnly(DataGridView DGV, string[] EditAbleField)
        {
            foreach (DataGridViewColumn dc in DGV.Columns)
            {
                dc.ReadOnly = true;
                foreach (string s in EditAbleField)
                {
                    if (dc.Name.ToLower() == s.ToLower())
                    {
                        DGV.Columns[dc.Name].ReadOnly = false;
                    }
                }
            }
        }

        //判断带有CheckBox的DGV是否有项目勾选了
        public static DataTable DGVIfChecked(DataGridView dgv)
        {
            int CheckCount = 0;
            DataTable dt = new DataTable();
            //第一列是勾选框，排除在循环之外
            for (int i = 1; i < dgv.Columns.Count; i++)
            {
                dt.Columns.Add(dgv.Columns[i].Name);
            }
            for (int i = 0; i < dgv.RowCount; i++)
            {
                if (dgv.Rows[i].Cells[0].Value != null)
                {
                    if (dgv.Rows[i].Cells[0].Value.ToString() == "True")
                    {
                        if (dgv.Rows[i].Tag.ToString() == "SonRow")
                        {
                            DataRow dr = dt.NewRow();
                            for (int j = 1; j < dgv.ColumnCount; j++)
                            {
                                dr[dgv.Columns[j].Name] = dgv.Rows[i].Cells[j].FormattedValue;
                            }
                            dt.Rows.Add(dr);
                            CheckCount++;
                        }
                    }
                }
            }
            //判断是否勾选了明细
            if (CheckCount == 0)
            {
                return null;
            }
            return dt;
        }

        /// <summary>
        /// 设置只允许输入数字
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public static void NumOnly(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')//这是允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))//这是允许输入0-9数字
                {
                    e.Handled = true;
                }
            }
        }

        public static Dictionary<string, object> ToDictionary(string JsonData)
        {
            object Data = null;
            Dictionary<string, object> Dic = new Dictionary<string, object>();
            if (JsonData.StartsWith("["))
            {
                //如果目标直接就为数组类型，则将会直接输出一个Key为List的List<Dictionary<string, object>>集合 
                //使用示例List<Dictionary<string, object>> ListDic = (List<Dictionary<string, object>>)Dic["List"]; 
                List<Dictionary<string, object>> List = new List<Dictionary<string, object>>();
                MatchCollection ListMatch = Regex.Matches(JsonData, @"{[\s\S]+?}");//使用正则表达式匹配出JSON数组 
                foreach (Match ListItem in ListMatch)
                {
                    List.Add(ToDictionary(ListItem.ToString()));//递归调用 
                }
                Data = List;
                Dic.Add("List", Data);
            }
            else
            {
                MatchCollection Match = Regex.Matches(JsonData, @"""(.+?)"": {0,1}(\[[\s\S]+?\]|null|"".+?""|-{0,1}\d*)");//使用正则表达式匹配出JSON数据中的键与值 
                foreach (Match item in Match)
                {
                    try
                    {
                        if (item.Groups[2].ToString().StartsWith("["))
                        {
                            //如果目标是数组，将会输出一个Key为当前Json的List<Dictionary<string, object>>集合 
                            //使用示例List<Dictionary<string, object>> ListDic = (List<Dictionary<string, object>>)Dic["Json中的Key"]; 
                            List<Dictionary<string, object>> List = new List<Dictionary<string, object>>();
                            MatchCollection ListMatch = Regex.Matches(item.Groups[2].ToString(), @"{[\s\S]+?}");//使用正则表达式匹配出JSON数组 
                            foreach (Match ListItem in ListMatch)
                            {
                                List.Add(ToDictionary(ListItem.ToString()));//递归调用 
                            }
                            Data = List;
                        }
                        else if (item.Groups[2].ToString().ToLower() == "null") Data = null;//如果数据为null(字符串类型),直接转换成null
                        else Data = item.Groups[2].ToString(); //数据为数字、字符串中的一类，直接写入 
                        Dic.Add(item.Groups[1].ToString(), Data);
                    }
                    catch { }
                }
            }
            return Dic;
        }

        public static string AddField(string[] Fields)
        {
            string sql = " ";
            foreach (string field in Fields)
            {
                sql += field + ",";
            }
            return sql.Substring(0, sql.Length - 1);
        }
    }
}