Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.DynamicData/DynamicData/EntityTemplateFactory.cs

@@ -0,0 +1,129 @@
+using System.Diagnostics;
+using System.Globalization;
+using System.Web.Compilation;
+using System.Web.Hosting;
+using System.Web.UI.WebControls;
+
+namespace System.Web.DynamicData {
+    public class EntityTemplateFactory {
+        private const string s_defaultTemplateName = "Default";
+        
+        private TemplateFactory _factory;
+        private Func<string, EntityTemplateUserControl> _templateInstantiator;
+
+        public EntityTemplateFactory()
+            : this(CreateEntityTemplateInstance, /* trackChanges */ true) {
+        }
+
+        // for unit testing
+        internal EntityTemplateFactory(Func<string, EntityTemplateUserControl> templateInstantiator, VirtualPathProvider vpp)
+            : this(templateInstantiator, /* trackChanges */ false) {
+            _factory.VirtualPathProvider = vpp;
+        }
+
+        private EntityTemplateFactory(Func<string, EntityTemplateUserControl> templateInstantiator, bool trackChanges) {
+            _factory = new TemplateFactory("EntityTemplates", trackChanges);
+            _templateInstantiator = templateInstantiator;
+        }
+
+        internal string TemplateFolderVirtualPath {
+            get {
+                return _factory.TemplateFolderVirtualPath;
+            }
+            set {
+                _factory.TemplateFolderVirtualPath = value;
+            }
+        }
+
+        private static EntityTemplateUserControl CreateEntityTemplateInstance(string path) {
+            return (EntityTemplateUserControl)BuildManager.CreateInstanceFromVirtualPath(
+                    path, typeof(EntityTemplateUserControl));
+        }
+
+        public virtual EntityTemplateUserControl CreateEntityTemplate(MetaTable table, DataBoundControlMode mode, string uiHint) {
+            if (table == null) {
+                throw new ArgumentNullException("table");
+            }
+
+            string entityTemplatePath = GetEntityTemplateVirtualPathWithCaching(table, mode, uiHint);
+            if (entityTemplatePath == null) {
+                return null;
+            }
+
+            return _templateInstantiator(entityTemplatePath);
+        }
+
+        private string GetEntityTemplateVirtualPathWithCaching(MetaTable table, DataBoundControlMode mode, string uiHint) {
+            long cacheKey = Misc.CombineHashCodes(table, mode, uiHint);
+
+            return _factory.GetTemplatePath(cacheKey, delegate() {
+                return GetEntityTemplateVirtualPath(table, mode, uiHint);
+            });
+        }
+
+        public virtual string GetEntityTemplateVirtualPath(MetaTable table, DataBoundControlMode mode, string uiHint) {
+            if (table == null) {
+                throw new ArgumentNullException("table");
+            }
+
+            // Fallback order is as follows (where CustomProducts is the uiHint)
+            //    CustomProducts_Insert
+            //    CustomProducts_Edit
+            //    Products_Insert
+            //    Products_Edit
+            //    Default_Insert
+            //    Default_Edit
+            //    CustomProducts_ReadOnly
+            //    Products_ReadOnly
+            //    Default_ReadOnly
+            //
+            // If nothing matches null is returned
+
+            return GetVirtualPathFallback(table, mode, uiHint, DataBoundControlMode.Edit) ??
+                GetVirtualPathFallback(table, DataBoundControlMode.ReadOnly, uiHint, DataBoundControlMode.ReadOnly);
+        }
+
+        private string GetVirtualPathFallback(MetaTable table, DataBoundControlMode mode, string uiHint, DataBoundControlMode minModeToFallBack) {
+            if (mode < minModeToFallBack) {
+                return null;
+            }
+
+            // the strategy is to go over each candidate name and try to find an existing template for
+            // each mode between 'mode' and 'minModeToFallBack'
+            // note that GetVirtualPathForMode will return null for empty names (e.g. when the uiHint is not specified)
+            string[] fallbackNames = new string[] { uiHint, table.Name, s_defaultTemplateName };
+            foreach (var name in fallbackNames) {
+                for (var currentMode = mode; currentMode >= minModeToFallBack; currentMode--) {
+                    string virtualPath = GetVirtualPathForMode(name, currentMode);
+                    if (virtualPath != null) {
+                        return virtualPath;
+                    }
+                }
+            }
+            return null;
+        }
+
+        private string GetVirtualPathForMode(string candidateName, DataBoundControlMode mode) {
+            if (String.IsNullOrEmpty(candidateName)) {
+                return null;
+            } else {
+                string templatePath = BuildEntityTemplateVirtualPath(candidateName, mode);
+                return _factory.FileExists(templatePath) ? templatePath : null;
+            }
+        }
+
+        public virtual string BuildEntityTemplateVirtualPath(string templateName, DataBoundControlMode mode) {
+            if (templateName == null) {
+                throw new ArgumentNullException("templateName");
+            }
+
+            string modeString = mode == DataBoundControlMode.ReadOnly ? String.Empty : "_" + mode.ToString();
+            return String.Format(CultureInfo.InvariantCulture, this.TemplateFolderVirtualPath + "{0}{1}.ascx", templateName, modeString);
+        }
+
+        internal void Initialize(MetaModel model) {
+            Debug.Assert(model != null);
+            _factory.Model = model;
+        }
+    }
+}