linux-packaging-mono/mcs/class/referencesource/System.Web.DynamicData/DynamicData/DynamicControlParameter.cs

using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Web.DynamicData.Util;
using System.Web.Resources;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace System.Web.DynamicData {

    /// <summary>
    /// DynamicControlParameter is similar to ControlParameter, but understainds higher level concepts.  e.g. in a 
    /// master-details scenario using a GridView and DetailsView, you only need to point the DetailsView's datasource
    /// to the GridView (using a DynamicControlParameter), and it does the right thing.  This works even for
    /// multi-part primary keys
    /// </summary>
    public class DynamicControlParameter : Parameter, IWhereParametersProvider {

        /// <summary>
        /// </summary>
        public DynamicControlParameter() { }

        /// <summary>
        /// </summary>
        public DynamicControlParameter(string controlId) { ControlId = controlId; }

        /// <summary>
        /// The ID of the control from which the parameter gets its data
        /// </summary>
        public string ControlId { get; set; }

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

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

        private IEnumerable<Parameter> GetPrimaryKeyControlWhereParameters(Control control,
            IControlParameterTarget paramTarget) {

            MetaTable parentTable = paramTarget.Table;
            if (parentTable != null) {
                // For each PK column in the table, we need to create a ControlParameter
                foreach (var keyColumn in parentTable.PrimaryKeyColumns) {
                    var controlParameter = new ControlParameter() {
                        Name = keyColumn.Name,
                        ControlID = control.UniqueID,
                        PropertyName = paramTarget.GetPropertyNameExpression(keyColumn.Name)
                    };

                    DataSourceUtil.SetParameterTypeCodeAndDbType(controlParameter, keyColumn);

                    yield return controlParameter;
                }
            }
        }

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

        /// <summary>
        /// same as base
        /// </summary>
        /// <param name="context"></param>
        /// <param name="control"></param>
        /// <returns></returns>
        protected override object Evaluate(HttpContext context, Control control) {
            // If this gets called, it means we never had a chance to expand the parameter. Give an error
            // telling the user to use a DynamicDataManager
            throw new InvalidOperationException(String.Format(
                CultureInfo.CurrentCulture, DynamicDataResources.DynamicParameter_NeedExpansion, typeof(DynamicControlParameter).Name));
        }
    }
}