Radarr/Marr.Data/Mapping/MapBuilder.cs

using System;
using System.Linq;
using Marr.Data.Mapping.Strategies;
using System.Reflection;
using System.Collections;

namespace Marr.Data.Mapping
{
    [Obsolete("This class is obsolete.  Please use the 'Mappings' class.")]
    public class MapBuilder
    {
        private bool _publicOnly;

        public MapBuilder()
            : this(true)
        { }

        public MapBuilder(bool publicOnly)
        {
            _publicOnly = publicOnly;
        }

        #region - Columns -

        /// <summary>
        /// Creates column mappings for the given type.
        /// Maps all properties except ICollection properties.
        /// </summary>
        /// <typeparam name="T">The type that is being built.</typeparam>
        /// <returns><see cref="ColumnMapCollection"/></returns>
        public ColumnMapBuilder<T> BuildColumns<T>()
        {
            return BuildColumns<T>(m => m.MemberType == MemberTypes.Property &&
                !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
        }

        /// <summary>
        /// Creates column mappings for the given type.
        /// Maps all properties that are simple types (int, string, DateTime, etc).  
        /// ICollection properties are not included.
        /// </summary>
        /// <typeparam name="T">The type that is being built.</typeparam>
        /// <returns><see cref="ColumnMapCollection"/></returns>
        public ColumnMapBuilder<T> BuildColumnsFromSimpleTypes<T>()
        {
            return BuildColumns<T>(m => m.MemberType == MemberTypes.Property &&
                DataHelper.IsSimpleType((m as PropertyInfo).PropertyType) &&
                !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
        }

        /// <summary>
        /// Creates column mappings for the given type.  
        /// Maps properties that are included in the include list.
        /// </summary>
        /// <typeparam name="T">The type that is being built.</typeparam>
        /// <param name="propertiesToInclude"></param>
        /// <returns><see cref="ColumnMapCollection"/></returns>
        public ColumnMapBuilder<T> BuildColumns<T>(params string[] propertiesToInclude)
        {
            return BuildColumns<T>(m =>
                m.MemberType == MemberTypes.Property &&
                propertiesToInclude.Contains(m.Name));
        }

        /// <summary>
        /// Creates column mappings for the given type.
        /// Maps all properties except the ones in the exclusion list.
        /// </summary>
        /// <typeparam name="T">The type that is being built.</typeparam>
        /// <param name="propertiesToExclude"></param>
        /// <returns><see cref="ColumnMapCollection"/></returns>
        public ColumnMapBuilder<T> BuildColumnsExcept<T>(params string[] propertiesToExclude)
        {
            return BuildColumns<T>(m => 
                m.MemberType == MemberTypes.Property &&
                !propertiesToExclude.Contains(m.Name));
        }

        /// <summary>
        /// Creates column mappings for the given type if they match the predicate.
        /// </summary>
        /// <typeparam name="T">The type that is being built.</typeparam>
        /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param>
        /// <returns><see cref="ColumnMapConfigurator"/></returns>
        public ColumnMapBuilder<T> BuildColumns<T>(Func<MemberInfo, bool> predicate)
        {
            Type entityType = typeof(T);
            ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
            strategy.ColumnPredicate = predicate;
            ColumnMapCollection columns = strategy.MapColumns(entityType);
            MapRepository.Instance.Columns[entityType] = columns;
            return new ColumnMapBuilder<T>(null, columns);
        }

        /// <summary>
        /// Creates a ColumnMapBuilder that starts out with no pre-populated columns.
        /// All columns must be added manually using the builder.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public ColumnMapBuilder<T> Columns<T>()
        {
            Type entityType = typeof(T);
            ColumnMapCollection columns = new ColumnMapCollection();
            MapRepository.Instance.Columns[entityType] = columns;
            return new ColumnMapBuilder<T>(null, columns);
        }
        
        #endregion

        #region - Relationships -

        /// <summary>
        /// Creates relationship mappings for the given type.
        /// Maps all properties that implement ICollection.
        /// </summary>
        /// <typeparam name="T">The type that is being built.</typeparam>
        /// <returns><see cref="RelationshipBuilder"/></returns>
        public RelationshipBuilder<T> BuildRelationships<T>()
        {
            return BuildRelationships<T>(m => 
                m.MemberType == MemberTypes.Property && 
                typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType));
        }

        /// <summary>
        /// Creates relationship mappings for the given type.
        /// Maps all properties that are listed in the include list.
        /// </summary>
        /// <typeparam name="T">The type that is being built.</typeparam>
        /// <param name="propertiesToInclude"></param>
        /// <returns><see cref="RelationshipBuilder"/></returns>
        public RelationshipBuilder<T> BuildRelationships<T>(params string[] propertiesToInclude)
        {
            Func<MemberInfo, bool> predicate = m => 
                (
                    // ICollection properties
                    m.MemberType == MemberTypes.Property && 
                    typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType) &&
                    propertiesToInclude.Contains(m.Name)
                ) || ( // Single entity properties
                    m.MemberType == MemberTypes.Property &&
                    !typeof(ICollection).IsAssignableFrom((m as PropertyInfo).PropertyType) &&
                    propertiesToInclude.Contains(m.Name)
                );
            
            return BuildRelationships<T>(predicate);
        }

        /// <summary>
        /// Creates relationship mappings for the given type if they match the predicate.
        /// </summary>
        /// <typeparam name="T">The type that is being built.</typeparam>
        /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param>
        /// <returns><see cref="RelationshipBuilder"/></returns>
        public RelationshipBuilder<T> BuildRelationships<T>(Func<MemberInfo, bool> predicate)
        {
            Type entityType = typeof(T);
            ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly);
            strategy.RelationshipPredicate = predicate;
            RelationshipCollection relationships = strategy.MapRelationships(entityType);
            MapRepository.Instance.Relationships[entityType] = relationships;
            return new RelationshipBuilder<T>(null, relationships);
        }

        /// <summary>
        /// Creates a RelationshipBuilder that starts out with no pre-populated relationships.
        /// All relationships must be added manually using the builder.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public RelationshipBuilder<T> Relationships<T>()
        {
            Type entityType = typeof(T);
            RelationshipCollection relationships = new RelationshipCollection();
            MapRepository.Instance.Relationships[entityType] = relationships;
            return new RelationshipBuilder<T>(null, relationships);
        }
        
        #endregion

        #region - Tables -

        /// <summary>
        /// Provides a fluent table mapping interface.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public TableBuilder<T> BuildTable<T>()
        {
            return new TableBuilder<T>(null);
        }

        /// <summary>
        /// Sets the table name for a given type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tableName"></param>
        public TableBuilder<T> BuildTable<T>(string tableName)
        {
            return new TableBuilder<T>(null).SetTableName(tableName);
        }

        #endregion
    }
}