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