Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.DynamicData/DynamicData/MetaForeignKeyColumn.cs

@@ -0,0 +1,214 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Security.Permissions;
+using System.Web.DynamicData.ModelProviders;
+using System.Linq;
+using System.Web.UI;
+
+namespace System.Web.DynamicData {
+    /// <summary>
+    /// A special column representing many-1 relationships
+    /// </summary>
+    public class MetaForeignKeyColumn : MetaColumn, IMetaForeignKeyColumn {
+        // Maps a foreign key name to the name that should be used in a Linq expression for filtering
+        // i.e. the foreignkey name might be surfaced through a custom type descriptor e.g. CategoryID but we might really want to use
+        // Category.CategoryId in the expression
+        private Dictionary<string, string> _foreignKeyFilterMapping;
+
+        public MetaForeignKeyColumn(MetaTable table, ColumnProvider entityMember)
+            : base(table, entityMember) {
+        }
+
+        /// <summary>
+        /// Perform initialization logic for this column
+        /// </summary>
+        internal protected override void Initialize() {
+            base.Initialize();
+
+            ParentTable = Model.GetTable(Provider.Association.ToTable.Name, Table.DataContextType);
+
+            CreateForeignKeyFilterMapping(ForeignKeyNames, ParentTable.PrimaryKeyNames, (foreignKey) => Table.EntityType.GetProperty(foreignKey) != null);
+        }
+
+        internal void CreateForeignKeyFilterMapping(IList<string> foreignKeyNames, IList<string> primaryKeyNames, Func<string, bool> propertyExists) {
+            // HACK: Some tests don't mock foreign key names, but this should never be the case at runtime
+            if (foreignKeyNames == null) {
+                return;
+            }
+
+            int pKIndex = 0;
+            foreach (string fkName in foreignKeyNames) {
+                if (!propertyExists(fkName)) {
+                    if (_foreignKeyFilterMapping == null) {
+                        _foreignKeyFilterMapping = new Dictionary<string, string>();
+                    }
+                    _foreignKeyFilterMapping[fkName] = Name + "." + primaryKeyNames[pKIndex];
+                }
+                pKIndex++;
+            }
+        }
+
+        /// <summary>
+        /// The parent table of the relationship (e.g. Categories in Products-&gt;Categories)
+        /// </summary>
+        public MetaTable ParentTable {
+            get;
+            // internal for unit testing
+            internal set;
+        }
+
+        /// <summary>
+        /// Returns true if this foriegn key column is part of the primary key of its table
+        /// e.g. Order and Product are PKs in the Order_Details table
+        /// </summary>
+        public bool IsPrimaryKeyInThisTable {
+            get {
+                return Provider.Association.IsPrimaryKeyInThisTable;
+            }
+        }
+
+        /// <summary>
+        /// This is used when saving the value of a foreign key, e.g. when selected from a drop down.
+        /// </summary>
+        public void ExtractForeignKey(IDictionary dictionary, string value) {
+            if (String.IsNullOrEmpty(value)) {
+                // If the value is null, set all the FKs to null
+                foreach (string fkName in ForeignKeyNames) {
+                    dictionary[fkName] = null;
+                }
+            }
+            else {
+                string[] fkValues = Misc.ParseCommaSeparatedString(value);
+                Debug.Assert(fkValues.Length == ForeignKeyNames.Count);
+                for (int i = 0; i < fkValues.Length; i++) {
+                    dictionary[ForeignKeyNames[i]] = fkValues[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Return the value of all the foreign keys components for the passed in row
+        /// </summary>
+        public IList<object> GetForeignKeyValues(object row) {
+            object[] values = new object[ForeignKeyNames.Count];
+
+            int index = 0;
+            bool hasNonNullKey = false;
+            foreach (string fkMemberName in ForeignKeyNames) {
+                object keyValue = Table.Provider.EvaluateForeignKey(row, fkMemberName);
+
+                // Set a flag if at least one non-null key is found
+                if (keyValue != null)
+                    hasNonNullKey = true;
+
+                values[index++] = keyValue;
+            }
+
+            // If all the foreign keys are null, return null
+            if (!hasNonNullKey)
+                return null;
+
+            return values;
+        }
+
+        /// <summary>
+        /// Get a comma separated list of values representing the foreign key 
+        /// </summary>
+        /// <param name="row"></param>
+        /// <returns></returns>
+        public string GetForeignKeyString(object row) {
+            // Don't do anything if the row is null
+            if (row == null) {
+                return String.Empty;
+            }
+            return Misc.PersistListToCommaSeparatedString(GetForeignKeyValues(row));
+        }
+
+        /// <summary>
+        /// Override allowing for sorting by the display column of the parent table (e.g. in the Products table, the Category column
+        /// will be sorted by the Category.Name column order)
+        /// </summary>
+        internal override string SortExpressionInternal {
+            get {
+                var displayColumn = ParentTable.DisplayColumn;
+                var sortExpression = Provider.Association.GetSortExpression(displayColumn.Provider);
+                return sortExpression ?? String.Empty;
+            }
+        }
+
+        /*protected*/ internal override bool ScaffoldNoCache {
+            get {
+                // always display many-1 associations
+                return true;
+            }
+        }
+
+        public string GetFilterExpression(string foreignKeyName) {
+            string mappedforeignKey;
+            // If the mapping doesn't exists for this property then we return the actual FK
+            if (_foreignKeyFilterMapping == null || !_foreignKeyFilterMapping.TryGetValue(foreignKeyName, out mappedforeignKey)) {
+                return foreignKeyName;
+            }
+
+            return mappedforeignKey;
+        }
+
+        /// <summary>
+        /// Shortcut for getting the path to the details action for the given row
+        /// </summary>
+        /// <param name="row"></param>
+        /// <returns></returns>
+        public string GetForeignKeyDetailsPath(object row) {
+            return GetForeignKeyPath(PageAction.Details, row);
+        }
+
+        public string GetForeignKeyPath(string action, object row) {
+            return GetForeignKeyPath(action, row, null);
+        }
+
+        public string GetForeignKeyPath(string action, object row, string path) {
+
+            // If there is no row, we can't get a path
+            if (row == null)
+                return String.Empty;
+
+            // Get the value of all the FKs
+            IList<object> fkValues = GetForeignKeyValues(row);
+
+            // If null, there is no associated object to go to
+            if (fkValues == null)
+                return String.Empty;
+
+            return GetForeignKeyMetaTable(row).GetActionPath(action, fkValues, path);
+        }
+
+        internal MetaTable GetForeignKeyMetaTable(object row) {
+            // Get the foreign key reference
+            object foreignKeyReference = DataBinder.GetPropertyValue(row, Name);
+            // if the type is different to the parent table type then proceed to get the correct table
+            if (foreignKeyReference != null) {
+                // Get the correct MetaTable based on the live object. This is used for inheritance scenarios where the type of the navigation
+                // property's parent table is some base type but the instance is pointing to a derived type.
+                Type rowType = foreignKeyReference.GetType();
+                MetaTable rowTable = Misc.GetTableFromTypeHierarchy(rowType);
+                if (rowTable != null) {
+                    return rowTable;
+                }
+            }
+            return ParentTable;
+        }
+
+        /// <summary>
+        /// The names of the underlying foreign keys that make up this association
+        /// </summary>
+        public ReadOnlyCollection<string> ForeignKeyNames { get { return Provider.Association.ForeignKeyNames; } }
+
+        IMetaTable IMetaForeignKeyColumn.ParentTable {
+            get {
+                return ParentTable;
+            }
+        }
+    }
+}