linux-packaging-mono/mcs/class/referencesource/System.Web.DynamicData/DynamicData/FieldTemplateFactory.cs

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Data.Spatial;
using System.Diagnostics;
using System.Globalization;
using System.Web.Compilation;
using System.Web.Hosting;
using System.Web.UI.WebControls;

namespace System.Web.DynamicData {
    /// <summary>
    /// Default implementation of IFieldTemplateFactory. It uses user controls for the field templates.
    /// </summary>
    public class FieldTemplateFactory : IFieldTemplateFactory {
        private const string IntegerField = "Integer";
        private const string ForeignKeyField = "ForeignKey";
        private const string ChildrenField = "Children";
        private const string ManyToManyField = "ManyToMany";
        private const string EnumerationField = "Enumeration";

        private const string EditModePathModifier = "_Edit";
        private const string InsertModePathModifier = "_Insert";

        private Dictionary<Type, string> _typesToTemplateNames;
        private Dictionary<Type, Type> _typesFallBacks;

        private TemplateFactory _templateFactory;

        /// <summary>
        /// </summary>
        public FieldTemplateFactory() {
            InitTypesToTemplateNamesTable();
            BuildTypeFallbackTable();
            _templateFactory = new TemplateFactory("FieldTemplates");
        }

        // For unit test purpose
        internal FieldTemplateFactory(VirtualPathProvider vpp)
            : this() {
            _templateFactory.VirtualPathProvider = vpp;
        }

        /// <summary>
        /// Sets the folder containing the user controls. By default, this is ~/DynamicData/FieldTemplates/
        /// </summary>
        public string TemplateFolderVirtualPath {
            get {
                return _templateFactory.TemplateFolderVirtualPath;
            }
            set {
                _templateFactory.TemplateFolderVirtualPath = value;
            }
        }

        /// <summary>
        /// The MetaModel that the factory is associated with
        /// </summary>
        public MetaModel Model {
            get {
                return _templateFactory.Model;
            }
            private set {
                _templateFactory.Model = value;
            }
        }

        private void InitTypesToTemplateNamesTable() {
            _typesToTemplateNames = new Dictionary<Type, string>();
            _typesToTemplateNames[typeof(int)] = FieldTemplateFactory.IntegerField;
            _typesToTemplateNames[typeof(string)] = DataType.Text.ToString();
        }

        private void BuildTypeFallbackTable() {
            _typesFallBacks = new Dictionary<Type, Type>();
            _typesFallBacks[typeof(float)] = typeof(decimal);
            _typesFallBacks[typeof(double)] = typeof(decimal);
            _typesFallBacks[typeof(Int16)] = typeof(int);
            _typesFallBacks[typeof(byte)] = typeof(int);
            _typesFallBacks[typeof(long)] = typeof(int);

            // Fall back to strings for most types
            _typesFallBacks[typeof(char)] = typeof(string);
            _typesFallBacks[typeof(int)] = typeof(string);
            _typesFallBacks[typeof(decimal)] = typeof(string);
            _typesFallBacks[typeof(Guid)] = typeof(string);
            _typesFallBacks[typeof(DateTime)] = typeof(string);
            _typesFallBacks[typeof(DateTimeOffset)] = typeof(string);
            _typesFallBacks[typeof(TimeSpan)] = typeof(string);
            _typesFallBacks[typeof(DbGeography)] = typeof(string);
            _typesFallBacks[typeof(DbGeometry)] = typeof(string);

            // 
        }

        private Type GetFallBackType(Type t) {
            // Check if there is a fallback type
            Type fallbackType;
            if (_typesFallBacks.TryGetValue(t, out fallbackType))
                return fallbackType;

            return null;
        }

        // Internal for unit test purpose
        internal string GetFieldTemplateVirtualPathWithCaching(MetaColumn column, DataBoundControlMode mode, string uiHint) {
            // Compute a cache key based on all the input paramaters
            long cacheKey = Misc.CombineHashCodes(uiHint, column, mode);

            Func<string> templatePathFactoryFunction = () => GetFieldTemplateVirtualPath(column, mode, uiHint);

            return _templateFactory.GetTemplatePath(cacheKey, templatePathFactoryFunction);
        }

        /// <summary>
        /// Returns the virtual path of the field template user control to be used, based on various pieces of data
        /// </summary>
        /// <param name="column">The MetaColumn for which the field template is needed</param>
        /// <param name="mode">The mode (Readonly, Edit, Insert) for which the field template is needed</param>
        /// <param name="uiHint">The UIHint (if any) that should affect the field template lookup</param>
        /// <returns></returns>
        public virtual string GetFieldTemplateVirtualPath(MetaColumn column, DataBoundControlMode mode, string uiHint) {

            mode = PreprocessMode(column, mode);

            bool hasDataTypeAttribute = column != null && column.DataTypeAttribute != null;

            // Set the UIHint in some special cases, but don't do it if we already have one or
            // if we have a DataTypeAttribute
            if (String.IsNullOrEmpty(uiHint) && !hasDataTypeAttribute) {
                // Check if it's an association
                // Or if it is an enum
                if (column is MetaForeignKeyColumn) {
                    uiHint = FieldTemplateFactory.ForeignKeyField;
                } else if (column is MetaChildrenColumn) {
                    var childrenColumn = (MetaChildrenColumn)column;
                    if (childrenColumn.IsManyToMany) {
                        uiHint = FieldTemplateFactory.ManyToManyField;
                    }
                    else {
                        uiHint = FieldTemplateFactory.ChildrenField;
                    }
                } else if (column.ColumnType.IsEnum) {
                    uiHint = FieldTemplateFactory.EnumerationField;
                }
            }

            return GetVirtualPathWithModeFallback(uiHint, column, mode);
        }

        /// <summary>
        /// Gets a chance to change the mode.  e.g. an Edit mode request can be turned into ReadOnly mode
        /// if the column is a primary key
        /// </summary>
        public virtual DataBoundControlMode PreprocessMode(MetaColumn column, DataBoundControlMode mode) {
            if (column == null) {
                throw new ArgumentNullException("column");
            }

            // Primary keys can't be edited, so put them in readonly mode.  Note that this
            // does not apply to Insert mode, which is fine
            if (column.IsPrimaryKey && mode == DataBoundControlMode.Edit) {
                mode = DataBoundControlMode.ReadOnly;
            }

            // Generated columns should never be editable/insertable
            if (column.IsGenerated) {
                mode = DataBoundControlMode.ReadOnly;
            }

            // ReadOnly columns cannot be edited nor inserted, and are always in Display mode
            if (column.IsReadOnly) {
                if (mode == DataBoundControlMode.Insert && column.AllowInitialValue) {
                    // but don't change the mode if we're in insert and an initial value is allowed
                } else {
                    mode = DataBoundControlMode.ReadOnly;
                }
            }

            // If initial value is not allowed set mode to ReadOnly
            if (mode == DataBoundControlMode.Insert && !column.AllowInitialValue) {
                mode = DataBoundControlMode.ReadOnly;
            }

            if (column is MetaForeignKeyColumn) {
                // If the foreign key is part of the primary key (e.g. Order and Product in Order_Details table),
                // change the mode to ReadOnly so that they can't be edited.
                if (mode == DataBoundControlMode.Edit && ((MetaForeignKeyColumn)column).IsPrimaryKeyInThisTable) {
                    mode = DataBoundControlMode.ReadOnly;
                }
            }

            return mode;
        }

        private string GetVirtualPathWithModeFallback(string templateName, MetaColumn column, DataBoundControlMode mode) {
            // Try not only the requested mode, but others if needed.  Basically:
            // - an edit template can default to an item template
            // - an insert template can default to an edit template, then to an item template
            for (var currentMode = mode; currentMode >= 0; currentMode--) {
                string virtualPath = GetVirtualPathForMode(templateName, column, currentMode);
                if (virtualPath != null)
                    return virtualPath;
            }

            // We couldn't locate any field template at all, so give up
            return null;
        }

        private string GetVirtualPathForMode(string templateName, MetaColumn column, DataBoundControlMode mode) {

            // If we got a template name, try it
            if (!String.IsNullOrEmpty(templateName)) {
                string virtualPath = GetVirtualPathIfExists(templateName, column, mode);
                if (virtualPath != null)
                    return virtualPath;
            }

            // Otherwise, use the column's type
            return GetVirtualPathForTypeWithFallback(column.ColumnType, column, mode);
        }

        private string GetVirtualPathForTypeWithFallback(Type fieldType, MetaColumn column, DataBoundControlMode mode) {

            string templateName;
            string virtualPath;

            // If we have a data type attribute
            if (column.DataTypeAttribute != null) {
                templateName = column.DataTypeAttribute.GetDataTypeName();

                // Try to get the path from it
                virtualPath = GetVirtualPathIfExists(templateName, column, mode);
                if (virtualPath != null)
                    return virtualPath;
            }

            // Try the actual fully qualified type name (i.e. with the namespace)
            virtualPath = GetVirtualPathIfExists(fieldType.FullName, column, mode);
            if (virtualPath != null)
                return virtualPath;

            // Try the simple type name
            virtualPath = GetVirtualPathIfExists(fieldType.Name, column, mode);
            if (virtualPath != null)
                return virtualPath;

            // If our type name table has an entry for it, try it
            if (_typesToTemplateNames.TryGetValue(fieldType, out templateName)) {
                virtualPath = GetVirtualPathIfExists(templateName, column, mode);
                if (virtualPath != null)
                    return virtualPath;
            }

            // Check if there is a fallback type
            Type fallbackType = GetFallBackType(fieldType);

            // If not, we've run out of options
            if (fallbackType == null)
                return null;

            // If so, try it
            return GetVirtualPathForTypeWithFallback(fallbackType, column, mode);
        }

        private string GetVirtualPathIfExists(string templateName, MetaColumn column, DataBoundControlMode mode) {
            // Build the path
            string virtualPath = BuildVirtualPath(templateName, column, mode);

            // Check if it exists
            if (_templateFactory.FileExists(virtualPath))
                return virtualPath;

            // If not, return null
            return null;
        }

        /// <summary>
        /// Build the virtual path to the field template user control based on the template name and mode.
        /// By default, it returns names that look like TemplateName_ModeName.ascx, in the folder specified
        /// by TemplateFolderVirtualPath.
        /// </summary>
        /// <param name="templateName"></param>
        /// <param name="column"></param>
        /// <param name="mode"></param>
        /// <returns></returns>
        public virtual string BuildVirtualPath(string templateName, MetaColumn column, DataBoundControlMode mode) {
            if (String.IsNullOrEmpty(templateName)) {
                throw new ArgumentNullException("templateName");
            }

            string modePathModifier = null;
            switch (mode) {
                case DataBoundControlMode.ReadOnly:
                    modePathModifier = String.Empty;
                    break;
                case DataBoundControlMode.Edit:
                    modePathModifier = FieldTemplateFactory.EditModePathModifier;
                    break;
                case DataBoundControlMode.Insert:
                    modePathModifier = FieldTemplateFactory.InsertModePathModifier;
                    break;
                default:
                    Debug.Assert(false);
                    break;
            }

            return String.Format(CultureInfo.InvariantCulture,
                TemplateFolderVirtualPath + "{0}{1}.ascx", templateName, modePathModifier);
        }

        #region IFieldTemplateFactory Members

        public virtual void Initialize(MetaModel model) {
            Model = model;
        }

        /// <summary>
        /// See IFieldTemplateFactory for details.
        /// </summary>
        /// <returns></returns>
        public virtual IFieldTemplate CreateFieldTemplate(MetaColumn column, DataBoundControlMode mode, string uiHint) {
            string fieldTemplatePath = GetFieldTemplateVirtualPathWithCaching(column, mode, uiHint);

            if (fieldTemplatePath == null)
                return null;

            return (IFieldTemplate)BuildManager.CreateInstanceFromVirtualPath(
                fieldTemplatePath, typeof(IFieldTemplate));
        }

        #endregion
    }
}