MES_Client/TGMES/Core.StlMes.Client.YdmStuffManage/改判显示工艺/Dal.cs

using Core.Mes.Client.Comm.Tool;
using CoreFS.CA06;
using CoreFS.SA06;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Core.StlMes.Client.YdmStuffManage
{
    public class Dal
    {
        private OpeBase _ob = null;

        public OpeBase Ob
        {
            get { return _ob; }
            set { _ob = value; }
        }

        public Dal(OpeBase ob)
        {
            _ob = ob;
        }

        public DataTable GetTable(string remoteStr, params object[] param)
        {
            CoreClientParam ccp = new CoreClientParam();
            ccp.ServerName = remoteStr.Substring(0, remoteStr.LastIndexOf("."));
            ccp.MethodName = remoteStr.Substring(remoteStr.LastIndexOf(".") + 1);
            ccp.ServerParams = param;
            ccp = _ob.ExecuteSortResultByQueryToDataTable(ccp, CoreInvokeType.Internal);
            DataTable src = ccp.SourceDataTable;

            foreach (DataColumn col in src.Columns)
            {
               col.ColumnName = GetLanguageFormat(col.ColumnName, true);
            }

            return src;
        }

        /// <summary>
        /// 直接通过服务端xmlId获取数据
        /// </summary>
        /// <param name="xmlId"></param>
        /// <param name="parms"></param>
        /// <returns></returns>
        public DataTable GetTableByXmlId(string xmlId, params object[] parms)
        {
            CoreClientParam ccp = new CoreClientParam();
            ccp.ServerName = "Core.LgMes.Server.Common.ClientQueryHelper";
            ccp.MethodName = "query";
            ccp.ServerParams = new object[]{ xmlId, parms };
            ccp = _ob.ExecuteSortResultByQueryToDataTable(ccp, CoreInvokeType.Internal);
            DataTable src = ccp.SourceDataTable;

            if (src != null) 
            {
                foreach (DataColumn col in src.Columns)
                {
                    col.ColumnName = GetLanguageFormat(col.ColumnName, true);
                }
            }

            return src;
        }

        public CoreClientParam Set(string remoteStr, params object[] param)
        {
            CoreClientParam ccp = new CoreClientParam();
            ccp.IfShowErrMsg = false;
            ccp.ServerName = remoteStr.Substring(0, remoteStr.LastIndexOf("."));
            ccp.MethodName = remoteStr.Substring(remoteStr.LastIndexOf(".") + 1);
            ccp.ServerParams = param;
            ccp = _ob.ExecuteNonQuery(ccp, CoreInvokeType.Internal);

            return ccp;
        }

        /// <summary>
        /// 直接通过服务端xmlId获取数据
        /// </summary>
        /// <param name="methodName"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public DataRow GetRow(string remoteStr, params object[] param)
        {
            DataTable dt = GetTable(remoteStr, param);
            if(dt.Rows.Count == 0)
            {
                return null;
            }
            else
            {
                return dt.Rows[0];
            }
        }

        public DataRow GetRowByXmlId(string xmlId, params object[] parms)
        {
            DataTable dt = GetTableByXmlId(xmlId, parms);
            if (dt.Rows.Count == 0)
            {
                return null;
            }
            else
            {
                return dt.Rows[0];
            }
        }

        private string GetLanguageFormat(string strName, bool isLowerBegin)
        {
            string[] strs = strName.Split('_');
            strName = "";
            for (int i = 0; i < strs.Length; i++)
            {
                if (i == 0 && isLowerBegin)
                {
                    strName += strs[i].ToLower();
                }
                else
                {
                    strName += strs[i].Substring(0, 1).ToUpper() + strs[i].Substring(1).ToLower();
                }
            }
            return strName;
        }

        public DataSourceList<T> GetEntitysByXmlId<T>(string xmlId, params object[] parms)
        {
            return GetEntitys<T>("Core.LgMes.Server.Common.ClientQueryHelper.query", new object[] { xmlId, parms });
        }

        public DataSourceList<T> GetEntitys<T>(string remoteStr, params object[] parms)
        {
            string key = "";
            try
            {
                DataSourceList<T> listResult = new DataSourceList<T>();

                CoreClientParam ccp = new CoreClientParam();
                ccp.ServerName = remoteStr.Substring(0, remoteStr.LastIndexOf("."));
                ccp.MethodName = remoteStr.Substring(remoteStr.LastIndexOf(".") + 1);
                ccp.ServerParams = parms;
                ccp = _ob.ExecuteQuery(ccp, CoreInvokeType.Internal);
                string[] strColumns = (ccp.ReturnObject as CoreReturnSortObject).getColIdx();
                string[] strColumnsEntity = ConvertColumnName(strColumns);
                ArrayList list = (ccp.ReturnObject as CoreReturnSortObject).getResult();

                Type type = typeof(T);
                Dictionary<string, PropertyInfo> propertyInfoDic = new Dictionary<string, PropertyInfo>();
                for (int j = 0; j < strColumns.Length; j++)
                {
                    string column = strColumns[j];
                    string columnEntity = strColumnsEntity[j];
                    PropertyInfo propertyInfo = type.GetProperty(columnEntity);
                    if (propertyInfo == null) continue;
                    if (propertyInfoDic.ContainsKey(column))
                    {
                        propertyInfoDic[column] = propertyInfo;
                    }
                    else
                    {
                        propertyInfoDic.Add(column, propertyInfo);
                    }
                }


                for (int i = 0; i < list.Count; i++)
                {
                    Hashtable hashtable = (Hashtable)list[i];
                    ArrayList list2 = new ArrayList();
                    T obj = (T)type.Assembly.CreateInstance(type.FullName);
                    foreach (KeyValuePair<string, PropertyInfo> propertyInfoKV in propertyInfoDic)
                    {
                        key = propertyInfoKV.Key;
                        object obj2 = hashtable[propertyInfoKV.Key];
                        PropertyInfo propertyInfo = propertyInfoKV.Value;
                        if ((obj2 != null) && typeof(Hashtable).Equals(obj2.GetType()))
                        {
                            Hashtable hashtable2 = (Hashtable)obj2;
                            propertyInfo.SetValue(obj, ConvertDataType(propertyInfo.PropertyType, hashtable2["value"]), null);
                        }
                        else
                        {
                            propertyInfo.SetValue(obj, ConvertDataType(propertyInfo.PropertyType, obj2), null);
                        }
                    }
                    listResult.Add(obj);
                }

                return listResult;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {

            }
        }

        private static object ConvertDataType(Type type, object objValue)
        {
            if (type == typeof(bool))
            {
                bool result;
                if (bool.TryParse(objValue.ToString(), out result))
                {
                    return result;
                }
                else
                {
                    return false;
                }
            }
            else if (type == typeof(bool?))
            {
                bool result;
                if (bool.TryParse(objValue.ToString(), out result))
                {
                    return result;
                }
                else
                {
                    return null;
                }
            }
            else if (type == typeof(int?))
            {
                if (objValue == null)
                {
                    return null;
                }
                else
                {
                    return int.Parse(objValue.ToString());
                }
            }
            else if (type == typeof(long?))
            {
                if (objValue == null)
                {
                    return null;
                }
                else
                {
                    return long.Parse(objValue.ToString());
                }
            }
            else if (type == typeof(short?))
            {
                if (objValue == null)
                {
                    return null;
                }
                else
                {
                    return short.Parse(objValue.ToString());
                }
            }
            else if (type == typeof(float?))
            {
                if (objValue == null)
                {
                    return null;
                }
                else
                {
                    return float.Parse(objValue.ToString());
                }
            }
            else if (type == typeof(double?))
            {
                if (objValue == null)
                {
                    return null;
                }
                else
                {
                    return double.Parse(objValue.ToString());
                }
            }
            else if (type == typeof(decimal?))
            {
                if (objValue == null)
                {
                    return null;
                }
                else
                {
                    return decimal.Parse(objValue.ToString());
                }
            }
            else if (type == typeof(DateTime?))
            {
                if (objValue == null)
                {
                    return null;
                }
                else
                {
                    return DateTime.Parse(objValue.ToString());
                }
            }
            else
            {
                return objValue == null ? "" : objValue.ToString();
            }
        }

        private string[] ConvertColumnName(string[] strColumns)
        {
            string[] strs = new string[strColumns.Length];
            for (int i = 0; i < strColumns.Length; i++)
            {
                strs[i] = GetLanguageFormat(strColumns[i], false);
            }

            return strs;
        }
    }
}