Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

334 lines
14 KiB
C#

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
}
}