private static object ChangeValueType(MetaColumn column, string value) {
if (column.ColumnType == typeof(Guid)) {
return new Guid(value);
} else {
return Convert.ChangeType(value, column.TypeCode, CultureInfo.InvariantCulture);
}
}
//-------------------------------------------------------------------------------------------
public static Boolean IsShown(MetaColumn column)
{
// need to get the current page template
var page = (System.Web.UI.Page)System.Web.HttpContext.Current.CurrentHandler;
var pageTemplate = page.GetPageTemplate();
var hideIn = column.GetAttribute<HideColumnInAttribute>();
if (hideIn != null && (hideIn.PageTemplates.Contains(pageTemplate)))
return false;
var hideIfFiltered = column.GetAttribute<HideIfFiltered>();
if (hideIfFiltered != null &&
(System.Web.HttpContext.Current.Request[column.Name] != null ||
(hideIfFiltered.FilterName != null &&
System.Web.HttpContext.Current.Request[hideIfFiltered.FilterName] != null))
)
return false;
var securedColumns = column.GetColumnPermissions(System.Web.Security.Roles.GetRolesForUser());
if (securedColumns.Contains(ColumnActions.DenyRead))
return false;
//foreach (var secureColumn in securedColumns)
//{
// if (securedColumn
//}
return true;
}
public static SimpleFieldTemplateUserControl CreateTextTemplate(MetaColumn column, bool readOnly) {
SimpleFieldTemplateUserControl control = new SimpleFieldTemplateUserControl();
if (readOnly) {
var literal = new Literal();
literal.DataBinding += (sender, e) => {
literal.Text = control.FieldValueString;
};
control.Controls.Add(literal);
}
else {
var textBox = new TextBox();
textBox.DataBinding += (sender, e) => {
textBox.Text = control.FieldValueEditString;
};
// Logic copied from BoundField
if (column.ColumnType.IsPrimitive) {
textBox.Columns = 5;
}
control._valueExtrator = () => textBox.Text;
textBox.CssClass = "DDTextBox";
textBox.ID = TextBoxID;
control.Controls.Add(textBox);
control.CreateValidators(column);
}
return control;
}
public override IFieldTemplate CreateFieldTemplate(MetaColumn column, DataBoundControlMode mode, string uiHint)
{
if (column.IsReadOnly)// code to fix caching issue
mode = DataBoundControlMode.ReadOnly;
return base.CreateFieldTemplate(column, mode, uiHint);
}
private bool IncludeField(MetaColumn column, DataBoundControlMode mode) {
// Exclude bool columns in Insert mode (just to test custom filtering)
if (mode == DataBoundControlMode.Insert && column.ColumnType == typeof(bool))
return false;
return true;
}
private IFieldTemplate CreateFieldTemplate(bool readOnly, MetaColumn column) {
// By default we'll support checkbox fields for boolean and a textbox for
// everything else
if (column.ColumnType == typeof(bool)) {
return SimpleFieldTemplateUserControl.CreateBooleanTemplate(readOnly);
}
return SimpleFieldTemplateUserControl.CreateTextTemplate(column, readOnly);
}
// internal for unit testing
internal string GetFilterVirtualPathWithCaching(MetaColumn column, string filterUIHint) {
Debug.Assert(column != null);
long cacheKey = Misc.CombineHashCodes(column, filterUIHint);
return _templateFactory.GetTemplatePath(cacheKey, delegate() {
return GetFilterVirtualPath(column, filterUIHint);
});
}
//-------------------------------------------------------------------------------------------
public static Boolean IsAuthorized(MetaColumn column)
{
var securedColumns = column.GetColumnPermissions(System.Web.Security.Roles.GetRolesForUser());
if (securedColumns.Contains(ColumnActions.DenyRead))
return false;
return true;
}
protected override void OnLoad(EventArgs e) {
foreach (MetaColumn column in Table.GetScaffoldColumns(Mode, ContainerType)) {
currentColumn = column;
Control item = new DefaultEntityTemplate._NamingContainer();
EntityTemplate1.ItemTemplate.InstantiateIn(item);
EntityTemplate1.Controls.Add(item);
}
}
internal static void SetParameterTypeCodeAndDbType(Parameter parameter, MetaColumn column) {
// If it's a Guid, use a DbType, since TypeCode doesn't support it. For everything else, use TypeCode
if (column.ColumnType == typeof(Guid)) {
parameter.DbType = DbType.Guid;
}
else {
parameter.Type = column.TypeCode;
}
}
public virtual string GetFilterVirtualPath(MetaColumn column, string filterUIHint) {
if (column == null) {
throw new ArgumentNullException("column");
}
string filterControlName = BuildFilterVirtualPath(column, filterUIHint);
string filterTemplatePath = VirtualPathUtility.Combine(FilterFolderVirtualPath, filterControlName + ".ascx");
return filterTemplatePath;
}
private static Boolean IsHidden(MetaColumn column)
{
var browsable = column.Attributes.OfType<BrowsableAttribute>().SingleOrDefault();
if (browsable == null)
{
return false;
}
return !browsable.Browsable;
}
public virtual QueryableFilterUserControl CreateFilterControl(MetaColumn column, string filterUIHint) {
if (column == null) {
throw new ArgumentNullException("column");
}
string filterTemplatePath = GetFilterVirtualPathWithCaching(column, filterUIHint);
Debug.Assert(filterTemplatePath != null);
QueryableFilterUserControl filter = (QueryableFilterUserControl)BuildManager.CreateInstanceFromVirtualPath(
filterTemplatePath, typeof(QueryableFilterUserControl));
return filter;
}
protected virtual DynamicField CreateField(MetaColumn column, ContainerType containerType, DataBoundControlMode mode) {
string headerText = (containerType == ContainerType.List ? column.ShortDisplayName : column.DisplayName);
var field = new DynamicField() {
DataField = column.Name,
HeaderText = headerText
};
// Turn wrapping off by default so that error messages don't show up on the next line.
field.ItemStyle.Wrap = false;
return field;
}
private string GetDefaultFilterControlName(MetaColumn column) {
if (column is MetaForeignKeyColumn) {
return s_foreignKeyFilter;
}
else if (column.ColumnType == typeof(bool)) {
return s_booleanFilter;
}
else if (column.GetEnumType() != null) {
return s_enumerationFilter;
}
else {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.DynamicDataResources.FilterFactory_ColumnHasNoDefaultFilter,
column.Name,
column.Table.Name));
}
}
/// <summary>
/// Get the value of a specific column in the current row
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
protected virtual object GetColumnValue(MetaColumn column)
{
object row = Row;
if (row != null)
{
return(DataBinder.GetPropertyValue(row, column.Name));
}
// Fallback on old behavior
if (Mode == DataBoundControlMode.Insert)
{
return(column.DefaultValue);
}
return(null);
}
public bool TryGetColumn(string columnName, out MetaColumn column)
{
if (columnName == null)
{
throw new ArgumentNullException("columnName");
}
foreach (var m in Columns)
{
if (m.Name == columnName)
{
column = m;
return(true);
}
}
column = null;
return(false);
}
MetaColumn FindSortColumn()
{
if (sortColumnChecked)
{
return(sortColumn);
}
sortColumnChecked = true;
DisplayColumnAttribute attr = Attributes [typeof(DisplayColumnAttribute)] as DisplayColumnAttribute;
if (attr == null)
{
return(null);
}
string name = attr.SortColumn;
if (String.IsNullOrEmpty(name))
{
return(null);
}
MetaColumn ret = null;
Exception exception = null;
try {
ret = Columns.First <MetaColumn> ((MetaColumn mc) => {
if (String.Compare(mc.Name, name, StringComparison.Ordinal) == 0)
{
return(true);
}
return(false);
});
} catch (Exception ex) {
exception = ex;
}
if (ret == null)
{
throw new InvalidOperationException("The sort column '" + name + "' specified for table '" + Name + "' does not exist.", exception);
}
return(ret);
}
string GetExistingTemplateVirtualPath(string baseName, MetaColumn column, DataBoundControlMode mode)
{
string templatePath = BuildVirtualPath(baseName, column, mode);
if (String.IsNullOrEmpty(templatePath))
{
return(null);
}
// TODO: cache positive hits (and watch for removal events on those)
string physicalPath = HostingEnvironment.MapPath(templatePath);
if (File.Exists(physicalPath))
{
return(templatePath);
}
return(null);
}
public override IFieldTemplate CreateFieldTemplate(MetaColumn column, DataBoundControlMode mode, string uiHint) {
// Call Preprocess mode so that we do set the right mode base on the the column's attributes
mode = PreprocessMode(column, mode);
bool readOnly = (mode == DataBoundControlMode.ReadOnly);
// If the folder doesn't exist use the fallback
if (!DirectoryExists) {
return CreateFieldTemplate(readOnly, column);
}
// Always see check if the base found anything first then fall back to the simple field template
IFieldTemplate fieldTemplate = base.CreateFieldTemplate(column, mode, uiHint);
// If there was no field template found and the user specified a uiHint then use the default behavior
if (!String.IsNullOrEmpty(uiHint)) {
return fieldTemplate;
}
return fieldTemplate ?? CreateFieldTemplate(readOnly, column);
}
internal void CreateColumns()
{
var columns = new List <MetaColumn>();
_columnsByName = new Dictionary <string, MetaColumn>(StringComparer.OrdinalIgnoreCase);
foreach (ColumnProvider columnProvider in Provider.Columns)
{
MetaColumn column = CreateColumnInternal(columnProvider);
columns.Add(column);
if (_columnsByName.ContainsKey(column.Name))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, DynamicDataResources.MetaTable_ColumnNameConflict,
column.Name, Provider.Name));
}
_columnsByName.Add(column.Name, column);
}
Columns = new ReadOnlyCollection <MetaColumn>(columns);
}
private void SetUpRangeValidator(RangeValidator validator, MetaColumn column)
{
// Nothing to do if no range was specified
var rangeAttribute = column.Attributes.OfType <RangeAttribute>().FirstOrDefault();
if (rangeAttribute == null)
{
return;
}
// Make sure the attribute doesn't get validated a second time by the DynamicValidator
IgnoreModelValidationAttribute(rangeAttribute.GetType());
validator.Enabled = true;
Func <object, string> converter;
switch (validator.Type)
{
case ValidationDataType.Integer:
converter = val => Convert.ToInt32(val, CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture);
break;
case ValidationDataType.Double:
converter = val => Convert.ToDouble(val, CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture);
break;
case ValidationDataType.String:
default:
converter = val => val.ToString();
break;
}
validator.MinimumValue = converter(rangeAttribute.Minimum);
validator.MaximumValue = converter(rangeAttribute.Maximum);
if (String.IsNullOrEmpty(validator.ErrorMessage))
{
validator.ErrorMessage = HttpUtility.HtmlEncode(
StringLocalizerUtil.GetLocalizedString(rangeAttribute, column.DisplayName));
}
}
private MetaColumn GetDisplayColumnFromMetadata()
{
var displayColumnAttribute = Metadata.DisplayColumnAttribute;
if (displayColumnAttribute == null)
{
return(null);
}
MetaColumn displayColumn = null;
if (!TryGetColumn(displayColumnAttribute.DisplayColumn, out displayColumn))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.MetaTable_CantFindDisplayColumn,
displayColumnAttribute.DisplayColumn,
Name));
}
return(displayColumn);
}
private void SetUpRegexValidator(RegularExpressionValidator validator, MetaColumn column)
{
// Nothing to do if no regex was specified
var regexAttribute = column.Attributes.OfType <RegularExpressionAttribute>().FirstOrDefault();
if (regexAttribute == null)
{
return;
}
// Make sure the attribute doesn't get validated a second time by the DynamicValidator
IgnoreModelValidationAttribute(regexAttribute.GetType());
validator.Enabled = true;
validator.ValidationExpression = regexAttribute.Pattern;
if (String.IsNullOrEmpty(validator.ErrorMessage))
{
validator.ErrorMessage = HttpUtility.HtmlEncode(regexAttribute.FormatErrorMessage(column.DisplayName));
}
}
private string GetDefaultFilterControlName(MetaColumn column)
{
if (column is MetaForeignKeyColumn)
{
return(s_foreignKeyFilter);
}
else if (column.ColumnType == typeof(bool))
{
return(s_booleanFilter);
}
else if (column.GetEnumType() != null)
{
return(s_enumerationFilter);
}
else
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.DynamicDataResources.FilterFactory_ColumnHasNoDefaultFilter,
column.Name,
column.Table.Name));
}
}
public override IFieldTemplate CreateFieldTemplate(MetaColumn column, DataBoundControlMode mode, string uiHint)
{
// Call Preprocess mode so that we do set the right mode base on the the column's attributes
mode = PreprocessMode(column, mode);
bool readOnly = (mode == DataBoundControlMode.ReadOnly);
// If the folder doesn't exist use the fallback
if (!DirectoryExists)
{
return(CreateFieldTemplate(readOnly, column));
}
// Always see check if the base found anything first then fall back to the simple field template
IFieldTemplate fieldTemplate = base.CreateFieldTemplate(column, mode, uiHint);
// If there was no field template found and the user specified a uiHint then use the default behavior
if (!String.IsNullOrEmpty(uiHint))
{
return(fieldTemplate);
}
return(fieldTemplate ?? CreateFieldTemplate(readOnly, column));
}
/// <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));
}
internal static bool IsFilterableColumn(MetaColumn column)
{
if (!column.Scaffold)
{
return(false);
}
if (column.IsCustomProperty)
{
return(false);
}
if (column is MetaForeignKeyColumn)
{
return(true);
}
if (column.ColumnType == typeof(bool))
{
return(true);
}
return(false);
}
public virtual DataBoundControlMode PreprocessMode(MetaColumn column, DataBoundControlMode mode)
{
// In good tradition of .NET's DynamicData, let's not check the
// parameters...
if (column == null)
{
throw new NullReferenceException();
}
if (column.IsGenerated)
{
return(DataBoundControlMode.ReadOnly);
}
if (column.IsPrimaryKey)
{
if (mode == DataBoundControlMode.Edit)
{
return(DataBoundControlMode.ReadOnly);
}
}
return(mode);
}
private IEnumerable <Parameter> GetForeignKeyControlWhereParameters(Control control,
IControlParameterTarget paramTarget, MetaForeignKeyColumn column)
{
MetaTable parentTable = paramTarget.Table;
if (parentTable != null)
{
string namePrefix = String.Empty;
// Make sure the data types match
if (column.ColumnType != parentTable.EntityType)
{
throw new Exception(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.DynamicControlParameter_DynamicDataSourceColumnNotCompatibleWithTable,
column.DisplayName, parentTable.Name));
}
// For each underlying FK, we need to create a ControlParameter
Debug.Assert(column.ForeignKeyNames.Count == parentTable.PrimaryKeyColumns.Count);
int index = 0;
foreach (var fkName in column.ForeignKeyNames)
{
MetaColumn parentTablePKColumn = parentTable.PrimaryKeyColumns[index++];
var controlParameter = new ControlParameter()
{
Name = fkName,
ControlID = control.UniqueID,
PropertyName = paramTarget.GetPropertyNameExpression(parentTablePKColumn.Name)
};
DataSourceUtil.SetParameterTypeCodeAndDbType(controlParameter, parentTablePKColumn);
yield return(controlParameter);
}
}
}
// internal for unit testing
internal static QueryableFilterUserControl CreateUserControl(MetaColumn column, string filterUiHint)
{
return(column.Model.FilterFactory.CreateFilterControl(column, filterUiHint));
}
private static BinaryExpression BuildWhereBodyFragment(ParameterExpression parameter, MetaColumn column, string value) {
// row.ID
var property = Expression.Property(parameter, column.Name);
// row.ID == 1
return Expression.Equal(property, Expression.Constant(ChangeValueType(column, value)));
}
internal static bool IsEnumType(this MetaColumn column, out Type enumType)
{
enumType = column.GetEnumType();
return(enumType != null);
}
public static Type GetEnumType(this MetaColumn column)
{
return(GetEnumType((IMetaColumn)column));
}
string GetExistingTemplateVirtualPath (string baseName, MetaColumn column, DataBoundControlMode mode)
{
string templatePath = BuildVirtualPath (baseName, column, mode);
if (String.IsNullOrEmpty (templatePath))
return null;
// TODO: cache positive hits (and watch for removal events on those)
string physicalPath = HostingEnvironment.MapPath (templatePath);
if (File.Exists (physicalPath))
return templatePath;
return null;
}
string GetTemplateForDataType(DataType dataType, string customDataType, string uiHint, MetaColumn column, DataBoundControlMode mode)
{
switch (dataType)
{
case DataType.Custom:
return(GetExistingTemplateVirtualPath(customDataType, column, mode));
case DataType.DateTime:
return(GetExistingTemplateVirtualPath("DateTime", column, mode));
case DataType.MultilineText:
return(GetExistingTemplateVirtualPath("MultilineText", column, mode));
default:
return(GetExistingTemplateVirtualPath("Text", column, mode));
}
}
// This method create's validators for a particular column type. This should be as close to the the actual FieldTemplates (user controls) as possible.
// DateTime -> Required, Regex
// Integer -> Regex, Required, Range, Compare
// Decimal -> Regex, Required, Range, Compare
// Text -> Regex, Required
// Enum -> Required
private void CreateValidators(MetaColumn column) {
if (_validators == null) {
_validators = new List<BaseValidator>();
}
// Exclude regular expression validator for enum columns
if (column.GetEnumType() == null) {
RegularExpressionValidator regularExpressionValidator = new RegularExpressionValidator {
ControlToValidate = TextBoxID,
Enabled = false,
Display = ValidatorDisplay.Static,
CssClass = "DDControl DDValidator"
};
_validators.Add(regularExpressionValidator);
}
if (column.IsInteger || column.ColumnType == typeof(decimal) || column.ColumnType == typeof(double) || column.ColumnType == typeof(float)) {
RangeValidator rangeValidator = new RangeValidator {
ControlToValidate = TextBoxID,
Enabled = false,
Display = ValidatorDisplay.Static,
MinimumValue = "0",
MaximumValue = "100",
CssClass = "DDControl DDValidator",
Type = column.IsInteger ? ValidationDataType.Integer : ValidationDataType.Double
};
_validators.Add(rangeValidator);
CompareValidator compareValidator = new CompareValidator {
ControlToValidate = TextBoxID,
Enabled = false,
Display = ValidatorDisplay.Static,
Operator = ValidationCompareOperator.DataTypeCheck,
CssClass = "DDControl DDValidator",
Type = column.IsInteger ? ValidationDataType.Integer : ValidationDataType.Double
};
_validators.Add(compareValidator);
}
RequiredFieldValidator requiredFieldValidator = new RequiredFieldValidator {
ControlToValidate = TextBoxID,
Enabled = false,
CssClass = "DDControl DDValidator",
Display = ValidatorDisplay.Static
};
_validators.Add(requiredFieldValidator);
DynamicValidator dynamicValidator = new DynamicValidator {
ControlToValidate = TextBoxID,
CssClass = "DDControl DDValidator",
Display = ValidatorDisplay.Static
};
_validators.Add(dynamicValidator);
}
internal MetaTable(MetaModel model, TableProvider provider, ContextConfiguration configuration)
{
bool scaffoldAllTables;
this.model = model;
Provider = provider;
if (configuration != null)
{
ScaffoldAllTables = scaffoldAllTables = configuration.ScaffoldAllTables;
Func <Type, TypeDescriptionProvider> factory = configuration.MetadataProviderFactory;
if (factory != null)
{
Type t = EntityType;
TypeDescriptionProvider p = factory(t);
if (p != null)
{
TypeDescriptor.AddProvider(p, t);
}
}
}
else
{
scaffoldAllTables = false;
}
ScaffoldTableAttribute attr = null;
MetaModel.GetDataFieldAttribute <ScaffoldTableAttribute> (Attributes, ref attr);
Scaffold = attr != null ? attr.Scaffold : scaffoldAllTables;
DataContextType = provider.DataModel.ContextType;
var columns = new List <MetaColumn> ();
var primaryKeyColumns = new List <MetaColumn> ();
var foreignKeyColumnNames = new List <string> ();
MetaColumn mc;
foreach (var c in provider.Columns)
{
// this seems to be the determining factor on whether we create
// MetaColumn or MetaForeignKeyColumn/MetaChildrenColumn. As the
// determination depends upon the relationship direction, we must
// check that using the ColumnProvider's association, if any.
//
// http://msdn.microsoft.com/en-us/library/system.web.dynamicdata.metaforeignkeycolumn.aspx
// http://msdn.microsoft.com/en-us/library/system.web.dynamicdata.metachildrencolumn.aspx
// http://forums.asp.net/t/1426992.aspx
var association = c.Association;
if (association == null)
{
mc = new MetaColumn(this, c);
}
else
{
var dir = association.Direction;
if (dir == AssociationDirection.OneToOne || dir == AssociationDirection.ManyToOne)
{
mc = new MetaForeignKeyColumn(this, c);
}
else
{
mc = new MetaChildrenColumn(this, c);
}
}
columns.Add(mc);
if (c.IsPrimaryKey)
{
primaryKeyColumns.Add(mc);
}
if (mc is MetaForeignKeyColumn)
{
foreignKeyColumnNames.Add(c.Name);
}
}
Columns = new ReadOnlyCollection <MetaColumn> (columns);
PrimaryKeyColumns = new ReadOnlyCollection <MetaColumn> (primaryKeyColumns);
if (foreignKeyColumnNames.Count == 0)
{
ForeignKeyColumnsNames = String.Empty;
}
else
{
ForeignKeyColumnsNames = String.Join(",", foreignKeyColumnNames.ToArray());
}
HasPrimaryKey = primaryKeyColumns.Count > 0;
// See http://forums.asp.net/t/1388561.aspx
//
// Also, http://forums.asp.net/t/1307243.aspx - that seems to be out of
// scope for us, though (at least for now)
IsReadOnly = primaryKeyColumns.Count == 0;
// FIXME: fill more properties.
}
private void EnsureInit() {
if (_column != null)
return;
// make sure we have a DataField
if (String.IsNullOrEmpty(DataField)) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_MissingDataField,
ID));
}
MetaTable table = null;
if (!String.IsNullOrEmpty(ContextTypeName) || !String.IsNullOrEmpty(TableName)) {
// make sure both ContextTypeName and TableName are specified together
if (String.IsNullOrEmpty(ContextTypeName)) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_MissingContextTypeName,
ID));
}
if (String.IsNullOrEmpty(TableName)) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_MissingTableName,
ID));
}
Type contextType = GetContextType(ContextTypeName);
MetaModel model = null;
try {
model = MetaModel.GetModel(contextType);
} catch (InvalidOperationException e) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_UnknownContextType,
ID,
contextType.FullName), e);
}
string tableName = TableName;
try {
table = model.GetTable(tableName);
} catch (ArgumentException e) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_InvalidTableName,
ID,
tableName), e);
}
} else {
// get context information from request context
table = DynamicDataRouteHandler.GetRequestMetaTable(HttpContext.Current);
if (table == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_CantInferInformationFromRequestUrl,
ID));
}
}
try {
_column = table.GetColumn(DataField);
} catch (InvalidOperationException e) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_InvalidDataField,
ID,
DataField), e);
}
// create appropriate filter implementation based on column type
if (_column is MetaForeignKeyColumn) {
_filterDelegate = new ForeignKeyFilterDelegate(this);
} else if (_column.ColumnType == typeof(bool) && !_column.IsCustomProperty) {
_filterDelegate = new BooleanPropertyFilterDelegate(this);
} else {
_filterDelegate = new DefaultPropertyFilterDelegate(this);
}
}
//-------------------------------------------------------------------------------------------
protected override void OnLoad(EventArgs e)
{
IEnumerable<MetaColumn> columns = Table.GetScaffoldColumns(this.Mode, this.ContainerType);
List<string> Groups = new List<string>();
foreach (MetaColumn column in columns)
{
this.currentColumn = column;
var groupattribute = column.GetAttribute<ColumnGroupAttribute>();
HtmlGenericControl tabContent = (HtmlGenericControl)GeneralControls;
if (groupattribute != null)
{
string groupId = groupattribute.GroupName.Replace(" ", "_");
if (!Groups.Contains(groupId))
{
Groups.Add(groupId);
var div = new HtmlGenericControl("div");
div.ID = groupId;
Tabs.Controls.Add(div);
LiteralControl tab = new LiteralControl();
tab.Text = "<li><a href=\"#" + div.ClientID + "\">" + groupattribute.GroupName + "</a></li>";
tabheader.Controls.Add(tab);
}
tabContent = (HtmlGenericControl)Tabs.FindControl(groupId);
}
HtmlGenericControl cellLine = new HtmlGenericControl("div");
cellLine.Attributes["class"] = "formLine";
tabContent.Controls.Add(cellLine);
HtmlGenericControl cellLabel = new HtmlGenericControl("div");
cellLabel.Attributes["class"] = "formLabel";
cellLabel.InnerText = column.DisplayName + ":";
cellLine.Controls.Add(cellLabel);
HtmlGenericControl cellData = new HtmlGenericControl("div");
cellData.Attributes["class"] = "formData";
var dynamicControl = new DynamicControl()
{
Mode = Mode,
DataField = column.Name,
ValidationGroup = this.ValidationGroup
};
cellData.Controls.Add(dynamicControl);
cellLine.Controls.Add(cellData);
HtmlGenericControl br = new HtmlGenericControl("div");
br.Style["clear"] = "both";
br.Style["height"] = "1px";
cellLine.Controls.Add(br);
}
var clearDiv = new HtmlGenericControl("div");
clearDiv.InnerHtml = " ";
clearDiv.Style["clear"] = "both";
GeneralControls.Controls.Add(clearDiv);
//if (tabheader.Controls.Count == 1)
//{
// tabheader.Controls.Clear();
//}
//else
{
string script = "<script type='text/javascript'>$(document).ready(function () { $(\"#tableControl\").tabs(); });</script>";
ScriptManager.RegisterStartupScript(Page, GetType(), "TableControlInit", script, false);
}
}
public virtual string GetFieldTemplateVirtualPath(MetaColumn column, DataBoundControlMode mode, string uiHint)
{
// NO checks are made on parameters in .NET, but well "handle" the NREX
// throws in the other methods
DataBoundControlMode newMode = PreprocessMode(column, mode);
// The algorithm is as follows:
//
// 1. If column has a DataTypeAttribute on it, get the data type
// - if it's Custom data type, uiHint is used unconditionally
// - if it's not a custom type, ignore uiHint and choose template based
// on type
//
// 2. If #1 is false and uiHint is not empty, use uiHint if the template
// exists
//
// 3. If #2 is false, look up type according to the following algorithm:
//
// 1. lookup column type's full name
// 2. if #1 fails, look up short type name
// 3. if #2 fails, map type to special type name (Int -> Integer, String
// -> Text etc)
// 4. if #3 fails, try to find a fallback type
// 5. if #4 fails, check if it's a foreign key or child column
// 6. if #5 fails, return null
//
// From: http://msdn.microsoft.com/en-us/library/cc488523.aspx (augmented)
//
DataTypeAttribute attr = column.DataTypeAttribute;
bool uiHintPresent = !String.IsNullOrEmpty(uiHint);
string templatePath = null;
int step = uiHintPresent ? 0 : 1;
Type columnType = column.ColumnType;
if (!uiHintPresent && attr == null)
{
if (column is MetaChildrenColumn)
{
templatePath = GetExistingTemplateVirtualPath("Children", column, newMode);
}
else if (column is MetaForeignKeyColumn)
{
templatePath = GetExistingTemplateVirtualPath("ForeignKey", column, newMode);
}
}
while (step < 6 && templatePath == null)
{
switch (step)
{
case 0:
templatePath = GetExistingTemplateVirtualPath(uiHint, column, newMode);
break;
case 1:
if (attr != null)
{
templatePath = GetTemplateForDataType(attr.DataType, attr.GetDataTypeName(), uiHint, column, newMode);
}
break;
case 2:
templatePath = GetExistingTemplateVirtualPath(columnType.FullName, column, newMode);
break;
case 3:
templatePath = GetExistingTemplateVirtualPath(columnType.Name, column, newMode);
break;
case 4:
templatePath = ColumnTypeToSpecialName(columnType, column, newMode);
break;
case 5:
columnType = GetFallbackType(columnType, column, newMode);
if (columnType == null)
{
step = 5;
}
else
{
step = uiHintPresent ? 0 : 1;
}
break;
}
step++;
}
return(templatePath);
}
// This method create's validators for a particular column type. This should be as close to the the actual FieldTemplates (user controls) as possible.
// DateTime -> Required, Regex
// Integer -> Regex, Required, Range, Compare
// Decimal -> Regex, Required, Range, Compare
// Text -> Regex, Required
// Enum -> Required
private void CreateValidators(MetaColumn column)
{
if (_validators == null)
{
_validators = new List <BaseValidator>();
}
// Exclude regular expression validator for enum columns
if (column.GetEnumType() == null)
{
RegularExpressionValidator regularExpressionValidator = new RegularExpressionValidator {
ControlToValidate = TextBoxID,
Enabled = false,
Display = ValidatorDisplay.Static,
CssClass = "DDControl DDValidator"
};
_validators.Add(regularExpressionValidator);
}
if (column.IsInteger || column.ColumnType == typeof(decimal) || column.ColumnType == typeof(double) || column.ColumnType == typeof(float))
{
RangeValidator rangeValidator = new RangeValidator {
ControlToValidate = TextBoxID,
Enabled = false,
Display = ValidatorDisplay.Static,
MinimumValue = "0",
MaximumValue = "100",
CssClass = "DDControl DDValidator",
Type = column.IsInteger ? ValidationDataType.Integer : ValidationDataType.Double
};
_validators.Add(rangeValidator);
CompareValidator compareValidator = new CompareValidator {
ControlToValidate = TextBoxID,
Enabled = false,
Display = ValidatorDisplay.Static,
Operator = ValidationCompareOperator.DataTypeCheck,
CssClass = "DDControl DDValidator",
Type = column.IsInteger ? ValidationDataType.Integer : ValidationDataType.Double
};
_validators.Add(compareValidator);
}
RequiredFieldValidator requiredFieldValidator = new RequiredFieldValidator {
ControlToValidate = TextBoxID,
Enabled = false,
CssClass = "DDControl DDValidator",
Display = ValidatorDisplay.Static
};
_validators.Add(requiredFieldValidator);
DynamicValidator dynamicValidator = new DynamicValidator {
ControlToValidate = TextBoxID,
CssClass = "DDControl DDValidator",
Display = ValidatorDisplay.Static
};
_validators.Add(dynamicValidator);
}
public virtual string BuildVirtualPath (string templateName, MetaColumn column, DataBoundControlMode mode)
{
// Tests show the 'column' parameter is not used here
if (String.IsNullOrEmpty (templateName))
throw new ArgumentNullException ("templateName");
string basePath = TemplateFolderVirtualPath;
string suffix;
switch (mode) {
default:
case DataBoundControlMode.ReadOnly:
suffix = String.Empty;
break;
case DataBoundControlMode.Edit:
suffix = "_Edit";
break;
case DataBoundControlMode.Insert:
suffix = "_Insert";
break;
}
return basePath + templateName + suffix + ".ascx";
}
private void EnsureInit()
{
if (_column != null)
{
return;
}
// make sure we have a DataField
if (String.IsNullOrEmpty(DataField))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_MissingDataField,
ID));
}
MetaTable table = null;
if (!String.IsNullOrEmpty(ContextTypeName) || !String.IsNullOrEmpty(TableName))
{
// make sure both ContextTypeName and TableName are specified together
if (String.IsNullOrEmpty(ContextTypeName))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_MissingContextTypeName,
ID));
}
if (String.IsNullOrEmpty(TableName))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_MissingTableName,
ID));
}
Type contextType = GetContextType(ContextTypeName);
MetaModel model = null;
try {
model = MetaModel.GetModel(contextType);
} catch (InvalidOperationException e) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_UnknownContextType,
ID,
contextType.FullName), e);
}
string tableName = TableName;
try {
table = model.GetTable(tableName);
} catch (ArgumentException e) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_InvalidTableName,
ID,
tableName), e);
}
}
else
{
// get context information from request context
table = DynamicDataRouteHandler.GetRequestMetaTable(HttpContext.Current);
if (table == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_CantInferInformationFromRequestUrl,
ID));
}
}
try {
_column = table.GetColumn(DataField);
} catch (InvalidOperationException e) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.FilterUserControlBase_InvalidDataField,
ID,
DataField), e);
}
// create appropriate filter implementation based on column type
if (_column is MetaForeignKeyColumn)
{
_filterDelegate = new ForeignKeyFilterDelegate(this);
}
else if (_column.ColumnType == typeof(bool) && !_column.IsCustomProperty)
{
_filterDelegate = new BooleanPropertyFilterDelegate(this);
}
else
{
_filterDelegate = new DefaultPropertyFilterDelegate(this);
}
}
public virtual DataBoundControlMode PreprocessMode (MetaColumn column, DataBoundControlMode mode)
{
// In good tradition of .NET's DynamicData, let's not check the
// parameters...
if (column == null)
throw new NullReferenceException ();
if (column.IsGenerated)
return DataBoundControlMode.ReadOnly;
if (column.IsPrimaryKey) {
if (mode == DataBoundControlMode.Edit)
return DataBoundControlMode.ReadOnly;
}
return mode;
}
internal void Initialize(MetaColumn column, IQueryableDataSource iQueryableDataSource, HttpContextBase context)
{
QueryableDataSource = iQueryableDataSource;
Column = column;
_context = context ?? new HttpContextWrapper(Context);
}
private IEnumerable <Parameter> GetPropertyControlWhereParameters(Control control,
IControlParameterTarget paramTarget, MetaColumn column)
{
ControlParameter controlParameter = new ControlParameter()
{
Name = column.Name,
ControlID = control.UniqueID,
PropertyName = paramTarget.GetPropertyNameExpression(column.Name)
};
DataSourceUtil.SetParameterTypeCodeAndDbType(controlParameter, column);
yield return(controlParameter);
}
/// <summary>
/// See IWhereParametersProvider.GetWhereParameters
/// </summary>
public virtual IEnumerable <Parameter> GetWhereParameters(IDynamicDataSource dataSource)
{
Debug.Assert(dataSource != null);
// Find the control that the ControlParameter uses
Control control = Misc.FindControl((Control)dataSource, ControlId);
if (control == null)
{
throw new InvalidOperationException(String.Format(
CultureInfo.CurrentCulture, DynamicDataResources.DynamicControlParameter_DynamicDataSourceControlNotFound, ControlId));
}
// If the control is itself a parameter provider, delegate to it
var whereParametersProvider = control as IWhereParametersProvider;
if (whereParametersProvider != null)
{
return(whereParametersProvider.GetWhereParameters(dataSource));
}
IControlParameterTarget paramTarget = DynamicDataManager.GetControlParameterTarget(control);
if (paramTarget == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.DynamicControlParameter_DynamicDataSourceControlCannotBeUsedAsParent, ControlId));
}
string columnName = Name;
MetaColumn column = null;
MetaTable table = MetaTableHelper.GetTableWithFullFallback(dataSource, HttpContext.Current.ToWrapper());
if (!String.IsNullOrEmpty(columnName))
{
column = table.GetColumn(columnName);
}
else
{
// There was no Name attribute telling us what field to filter, but maybe
// the control given us data has that info
column = paramTarget.FilteredColumn;
}
if (column == null)
{
// If there is no specific column, we're setting the primary key
if (paramTarget.Table != table)
{
throw new Exception(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.DynamicControlParameter_InvalidPK,
ControlId, paramTarget.Table, table.Name));
}
return(GetPrimaryKeyControlWhereParameters(control, paramTarget));
}
else if (column is MetaForeignKeyColumn)
{
return(GetForeignKeyControlWhereParameters(control, paramTarget, (MetaForeignKeyColumn)column));
}
return(GetPropertyControlWhereParameters(control, paramTarget, column));
}
// Dynamic field titles based on entity + column
public static string DynamicFieldTitle(this HtmlHelper html, object entity, MetaColumn column)
{
return column.DisplayName;
}
internal static bool IsFilterableColumn(MetaColumn column) {
if (!column.Scaffold) return false;
if (column.IsCustomProperty) return false;
if (column is MetaForeignKeyColumn) return true;
if (column.ColumnType == typeof(bool)) return true;
return false;
}
string GetTemplateForDataType (DataType dataType, string customDataType, string uiHint, MetaColumn column, DataBoundControlMode mode)
{
switch (dataType) {
case DataType.Custom:
return GetExistingTemplateVirtualPath (customDataType, column, mode);
case DataType.DateTime:
return GetExistingTemplateVirtualPath ("DateTime", column, mode);
case DataType.MultilineText:
return GetExistingTemplateVirtualPath ("MultilineText", column, mode);
default:
return GetExistingTemplateVirtualPath ("Text", column, mode);
}
}
private string BuildFilterVirtualPath(MetaColumn column, string filterUIHint) {
string filterControlName = null;
if (!String.IsNullOrEmpty(filterUIHint)) {
filterControlName = filterUIHint;
}
else if (!String.IsNullOrEmpty(column.FilterUIHint)) {
filterControlName = column.FilterUIHint;
}
filterControlName = filterControlName ?? GetDefaultFilterControlName(column);
return filterControlName;
}
protected virtual void SetUpValidator(BaseValidator validator, MetaColumn column)
{
throw new NotImplementedException();
}
// Dynamic field errors based on entity + column
public static string DynamicFieldErrors(this HtmlHelper html, object entity, MetaColumn column) {
return DynamicFieldErrors(html, entity, column.Name);
}
protected virtual object GetColumnValue(MetaColumn column)
{
throw new NotImplementedException();
}
private IEnumerable<Parameter> GetPropertyControlWhereParameters(Control control,
IControlParameterTarget paramTarget, MetaColumn column) {
ControlParameter controlParameter = new ControlParameter() {
Name = column.Name,
ControlID = control.UniqueID,
PropertyName = paramTarget.GetPropertyNameExpression(column.Name)
};
DataSourceUtil.SetParameterTypeCodeAndDbType(controlParameter, column);
yield return controlParameter;
}
string ColumnTypeToSpecialName (Type columnType, MetaColumn column, DataBoundControlMode mode)
{
if (columnType == typeof (int))
return GetExistingTemplateVirtualPath ("Integer", column, mode);
if (columnType == typeof (string))
return GetExistingTemplateVirtualPath ("Text", column, mode);
return null;
}
