mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
399 lines
18 KiB
C#
399 lines
18 KiB
C#
namespace System.Web.DynamicData {
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Data.Linq;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Linq.Expressions;
|
|
using System.Web;
|
|
using System.Web.DynamicData.Util;
|
|
using System.Web.Resources;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
/// <summary>
|
|
/// Extension methods used by DynamicData
|
|
/// </summary>
|
|
public static class DynamicDataExtensions {
|
|
public static void SetMetaTable(this INamingContainer control, MetaTable table) {
|
|
SetMetaTableInternal(control, table, null/* defaultValues*/, new HttpContextWrapper(HttpContext.Current));
|
|
}
|
|
|
|
public static void SetMetaTable(this INamingContainer control, MetaTable table, IDictionary<string, object> defaultValues) {
|
|
if (defaultValues == null) {
|
|
throw new ArgumentNullException("defaultValues");
|
|
}
|
|
SetMetaTableInternal(control, table, defaultValues, new HttpContextWrapper(HttpContext.Current));
|
|
}
|
|
|
|
public static void SetMetaTable(this INamingContainer control, MetaTable table, object defaultValues) {
|
|
if (defaultValues == null) {
|
|
throw new ArgumentNullException("defaultValues");
|
|
}
|
|
SetMetaTableInternal(control, table, Misc.ConvertObjectToDictionary(defaultValues), new HttpContextWrapper(HttpContext.Current));
|
|
}
|
|
|
|
public static IDictionary<string, object> GetDefaultValues(this IDataSource dataSource) {
|
|
return GetDefaultValues(dataSource, new HttpContextWrapper(HttpContext.Current));
|
|
}
|
|
|
|
public static IDictionary<string, object> GetDefaultValues(this INamingContainer control) {
|
|
return GetDefaultValues(control, new HttpContextWrapper(HttpContext.Current));
|
|
}
|
|
|
|
public static MetaTable GetMetaTable(this IDataSource dataSource) {
|
|
return GetMetaTable(dataSource, new HttpContextWrapper(HttpContext.Current));
|
|
}
|
|
|
|
public static bool TryGetMetaTable(this IDataSource dataSource, out MetaTable table) {
|
|
return TryGetMetaTable(dataSource, new HttpContextWrapper(HttpContext.Current), out table);
|
|
}
|
|
|
|
public static MetaTable GetMetaTable(this INamingContainer control) {
|
|
return GetMetaTable(control, new HttpContextWrapper(HttpContext.Current));
|
|
}
|
|
|
|
public static bool TryGetMetaTable(this INamingContainer control, out MetaTable table) {
|
|
return TryGetMetaTable(control, new HttpContextWrapper(HttpContext.Current), out table);
|
|
}
|
|
|
|
internal static void ApplyFieldGenerator(INamingContainer control, MetaTable table) {
|
|
GridView gridView = control as GridView;
|
|
if (gridView != null && gridView.AutoGenerateColumns && gridView.ColumnsGenerator == null) {
|
|
gridView.ColumnsGenerator = new DefaultAutoFieldGenerator(table);
|
|
}
|
|
else {
|
|
DetailsView detailsView = control as DetailsView;
|
|
if (detailsView != null && detailsView.AutoGenerateRows && detailsView.RowsGenerator == null) {
|
|
detailsView.RowsGenerator = new DefaultAutoFieldGenerator(table);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static DefaultValueMapping GetDefaultValueMapping(object control, HttpContextBase context) {
|
|
IDictionary<object, MappingInfo> mapping = MetaTableHelper.GetMapping(context);
|
|
MappingInfo mappingInfo;
|
|
if (mapping.TryGetValue(control, out mappingInfo)) {
|
|
return mappingInfo.DefaultValueMapping;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static IDictionary<string, object> GetDefaultValues(object control, HttpContextBase context) {
|
|
DefaultValueMapping mapping = GetDefaultValueMapping(control, context);
|
|
if (mapping != null) {
|
|
return mapping.Values;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static MetaTable GetMetaTable(IDataSource dataSource, HttpContextBase context) {
|
|
MetaTable table;
|
|
if (TryGetMetaTable(dataSource, context, out table)) {
|
|
return table;
|
|
}
|
|
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, DynamicDataResources.MetaTable_CannotGetTableFromDataSource));
|
|
}
|
|
|
|
internal static bool TryGetMetaTable(IDataSource dataSource, HttpContextBase context, out MetaTable table) {
|
|
if (dataSource == null) {
|
|
throw new ArgumentNullException("dataSource");
|
|
}
|
|
|
|
Debug.Assert(context != null);
|
|
|
|
table = MetaTableHelper.GetTableFromMapping(context, dataSource);
|
|
if (table == null) {
|
|
var dynamicDataSource = dataSource as IDynamicDataSource;
|
|
if (dynamicDataSource != null) {
|
|
table = MetaTableHelper.GetTableFromDynamicDataSource(dynamicDataSource);
|
|
}
|
|
}
|
|
return table != null;
|
|
}
|
|
|
|
internal static MetaTable GetMetaTable(INamingContainer control, HttpContextBase context) {
|
|
MetaTable table;
|
|
if (!TryGetMetaTable(control, context, out table)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, DynamicDataResources.MetaTable_CannotGetTableFromControl));
|
|
}
|
|
return table;
|
|
}
|
|
|
|
internal static bool TryGetMetaTable(INamingContainer control, HttpContextBase context, out MetaTable table) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
|
|
table = MetaTableHelper.GetTableFromMapping(context, control);
|
|
return table != null;
|
|
}
|
|
|
|
internal static void SetMetaTableInternal(INamingContainer control, MetaTable table, IDictionary<string, object> defaultValues, HttpContextBase context) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (table == null) {
|
|
throw new ArgumentNullException("table");
|
|
}
|
|
IDataBoundControl dataBoundControl = control as IDataBoundControl;
|
|
IDataSource dataSource = null;
|
|
if (dataBoundControl != null) {
|
|
dataSource = dataBoundControl.DataSourceObject;
|
|
}
|
|
MetaTableHelper.SetTableInMapping(context, control, table, defaultValues);
|
|
if (dataSource != null) {
|
|
// If the control being mapped is a databound control then register its datasource
|
|
MetaTableHelper.SetTableInMapping(context, dataSource, table, defaultValues);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the MetaTable association with a datasource
|
|
/// </summary>
|
|
[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "This is a legacy API and cannot be changed")]
|
|
public static MetaTable GetTable(this IDynamicDataSource dataSource) {
|
|
return MetaTableHelper.GetTableWithFullFallback(dataSource, HttpContext.Current.ToWrapper());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Expand Dynamic where parameter (e.g. DynamicControlParameter, DynamicQueryStringParameter) into
|
|
/// 'regular' parameters that the datasource can understand
|
|
/// </summary>
|
|
/// <param name="dataSource">The datasource which Where parameters need to be expanded</param>
|
|
public static void ExpandDynamicWhereParameters(this IDynamicDataSource dataSource) {
|
|
|
|
ParameterCollection whereParameters = dataSource.WhereParameters;
|
|
|
|
// First, check if any parameters need to be expanded
|
|
bool needProcessing = false;
|
|
foreach (Parameter parameter in whereParameters) {
|
|
if (parameter is IWhereParametersProvider) {
|
|
needProcessing = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If not, don't do anything
|
|
if (!needProcessing)
|
|
return;
|
|
|
|
// Make a copy of the parameters, and clear the collection
|
|
var whereParametersCopy = new Parameter[whereParameters.Count];
|
|
whereParameters.CopyTo(whereParametersCopy, 0);
|
|
whereParameters.Clear();
|
|
|
|
// Go through all the parameters and expand them
|
|
foreach (Parameter parameter in whereParametersCopy) {
|
|
ExpandWhereParameter(dataSource, parameter);
|
|
}
|
|
}
|
|
|
|
private static void ExpandWhereParameter(IDynamicDataSource dataSource, Parameter parameter) {
|
|
var provider = parameter as IWhereParametersProvider;
|
|
if (provider == null) {
|
|
// If it's a standard parameter, just add it
|
|
dataSource.WhereParameters.Add(parameter);
|
|
}
|
|
else {
|
|
// Get the list of sub-parameters and expand them recursively
|
|
IEnumerable<Parameter> newParameters = provider.GetWhereParameters(dataSource);
|
|
foreach (Parameter newParameter in newParameters) {
|
|
ExpandWhereParameter(dataSource, newParameter);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find the containing data control, and return the data source it points to
|
|
/// </summary>
|
|
public static IDynamicDataSource FindDataSourceControl(this Control current) {
|
|
return DataControlHelper.FindDataSourceControl(current);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find the containing data control, and return the MetaTable associated with it, if any
|
|
/// </summary>
|
|
public static MetaTable FindMetaTable(this Control current) {
|
|
return MetaTableHelper.FindMetaTable(current, HttpContext.Current.ToWrapper());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find the field template for a column within the current naming container
|
|
/// </summary>
|
|
public static Control FindFieldTemplate(this Control control, string columnName) {
|
|
return control.FindControl(DynamicControl.GetControlIDFromColumnName(columnName));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Make the SelectedIndex [....] up with the PersistedSelection. Concretely, what it means is that
|
|
/// if you select a row and then page away (or sort), the selection remains on that row
|
|
/// even if it's not currently visible.
|
|
/// </summary>
|
|
[Obsolete("Use the EnablePersistedSelection property on a databound control such as GridView or ListView.")]
|
|
public static void EnablePersistedSelection(this BaseDataBoundControl dataBoundControl) {
|
|
EnablePersistedSelectionInternal(dataBoundControl);
|
|
}
|
|
|
|
internal static void EnablePersistedSelectionInternal(BaseDataBoundControl dataBoundControl) {
|
|
IDataBoundListControl dataBoundListControl = dataBoundControl as IDataBoundListControl;
|
|
if (dataBoundListControl != null) {
|
|
dataBoundListControl.EnablePersistedSelection = true;
|
|
//
|
|
|
|
if (dataBoundListControl.SelectedIndex < 0) {
|
|
// Force the first item to be selected
|
|
dataBoundListControl.SelectedIndex = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the DataLoadOptions on a Linq To Sql datasource to force all the FK entities
|
|
/// to be directly loaded.
|
|
/// </summary>
|
|
/// <param name="dataSource">The data source for which we want to preload FKs</param>
|
|
/// <param name="rowType">The type of the entities returned by the data source</param>
|
|
public static void LoadWithForeignKeys(this LinqDataSource dataSource, Type rowType) {
|
|
dataSource.ContextCreated += delegate(object sender, LinqDataSourceStatusEventArgs e) {
|
|
// This only applies to a DLinq data context
|
|
var context = e.Result as DataContext;
|
|
if (context == null)
|
|
return;
|
|
|
|
DataLoadOptions loadOptions = null;
|
|
ParameterExpression tableParameter = null;
|
|
System.Data.Linq.Mapping.MetaTable metaTable = context.Mapping.GetTable(rowType);
|
|
foreach (System.Data.Linq.Mapping.MetaDataMember member in metaTable.RowType.DataMembers) {
|
|
if (member.IsAssociation && !member.Association.IsMany) {
|
|
if (member.Type.Equals(rowType)) continue;
|
|
if (loadOptions == null) {
|
|
loadOptions = new DataLoadOptions();
|
|
tableParameter = Expression.Parameter(rowType, "e");
|
|
}
|
|
var memberExpression = Expression.Property(tableParameter, member.Name);
|
|
loadOptions.LoadWith(Expression.Lambda(memberExpression, tableParameter));
|
|
}
|
|
}
|
|
|
|
if (loadOptions != null) {
|
|
context.LoadOptions = loadOptions;
|
|
}
|
|
};
|
|
}
|
|
|
|
public static void LoadWith<TEntity>(this LinqDataSource dataSource) {
|
|
LoadWithForeignKeys(dataSource, typeof(TEntity));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Apply potential HTML encoding and formatting to a string that needs to be displayed
|
|
/// This logic is mostly copied from BoundField.FormatDataValue, but omits the old Whidbey behavior path
|
|
/// </summary>
|
|
/// <param name="fieldValue">The value that should be formatted</param>
|
|
/// <param name="formattingOptions">The IFieldFormattingOptions to use. This is useful when using options different from the column's</param>
|
|
/// <returns>the formatted value</returns>
|
|
public static string FormatValue(this IFieldFormattingOptions formattingOptions, object fieldValue) {
|
|
|
|
string formattedValue = String.Empty;
|
|
|
|
if (fieldValue != null) {
|
|
string dataValueString = fieldValue.ToString();
|
|
string formatting = formattingOptions.DataFormatString;
|
|
int dataValueStringLength = dataValueString.Length;
|
|
|
|
// If the result is still empty and ConvertEmptyStringToNull=true, replace the value with the NullDisplayText
|
|
if (dataValueStringLength == 0 && formattingOptions.ConvertEmptyStringToNull) {
|
|
dataValueString = formattingOptions.NullDisplayText;
|
|
}
|
|
else {
|
|
// If there's a format string, apply it to the raw data value
|
|
// If there's no format string, then dataValueString already has the right value
|
|
if (!String.IsNullOrEmpty(formatting)) {
|
|
dataValueString = String.Format(CultureInfo.CurrentCulture, formatting, fieldValue);
|
|
}
|
|
|
|
// Optionally HTML encode the value (including the format string, if any was applied)
|
|
if (!String.IsNullOrEmpty(dataValueString) && formattingOptions.HtmlEncode) {
|
|
dataValueString = HttpUtility.HtmlEncode(dataValueString);
|
|
}
|
|
}
|
|
|
|
formattedValue = dataValueString;
|
|
}
|
|
else {
|
|
formattedValue = formattingOptions.NullDisplayText;
|
|
}
|
|
|
|
return formattedValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Similar to FormatValue, but the string is to be used when the field is in edit mode
|
|
/// </summary>
|
|
public static string FormatEditValue(this IFieldFormattingOptions formattingOptions, object fieldValue) {
|
|
string valueString;
|
|
|
|
// Apply the format string to it if that flag is set. Otherwise use it as is.
|
|
if (formattingOptions.ApplyFormatInEditMode) {
|
|
valueString = formattingOptions.FormatValue(fieldValue);
|
|
}
|
|
else {
|
|
valueString = (fieldValue != null) ? fieldValue.ToString() : String.Empty;
|
|
}
|
|
|
|
// Trim any trailing spaces as they cause unwanted behavior (since we limit the input length and the
|
|
// spaces cause the limit to be reach prematurely)
|
|
valueString = valueString.TrimEnd();
|
|
|
|
return valueString;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return either the input value or null based on ConvertEmptyStringToNull and NullDisplayText
|
|
/// </summary>
|
|
/// <param name="formattingOptions">the formatting options object</param>
|
|
/// <param name="value">The input value</param>
|
|
/// <returns>The converted value</returns>
|
|
public static object ConvertEditedValue(this IFieldFormattingOptions formattingOptions, string value) {
|
|
// If it's an empty string and ConvertEmptyStringToNull is set, make it null
|
|
if (String.IsNullOrEmpty(value) && formattingOptions.ConvertEmptyStringToNull) {
|
|
return null;
|
|
}
|
|
|
|
// If it's the NullDisplayText, return null
|
|
string nullDisplayText = formattingOptions.NullDisplayText;
|
|
if (value == nullDisplayText && !String.IsNullOrEmpty(nullDisplayText)) {
|
|
return null;
|
|
}
|
|
|
|
// Otherwise, return it unchanged
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// If this column represents an enumeration type, this method returns that type. The caloumn can represent
|
|
/// an enumeration type if the underlying type is an enum, or if it is decoareted with EnumDataTypeAttribute.
|
|
/// If this column does not represent an enum, this method returns null.
|
|
/// </summary>
|
|
/// <param name="column"></param>
|
|
/// <returns></returns>
|
|
[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "The interface is internal")]
|
|
public static Type GetEnumType(this MetaColumn column) {
|
|
return GetEnumType((IMetaColumn)column);
|
|
}
|
|
|
|
internal static Type GetEnumType(this IMetaColumn column) {
|
|
return column.Attributes.GetAttributePropertyValue<EnumDataTypeAttribute, Type>(a => a.EnumType, null) ??
|
|
(column.ColumnType.IsEnum ? column.ColumnType : null);
|
|
}
|
|
|
|
internal static bool IsEnumType(this MetaColumn column, out Type enumType) {
|
|
enumType = column.GetEnumType();
|
|
return enumType != null;
|
|
}
|
|
}
|
|
}
|