Radarr/Marr.Data/DataHelper.cs

/*  Copyright (C) 2008 - 2011 Jordan Marr

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>. */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Reflection;
using Marr.Data.Mapping;
using System.Linq.Expressions;

namespace Marr.Data
{
    /// <summary>
    /// This class contains misc. extension methods that are used throughout the project.
    /// </summary>
    internal static class DataHelper
    {
        public static bool HasColumn(this IDataReader dr, string columnName) 
        { 
            for (int i=0; i < dr.FieldCount; i++) 
            { 
                if (dr.GetName(i).Equals(columnName, StringComparison.InvariantCultureIgnoreCase)) 
                    return true; 
            } 
            return false; 
        }

        public static string ParameterPrefix(this IDbCommand command)
        {
            string commandType = command.GetType().Name.ToLower();
            return commandType.Contains("oracle") ? ":" : "@";
        }
        
        /// <summary>
        /// Returns the mapped name, or the member name.
        /// </summary>
        /// <param name="member"></param>
        /// <returns></returns>
        public static string GetTableName(this MemberInfo member)
        {
            string tableName = MapRepository.Instance.GetTableName(member.DeclaringType);
            return tableName ?? member.DeclaringType.Name;
        }

        public static string GetTableName(this Type memberType)
        {
            return MapRepository.Instance.GetTableName(memberType);
        }

        public static string GetColumName(this IColumnInfo col, bool useAltName)
        {
            if (useAltName)
            {
                return col.TryGetAltName();
            }
            else
            {
                return col.Name;
            }
        }

        /// <summary>
        /// Returns the mapped column name, or the member name.
        /// </summary>
        /// <param name="member"></param>
        /// <returns></returns>
        public static string GetColumnName(Type declaringType, string propertyName, bool useAltName)
        {
            // Initialize column name as member name
            string columnName = propertyName;

            var columnMap = MapRepository.Instance.GetColumns(declaringType).GetByFieldName(propertyName);

            if (columnMap == null)
            {
                throw new InvalidOperationException(string.Format("Column map missing for field {0}.{1}", declaringType.FullName, propertyName));
            }

            if (useAltName)
            {
                columnName = columnMap.ColumnInfo.TryGetAltName();
            }
            else
            {
                columnName = columnMap.ColumnInfo.Name;
            }

            return columnName;
        }

        /// <summary>
        /// Determines a property name from a passed in expression.
        /// Ex:  p => p.FirstName   ->    "FirstName
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="member"></param>
        /// <returns></returns>
        public static string GetMemberName<T>(this Expression<Func<T, object>> member)
        {
            var memberExpression = (member.Body as MemberExpression);
            if (memberExpression == null)
            {
                memberExpression = (member.Body as UnaryExpression).Operand as MemberExpression;
            }

            return memberExpression.Member.Name;
        }

        public static string GetMemberName(this LambdaExpression exp)
        {
            var memberExpression = (exp.Body as MemberExpression);
            if (memberExpression == null)
            {
                memberExpression = (exp.Body as UnaryExpression).Operand as MemberExpression;
            }

            return memberExpression.Member.Name;
        }

        public static bool ContainsMember(this List<MemberInfo> list, MemberInfo member)
        {
            foreach (var m in list)
            {
                if (m.EqualsMember(member))
                    return true;
            }

            return false;
        }

        public static bool EqualsMember(this MemberInfo member, MemberInfo otherMember)
        {
            return member.Name == otherMember.Name && member.DeclaringType == otherMember.DeclaringType;
        }

        /// <summary>
        /// Determines if a type is not a complex object.
        /// </summary>
        public static bool IsSimpleType(Type type)
        {
            Type underlyingType = !IsNullableType(type) ? type : type.GetGenericArguments()[0];

            return
                underlyingType.IsPrimitive ||
                underlyingType.Equals(typeof(string)) ||
                underlyingType.Equals(typeof(DateTime)) ||
                underlyingType.Equals(typeof(decimal)) ||
                underlyingType.IsEnum;
        }

        public static bool IsNullableType(Type theType)
        {
            return (theType.IsGenericType && theType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)));
        }

    }
}