You've already forked linux-packaging-mono
708 lines
24 KiB
C#
708 lines
24 KiB
C#
using System.ComponentModel;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Data.Spatial;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Web.DynamicData.ModelProviders;
|
|
using System.Web.DynamicData.Util;
|
|
|
|
namespace System.Web.DynamicData {
|
|
/// <summary>
|
|
/// Object that represents a database column used by dynamic data
|
|
/// </summary>
|
|
public class MetaColumn : IFieldFormattingOptions, IMetaColumn {
|
|
private TypeCode _typeCode = TypeCode.Empty;
|
|
private Type _type;
|
|
private object _metadataCacheLock = new object();
|
|
|
|
// text, ntext, varchar(max), nvarchar(max) all have different maximum lengths so this is a minimum value
|
|
// that ensures that all of the abovementioned columns get treated as long strings.
|
|
private static readonly int s_longStringLengthCutoff = ((Int32.MaxValue >> 1) - 4);
|
|
|
|
// Metadata related members
|
|
private IMetaColumnMetadata _metadata;
|
|
private bool? _scaffoldValueManual;
|
|
private bool? _scaffoldValueDefault;
|
|
|
|
public MetaColumn(MetaTable table, ColumnProvider columnProvider) {
|
|
Table = table;
|
|
Provider = columnProvider;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The collection of metadata attributes that apply to this column
|
|
/// </summary>
|
|
public AttributeCollection Attributes {
|
|
get {
|
|
return Metadata.Attributes;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The CLR type of the property/column
|
|
/// </summary>
|
|
public Type ColumnType {
|
|
get {
|
|
if (_type == null) {
|
|
// If it's an Nullable<T>, work with T instead
|
|
_type = Misc.RemoveNullableFromType(Provider.ColumnType);
|
|
}
|
|
|
|
return _type;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The DataTypeAttribute used for the column
|
|
/// </summary>
|
|
public DataTypeAttribute DataTypeAttribute {
|
|
get {
|
|
return Metadata.DataTypeAttribute;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This column's defalut value. It is typically used to populate the field when creating a new entry.
|
|
/// </summary>
|
|
public object DefaultValue {
|
|
get {
|
|
return Metadata.DefaultValue;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A description for this column
|
|
/// </summary>
|
|
public virtual string Description {
|
|
get {
|
|
//
|
|
return Metadata.Description;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A friendly display name for this column
|
|
/// </summary>
|
|
public virtual string DisplayName {
|
|
get {
|
|
// Default to the Name if there is no DisplayName
|
|
return Metadata.DisplayName ?? Name;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The PropertyInfo of the property that represents this column on the entity type
|
|
/// </summary>
|
|
public PropertyInfo EntityTypeProperty { get { return Provider.EntityTypeProperty; } }
|
|
|
|
/// <summary>
|
|
/// The FilterUIHint used for the column
|
|
/// </summary>
|
|
public string FilterUIHint {
|
|
get {
|
|
return Metadata.FilterUIHint;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does this column contain binary data
|
|
/// </summary>
|
|
public bool IsBinaryData {
|
|
get {
|
|
return ColumnType == typeof(byte[]);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// meant to indicate that a member is an extra property that was declared in a partial class
|
|
/// </summary>
|
|
public bool IsCustomProperty { get { return Provider.IsCustomProperty; } }
|
|
|
|
/// <summary>
|
|
/// Is this column a floating point type (float, double, decimal)
|
|
/// </summary>
|
|
public bool IsFloatingPoint {
|
|
get {
|
|
return ColumnType == typeof(float) || ColumnType == typeof(double) || ColumnType == typeof(decimal);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This is set for columns that are part of a foreign key. Note that it is NOT set for
|
|
/// the strongly typed entity ref columns (though those columns 'use' one or more columns
|
|
/// where IsForeignKeyComponent is set).
|
|
/// </summary>
|
|
public bool IsForeignKeyComponent {
|
|
get { return Provider.IsForeignKeyComponent; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is this column's value auto-generated in the database
|
|
/// </summary>
|
|
public bool IsGenerated { get { return Provider.IsGenerated; } }
|
|
|
|
/// <summary>
|
|
/// Is this column a integer
|
|
/// </summary>
|
|
public bool IsInteger {
|
|
get {
|
|
return ColumnType == typeof(byte) || ColumnType == typeof(short) || ColumnType == typeof(int) || ColumnType == typeof(long);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is this column a 'long' string. This is used to determine whether a textbox or textarea should be used.
|
|
/// </summary>
|
|
public bool IsLongString {
|
|
get {
|
|
return IsString && Provider.MaxLength >= s_longStringLengthCutoff;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is this column part if the table's primary key
|
|
/// </summary>
|
|
public bool IsPrimaryKey { get { return Provider.IsPrimaryKey; } }
|
|
|
|
/// <summary>
|
|
/// Is this a readonly column
|
|
/// </summary>
|
|
[SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
|
|
Justification = "Interface denotes existence of property, not used for security.")]
|
|
public virtual bool IsReadOnly {
|
|
get {
|
|
return Provider.IsReadOnly || Metadata.IsReadOnly ||
|
|
(Metadata.EditableAttribute != null && !Metadata.EditableAttribute.AllowEdit);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies if a read-only column (see IsReadOnly) allows for a value to be set on insert.
|
|
/// The default value is false when the column is read-only; true when the column is not read-only.
|
|
/// The default value can be override by using EditableAttribute (note that this will indicate that
|
|
/// the column is meant to be read only).
|
|
/// </summary>
|
|
public bool AllowInitialValue {
|
|
get {
|
|
if (IsGenerated) {
|
|
// always return false for generated columns, since that is a stronger statement.
|
|
return false;
|
|
}
|
|
|
|
return Metadata.EditableAttribute.GetPropertyValue(a => a.AllowInitialValue, !IsReadOnly);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does this column require a value
|
|
/// </summary>
|
|
public bool IsRequired {
|
|
get {
|
|
return Metadata.RequiredAttribute != null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is this column a string
|
|
/// </summary>
|
|
public bool IsString {
|
|
get {
|
|
return ColumnType == typeof(string);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The maximun length allowed for this column (applies to string columns)
|
|
/// </summary>
|
|
public int MaxLength {
|
|
get {
|
|
var stringLengthAttribute = Metadata.StringLengthAttribute;
|
|
return stringLengthAttribute != null ? stringLengthAttribute.MaximumLength : Provider.MaxLength;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The MetaModel that this column belongs to
|
|
/// </summary>
|
|
public MetaModel Model { get { return Table.Model; } }
|
|
|
|
/// <summary>
|
|
/// The column's name
|
|
/// </summary>
|
|
public string Name { get { return Provider.Name; } }
|
|
|
|
/// <summary>
|
|
/// A value that can be used as a watermark in UI bound to value represented by this column.
|
|
/// </summary>
|
|
public virtual string Prompt { get { return Metadata.Prompt; } }
|
|
|
|
/// <summary>
|
|
/// the abstraction provider object that was used to construct this metacolumn.
|
|
/// </summary>
|
|
public ColumnProvider Provider { get; private set; }
|
|
|
|
/// <summary>
|
|
/// The error message used if this column is required and it is set to empty
|
|
/// </summary>
|
|
public string RequiredErrorMessage {
|
|
get {
|
|
var requiredAttribute = Metadata.RequiredAttribute;
|
|
return requiredAttribute != null ?
|
|
StringLocalizerUtil.GetLocalizedString(requiredAttribute, DisplayName) : String.Empty;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is it a column that should be displayed (e.g. in a GridView's auto generate mode)
|
|
/// </summary>
|
|
[SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
|
|
Justification = "Interface denotes existence of property, not used for security.")]
|
|
public virtual bool Scaffold {
|
|
get {
|
|
// If the value was explicitely set, that always takes precedence
|
|
if (_scaffoldValueManual != null) {
|
|
return _scaffoldValueManual.Value;
|
|
}
|
|
|
|
// If there is a DisplayAttribute with an explicit value, always honor it
|
|
var displayAttribute = Metadata.DisplayAttribute;
|
|
if (displayAttribute != null && displayAttribute.GetAutoGenerateField().HasValue) {
|
|
return displayAttribute.GetAutoGenerateField().Value;
|
|
}
|
|
|
|
// If there is an explicit Scaffold attribute, always honor it
|
|
var scaffoldAttribute = Metadata.ScaffoldColumnAttribute;
|
|
if (scaffoldAttribute != null) {
|
|
return scaffoldAttribute.Scaffold;
|
|
}
|
|
|
|
if (_scaffoldValueDefault == null) {
|
|
_scaffoldValueDefault = ScaffoldNoCache;
|
|
}
|
|
|
|
return _scaffoldValueDefault.Value;
|
|
}
|
|
set {
|
|
_scaffoldValueManual = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Look at various pieces of data on the column to determine whether it's
|
|
/// Scaffold mode should be on. This only gets called once per column and the result
|
|
/// is cached
|
|
/// </summary>
|
|
internal virtual bool ScaffoldNoCache {
|
|
get {
|
|
// Any field with a UIHint should be included
|
|
if (!String.IsNullOrEmpty(UIHint)) return true;
|
|
|
|
// Skip columns that are part of a foreign key, since they are already 'covered' in the
|
|
// strongly typed foreign key column
|
|
if (IsForeignKeyComponent) return false;
|
|
|
|
// Skip generated columns, which are not typically interesting
|
|
if (IsGenerated) return false;
|
|
|
|
// Always include non-generated primary keys
|
|
if (IsPrimaryKey) return true;
|
|
|
|
// Skip custom properties
|
|
if (IsCustomProperty) return false;
|
|
|
|
// Include strings and characters
|
|
if (IsString) return true;
|
|
if (ColumnType == typeof(char)) return true;
|
|
|
|
// Include numbers
|
|
if (IsInteger) return true;
|
|
if (IsFloatingPoint) return true;
|
|
|
|
// Include date related columns
|
|
if (ColumnType == typeof(DateTime)) return true;
|
|
if (ColumnType == typeof(TimeSpan)) return true;
|
|
if (ColumnType == typeof(DateTimeOffset)) return true;
|
|
|
|
|
|
// Include bools
|
|
if (ColumnType == typeof(bool)) return true;
|
|
|
|
// Include enums
|
|
Type enumType;
|
|
if (this.IsEnumType(out enumType)) return true;
|
|
|
|
//Include spatial types
|
|
if (ColumnType == typeof(DbGeography)) return true;
|
|
if (ColumnType == typeof(DbGeometry)) return true;
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A friendly short display name for this column. Meant to be used in GridView and similar controls where there might be
|
|
/// limited column header space
|
|
/// </summary>
|
|
public virtual string ShortDisplayName {
|
|
get {
|
|
// Default to the DisplayName if there is no ShortDisplayName
|
|
return Metadata.ShortDisplayName ?? DisplayName;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The expression used to determine the sort order for this column
|
|
/// </summary>
|
|
public string SortExpression {
|
|
get {
|
|
return SortExpressionInternal;
|
|
}
|
|
}
|
|
|
|
internal virtual string SortExpressionInternal {
|
|
get {
|
|
return Provider.IsSortable ? Name : string.Empty;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The MetaTable that this column belongs to
|
|
/// </summary>
|
|
public MetaTable Table { get; private set; }
|
|
|
|
/// <summary>
|
|
/// The TypeCode of this column. It is derived from the ColumnType
|
|
/// </summary>
|
|
public TypeCode TypeCode {
|
|
get {
|
|
if (_typeCode == TypeCode.Empty) {
|
|
_typeCode = DataSourceUtil.TypeCodeFromType(ColumnType);
|
|
}
|
|
|
|
return _typeCode;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The UIHint used for the column
|
|
/// </summary>
|
|
[SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
|
|
Justification = "Interface denotes existence of property, not used for security.")]
|
|
public virtual string UIHint {
|
|
get {
|
|
return Metadata.UIHint;
|
|
}
|
|
}
|
|
|
|
#region IFieldFormattingOptions Members
|
|
|
|
/// <summary>
|
|
/// Same semantic as the same property on System.Web.UI.WebControls.BoundField
|
|
/// </summary>
|
|
public bool ApplyFormatInEditMode {
|
|
get {
|
|
return Metadata.ApplyFormatInEditMode;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Same semantic as the same property on System.Web.UI.WebControls.BoundField
|
|
/// </summary>
|
|
public bool ConvertEmptyStringToNull {
|
|
get {
|
|
return Metadata.ConvertEmptyStringToNull;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Same semantic as the same property on System.Web.UI.WebControls.BoundField
|
|
/// </summary>
|
|
public string DataFormatString {
|
|
get {
|
|
return Metadata.DataFormatString;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Same semantic as the same property on System.Web.UI.WebControls.BoundField
|
|
/// </summary>
|
|
public bool HtmlEncode {
|
|
get {
|
|
return Metadata.HtmlEncode;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Same semantic as the same property on System.Web.UI.WebControls.BoundField
|
|
/// </summary>
|
|
public string NullDisplayText {
|
|
get {
|
|
return Metadata.NullDisplayText;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Build the attribute collection, later made available through the Attributes property
|
|
/// </summary>
|
|
protected virtual AttributeCollection BuildAttributeCollection() {
|
|
return Provider.Attributes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Perform initialization logic for this column
|
|
/// </summary>
|
|
internal protected virtual void Initialize() { }
|
|
|
|
/// <summary>
|
|
/// Resets cached column metadata (i.e. information coming from attributes). The metadata cache will be rebuilt
|
|
/// the next time any metadata-derived information gets requested.
|
|
/// </summary>
|
|
public void ResetMetadata() {
|
|
_metadata = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shows the column name. Mostly for debugging purpose.
|
|
/// </summary>
|
|
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
|
|
public override string ToString() {
|
|
return GetType().Name + " " + Name;
|
|
}
|
|
|
|
internal IMetaColumnMetadata Metadata {
|
|
get {
|
|
// Use a local to avoid returning null if ResetMetadata is called
|
|
IMetaColumnMetadata metadata = _metadata;
|
|
if (metadata == null) {
|
|
metadata = new MetaColumnMetadata(this);
|
|
_metadata = metadata;
|
|
}
|
|
return metadata;
|
|
}
|
|
set {
|
|
// settable for unit testing
|
|
_metadata = value;
|
|
}
|
|
}
|
|
|
|
#region Metadata abstraction
|
|
|
|
internal interface IMetaColumnMetadata {
|
|
|
|
AttributeCollection Attributes { get; }
|
|
|
|
DisplayAttribute DisplayAttribute { get; }
|
|
|
|
bool ApplyFormatInEditMode { get; }
|
|
|
|
bool ConvertEmptyStringToNull { get; }
|
|
|
|
bool HtmlEncode { get; }
|
|
|
|
string DataFormatString { get; }
|
|
|
|
DataTypeAttribute DataTypeAttribute { get; }
|
|
|
|
object DefaultValue { get; }
|
|
|
|
string Description { get; }
|
|
|
|
string DisplayName { get; }
|
|
|
|
string FilterUIHint { get; }
|
|
|
|
string ShortDisplayName { get; }
|
|
|
|
string NullDisplayText { get; }
|
|
|
|
string Prompt { get; }
|
|
|
|
RequiredAttribute RequiredAttribute { get; }
|
|
|
|
ScaffoldColumnAttribute ScaffoldColumnAttribute { get; }
|
|
|
|
StringLengthAttribute StringLengthAttribute { get; }
|
|
|
|
string UIHint { get; }
|
|
|
|
bool IsReadOnly { get; }
|
|
|
|
EditableAttribute EditableAttribute { get; }
|
|
}
|
|
|
|
internal class MetaColumnMetadata : IMetaColumnMetadata {
|
|
private MetaColumn Column { get; set; }
|
|
|
|
public AttributeCollection Attributes { get; private set; }
|
|
|
|
public MetaColumnMetadata(MetaColumn column) {
|
|
Debug.Assert(column != null);
|
|
Column = column;
|
|
|
|
Attributes = Column.BuildAttributeCollection();
|
|
|
|
DisplayAttribute = Attributes.FirstOrDefault<DisplayAttribute>();
|
|
DataTypeAttribute = Attributes.FirstOrDefault<DataTypeAttribute>() ?? GetDefaultDataTypeAttribute();
|
|
DescriptionAttribute = Attributes.FirstOrDefault<DescriptionAttribute>();
|
|
DefaultValueAttribute = Attributes.FirstOrDefault<DefaultValueAttribute>();
|
|
DisplayNameAttribute = Attributes.FirstOrDefault<DisplayNameAttribute>();
|
|
RequiredAttribute = Attributes.FirstOrDefault<RequiredAttribute>();
|
|
ScaffoldColumnAttribute = Attributes.FirstOrDefault<ScaffoldColumnAttribute>();
|
|
StringLengthAttribute = Attributes.FirstOrDefault<StringLengthAttribute>();
|
|
|
|
UIHint = GetHint<UIHintAttribute>(a => a.PresentationLayer, a => a.UIHint);
|
|
FilterUIHint = GetHint<FilterUIHintAttribute>(a => a.PresentationLayer, a => a.FilterUIHint);
|
|
|
|
EditableAttribute = Attributes.FirstOrDefault<EditableAttribute>();
|
|
IsReadOnly = Attributes.GetAttributePropertyValue<ReadOnlyAttribute, bool>(a => a.IsReadOnly, false);
|
|
|
|
var displayFormatAttribute = Attributes.FirstOrDefault<DisplayFormatAttribute>() ??
|
|
(DataTypeAttribute != null ? DataTypeAttribute.DisplayFormat : null);
|
|
|
|
ApplyFormatInEditMode = displayFormatAttribute.GetPropertyValue(a => a.ApplyFormatInEditMode, false);
|
|
ConvertEmptyStringToNull = displayFormatAttribute.GetPropertyValue(a => a.ConvertEmptyStringToNull, true);
|
|
DataFormatString = displayFormatAttribute.GetPropertyValue(a => a.DataFormatString, String.Empty);
|
|
NullDisplayText = displayFormatAttribute.GetPropertyValue(a => a.NullDisplayText, String.Empty);
|
|
HtmlEncode = displayFormatAttribute.GetPropertyValue(a => a.HtmlEncode, true);
|
|
}
|
|
|
|
public DisplayAttribute DisplayAttribute { get; private set; }
|
|
|
|
public bool ApplyFormatInEditMode { get; private set; }
|
|
|
|
public bool ConvertEmptyStringToNull { get; private set; }
|
|
|
|
public string DataFormatString { get; private set; }
|
|
|
|
public DataTypeAttribute DataTypeAttribute { get; private set; }
|
|
|
|
public object DefaultValue {
|
|
get {
|
|
return DefaultValueAttribute.GetPropertyValue(a => a.Value, null);
|
|
}
|
|
}
|
|
|
|
private DefaultValueAttribute DefaultValueAttribute { get; set; }
|
|
|
|
public string Description {
|
|
get {
|
|
return DisplayAttribute.GetLocalizedDescription() ??
|
|
DescriptionAttribute.GetPropertyValue(a => a.Description, null);
|
|
}
|
|
}
|
|
|
|
private DescriptionAttribute DescriptionAttribute { get; set; }
|
|
|
|
public string DisplayName {
|
|
get {
|
|
return DisplayAttribute.GetLocalizedName() ??
|
|
DisplayNameAttribute.GetPropertyValue(a => a.DisplayName, null);
|
|
}
|
|
}
|
|
|
|
public string ShortDisplayName {
|
|
get {
|
|
return DisplayAttribute.GetLocalizedShortName();
|
|
}
|
|
}
|
|
|
|
private DisplayNameAttribute DisplayNameAttribute { get; set; }
|
|
|
|
public string FilterUIHint { get; private set; }
|
|
|
|
public EditableAttribute EditableAttribute { get; private set; }
|
|
|
|
public bool IsReadOnly { get; private set; }
|
|
|
|
public string NullDisplayText { get; private set; }
|
|
|
|
public string Prompt {
|
|
get {
|
|
return DisplayAttribute.GetLocalizedPrompt();
|
|
}
|
|
}
|
|
|
|
public RequiredAttribute RequiredAttribute { get; private set; }
|
|
|
|
public ScaffoldColumnAttribute ScaffoldColumnAttribute { get; private set; }
|
|
|
|
public StringLengthAttribute StringLengthAttribute { get; private set; }
|
|
|
|
public string UIHint { get; private set; }
|
|
|
|
private DataTypeAttribute GetDefaultDataTypeAttribute() {
|
|
if (Column.IsString) {
|
|
if (Column.IsLongString) {
|
|
return new DataTypeAttribute(DataType.MultilineText);
|
|
}
|
|
else {
|
|
return new DataTypeAttribute(DataType.Text);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private string GetHint<T>(Func<T, string> presentationLayerPropertyAccessor, Func<T, string> hintPropertyAccessor) where T : Attribute {
|
|
var uiHints = Attributes.OfType<T>();
|
|
var presentationLayerNotSpecified = uiHints.Where(a => String.IsNullOrEmpty(presentationLayerPropertyAccessor(a)));
|
|
var presentationLayerSpecified = uiHints.Where(a => !String.IsNullOrEmpty(presentationLayerPropertyAccessor(a)));
|
|
|
|
T uiHintAttribute = presentationLayerSpecified.FirstOrDefault(a => presentationLayerPropertyAccessor(a).ToLower(CultureInfo.InvariantCulture) == "webforms" ||
|
|
presentationLayerPropertyAccessor(a).ToLower(CultureInfo.InvariantCulture) == "mvc") ??
|
|
presentationLayerNotSpecified.FirstOrDefault();
|
|
|
|
return uiHintAttribute.GetPropertyValue(hintPropertyAccessor);
|
|
}
|
|
|
|
|
|
public bool HtmlEncode {
|
|
get; set;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
string IMetaColumn.Description {
|
|
get {
|
|
return Description;
|
|
}
|
|
}
|
|
|
|
string IMetaColumn.DisplayName {
|
|
get {
|
|
return DisplayName;
|
|
}
|
|
}
|
|
|
|
string IMetaColumn.Prompt {
|
|
get {
|
|
return Prompt;
|
|
}
|
|
}
|
|
|
|
string IMetaColumn.ShortDisplayName {
|
|
get {
|
|
return ShortDisplayName;
|
|
}
|
|
}
|
|
|
|
IMetaTable IMetaColumn.Table {
|
|
get {
|
|
return Table;
|
|
}
|
|
}
|
|
|
|
IMetaModel IMetaColumn.Model {
|
|
get {
|
|
return Model;
|
|
}
|
|
}
|
|
}
|
|
}
|