Merge branch 'master' of https://github.com/mcintyre321/mvc.jquery.datatables.git

mcintyre321 · mcintyre321 · commit 802893eebd87 · 2015-08-27T08:51:55.000+01:00
diff --git a/Mvc.JQuery.Datatables/DataTableConfigVm.cs b/Mvc.JQuery.Datatables/DataTableConfigVm.cs
@@ -79,17 +79,28 @@ public JToken SearchCols
 
 
 
+        private string _dom;
+
         public string Dom
         {
-            get { 
-                var sdom = "";
-                if (ColVis) sdom += "C";
-                if (TableTools) sdom += "T<\"clear\">";
-                if (ShowPageSizes) sdom += "l";
-                if (ShowSearch) sdom += "f";
-                sdom += "tipr";
-                return sdom;
+            get
+            {
+                if (!string.IsNullOrEmpty(_dom))
+                    return _dom;
+
+                string str = "";
+                if (this.ColVis)
+                    str += "C";
+                if (this.TableTools)
+                    str += "T<\"clear\">";
+                if (this.ShowPageSizes)
+                    str += "l";
+                if (this.ShowSearch)
+                    str += "f";
+                return str + "tipr";
             }
+
+            set { _dom = value; }
         }
 
         public bool ColVis { get; set; }
diff --git a/Mvc.JQuery.Datatables/DataTablesFiltering.cs b/Mvc.JQuery.Datatables/DataTablesFiltering.cs
@@ -31,15 +31,16 @@ public IQueryable<T> ApplyFiltersAndSort<T>(DataTablesParam dtParameters, IQuery
                 var values = parts.Where(p => p != null);
                 data = data.Where(string.Join(" or ", values), parameters.ToArray());
             }
-            for (int i = 0; i < dtParameters.sSearchColumns.Count; i++)
+            for (int i = 0; i < dtParameters.sSearchValues.Count; i++)
             {
                 if (dtParameters.bSearchable[i])
                 {
-                    var searchColumn = dtParameters.sSearchColumns[i];
+                    var searchColumn = dtParameters.sSearchValues[i];
                     if (!string.IsNullOrWhiteSpace(searchColumn))
                     {
+                        DataTablesPropertyInfo column = FindColumn(dtParameters, columns, i);
                         var parameters = new List<object>();
-                        var filterClause = GetFilterClause(dtParameters.sSearchColumns[i], columns[i], parameters);
+                        var filterClause = GetFilterClause(searchColumn, column, parameters);
                         if (string.IsNullOrWhiteSpace(filterClause) == false)
                         {
                             data = data.Where(filterClause, parameters.ToArray());
@@ -50,9 +51,9 @@ public IQueryable<T> ApplyFiltersAndSort<T>(DataTablesParam dtParameters, IQuery
             string sortString = "";
             for (int i = 0; i < dtParameters.iSortingCols; i++)
             {
-
                 int columnNumber = dtParameters.iSortCol[i];
-                string columnName = columns[columnNumber].PropertyInfo.Name;
+                DataTablesPropertyInfo column = FindColumn(dtParameters, columns, columnNumber);
+                string columnName = column.PropertyInfo.Name;
                 string sortDir = dtParameters.sSortDir[i];
                 if (i != 0)
                     sortString += ", ";
@@ -68,6 +69,18 @@ public IQueryable<T> ApplyFiltersAndSort<T>(DataTablesParam dtParameters, IQuery
             return data;
         }
 
+        private DataTablesPropertyInfo FindColumn(DataTablesParam dtParameters, DataTablesPropertyInfo[] columns, int i)
+        {
+            if (dtParameters.sColumnNames.Any())
+            {
+                return columns.First(x => x.PropertyInfo.Name == dtParameters.sColumnNames[i]);
+            }
+            else
+            {
+                return columns[i];
+            }
+        }
+
         public delegate string ReturnedFilteredQueryForType(
             string query, string columnName, DataTablesPropertyInfo columnType, List<object> parametersForLinqQuery);
 
diff --git a/Mvc.JQuery.Datatables/DataTablesModelBinder.cs b/Mvc.JQuery.Datatables/DataTablesModelBinder.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Web.Mvc;
 
 namespace Mvc.JQuery.Datatables
@@ -11,26 +12,83 @@ public class DataTablesModelBinder : IModelBinder
         public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
         {
             var valueProvider = bindingContext.ValueProvider;
+            int columns = GetValue<int>(valueProvider, "iColumns");
+            if (columns == 0)
+            {
+                return BindV10Model(valueProvider);
+            }
+            else
+            {
+                return BindLegacyModel(valueProvider, columns);
+            }
+        }
 
-            DataTablesParam obj = new DataTablesParam(GetValue<int>(valueProvider, "iColumns"));
+        private object BindV10Model(IValueProvider valueProvider)
+        {
+            DataTablesParam obj = new DataTablesParam();
+            obj.iDisplayStart = GetValue<int>(valueProvider, "start");
+            obj.iDisplayLength = GetValue<int>(valueProvider, "length");
+            obj.sSearch = GetValue<string>(valueProvider, "search[value]");
+            obj.bEscapeRegex = GetValue<bool>(valueProvider, "search[regex]");
+            obj.sEcho = GetValue<int>(valueProvider, "draw");
+
+            int colIdx = 0;
+            while (true)
+            {
+                string colPrefix = String.Format("columns[{0}]", colIdx);
+                string colName = GetValue<string>(valueProvider, colPrefix+"[data]");
+                if (String.IsNullOrWhiteSpace(colName)) {
+                    break;
+                }
+                obj.sColumnNames.Add(colName);
+                obj.bSortable.Add(GetValue<bool>(valueProvider, colPrefix+"[orderable]"));
+                obj.bSearchable.Add(GetValue<bool>(valueProvider, colPrefix+"[searchable]"));
+                obj.sSearchValues.Add(GetValue<string>(valueProvider, colPrefix+"[search][value]"));
+                obj.bEscapeRegexColumns.Add(GetValue<bool>(valueProvider, colPrefix+"[searchable][regex]"));
+                colIdx++;
+            }
+            obj.iColumns = colIdx;
+            colIdx = 0;
+            while (true)
+            {
+                string colPrefix = String.Format("order[{0}]", colIdx);
+                int? orderColumn = GetValue<int?>(valueProvider, colPrefix+"[column]");
+                if (orderColumn.HasValue)
+                {
+                    obj.iSortCol.Add(orderColumn.Value);
+                    obj.sSortDir.Add(GetValue<string>(valueProvider, colPrefix+"[dir]"));
+                    colIdx++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+            obj.iSortingCols = colIdx;
+            return obj;
+        }
+
+        private DataTablesParam BindLegacyModel(IValueProvider valueProvider, int columns)
+        {
+            DataTablesParam obj = new DataTablesParam(columns);
 
             obj.iDisplayStart = GetValue<int>(valueProvider, "iDisplayStart");
             obj.iDisplayLength = GetValue<int>(valueProvider, "iDisplayLength");
             obj.sSearch = GetValue<string>(valueProvider, "sSearch");
             obj.bEscapeRegex = GetValue<bool>(valueProvider, "bEscapeRegex");
             obj.iSortingCols = GetValue<int>(valueProvider, "iSortingCols");
             obj.sEcho = GetValue<int>(valueProvider, "sEcho");
-            
+
             for (int i = 0; i < obj.iColumns; i++)
             {
                 obj.bSortable.Add(GetValue<bool>(valueProvider, "bSortable_" + i));
                 obj.bSearchable.Add(GetValue<bool>(valueProvider, "bSearchable_" + i));
-                obj.sSearchColumns.Add(GetValue<string>(valueProvider, "sSearch_" + i));
+                obj.sSearchValues.Add(GetValue<string>(valueProvider, "sSearch_" + i));
                 obj.bEscapeRegexColumns.Add(GetValue<bool>(valueProvider, "bEscapeRegex_" + i));
                 obj.iSortCol.Add(GetValue<int>(valueProvider, "iSortCol_" + i));
                 obj.sSortDir.Add(GetValue<string>(valueProvider, "sSortDir_" + i));
             }
-            return obj;            
+            return obj;
         }
 
         private static T GetValue<T>(IValueProvider valueProvider, string key)
diff --git a/Mvc.JQuery.Datatables/DataTablesParam.cs b/Mvc.JQuery.Datatables/DataTablesParam.cs
@@ -15,18 +15,20 @@ public class DataTablesParam
         public bool bEscapeRegex { get; set; }
         public int iSortingCols { get; set; }
         public int sEcho { get; set; }
+        public List<string> sColumnNames { get; set; }
         public List<bool> bSortable { get; set; }
         public List<bool> bSearchable { get; set; }
-        public List<string> sSearchColumns { get; set; }
+        public List<string> sSearchValues { get; set; }
         public List<int> iSortCol { get; set; }
         public List<string> sSortDir { get; set; }
         public List<bool> bEscapeRegexColumns { get; set; }
 
         public DataTablesParam()
         {
+            sColumnNames = new List<string>();
             bSortable = new List<bool>();
             bSearchable = new List<bool>();
-            sSearchColumns = new List<string>();
+            sSearchValues = new List<string>();
             iSortCol = new List<int>();
             sSortDir = new List<string>();
             bEscapeRegexColumns = new List<bool>();
@@ -35,9 +37,10 @@ public DataTablesParam()
         public DataTablesParam(int iColumns)
         {
             this.iColumns = iColumns;
+            sColumnNames = new List<string>(iColumns);
             bSortable = new List<bool>(iColumns);
             bSearchable = new List<bool>(iColumns);
-            sSearchColumns = new List<string>(iColumns);
+            sSearchValues = new List<string>(iColumns);
             iSortCol = new List<int>(iColumns);
             sSortDir = new List<string>(iColumns);
             bEscapeRegexColumns = new List<bool>(iColumns);
diff --git a/Mvc.JQuery.Datatables/DataTablesResult.cs b/Mvc.JQuery.Datatables/DataTablesResult.cs
@@ -20,37 +20,56 @@ public abstract class DataTablesResult : ActionResult
         /// <returns></returns>
         public static DataTablesResult<TSource> Create<TSource, TTransform>(IQueryable<TSource> q, DataTablesParam dataTableParam,
             Func<TSource, TTransform> transform, ArrayOutputType? arrayOutput = null)
+        {
+            return Create(q, dataTableParam, transform, new ResponseOptions<TSource>() { ArrayOutputType = arrayOutput });
+        }
+
+        public static DataTablesResult<TSource> Create<TSource>(IQueryable<TSource> q, DataTablesParam dataTableParam,
+            ArrayOutputType? arrayOutput = null)
+        {
+            return Create(q, dataTableParam, new ResponseOptions<TSource>() { ArrayOutputType = arrayOutput });
+        }
+
+        /// <typeparam name="TSource"></typeparam>
+        /// <typeparam name="TTransform"></typeparam>
+        /// <param name="q">A queryable for the data. The properties of this can be marked up with [DataTablesAttribute] to control sorting/searchability/visibility</param>
+        /// <param name="dataTableParam"></param>
+        /// <param name="transform">//a transform for custom column rendering e.g. to do a custom date row => new { CreatedDate = row.CreatedDate.ToString("dd MM yy") } </param>
+        /// <returns></returns>
+        public static DataTablesResult<TSource> Create<TSource, TTransform>(IQueryable<TSource> q, DataTablesParam dataTableParam,
+            Func<TSource, TTransform> transform, ResponseOptions<TSource> responseOptions = null)
         {
             var result = new DataTablesResult<TSource>(q, dataTableParam);
 
             result.Data = result.Data
                 .Transform<TSource, Dictionary<string, object>>(row => TransformTypeInfo.MergeTransformValuesIntoDictionary(transform, row))
                 .Transform<Dictionary<string, object>, Dictionary<string, object>>(StringTransformers.StringifyValues);
 
-            result.Data = ApplyOutputRules(result.Data, arrayOutput);
+            result.Data = ApplyOutputRules(result.Data, responseOptions);
 
             return result;
         }
 
         public static DataTablesResult<TSource> Create<TSource>(IQueryable<TSource> q, DataTablesParam dataTableParam,
-            ArrayOutputType? arrayOutput = null)
+            ResponseOptions<TSource> responseOptions = null)
         {
             var result = new DataTablesResult<TSource>(q, dataTableParam);
 
+            var dictionaryTransform = DataTablesTypeInfo<TSource>.ToDictionary(responseOptions);
             result.Data = result.Data
-                .Transform<TSource, Dictionary<string, object>>(DataTablesTypeInfo<TSource>.ToDictionary)
+                .Transform<TSource, Dictionary<string, object>>(dictionaryTransform)
                 .Transform<Dictionary<string, object>, Dictionary<string, object>>(StringTransformers.StringifyValues);
 
-            result.Data = ApplyOutputRules(result.Data, arrayOutput);
+            result.Data = ApplyOutputRules(result.Data, responseOptions);
 
             return result;
         }
 
-        private static DataTablesData ApplyOutputRules(DataTablesData sourceData, ArrayOutputType? arrayOutput = null)
+        private static DataTablesData ApplyOutputRules<TSource>(DataTablesData sourceData, ResponseOptions<TSource> responseOptions)
         {
             DataTablesData outputData = sourceData;
 
-            switch (arrayOutput)
+            switch (responseOptions.ArrayOutputType)
             {
                 case ArrayOutputType.ArrayOfObjects:
                     // Nothing is needed
diff --git a/Mvc.JQuery.Datatables/DataTablesRowIdAttribute.cs b/Mvc.JQuery.Datatables/DataTablesRowIdAttribute.cs
@@ -0,0 +1,25 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using Mvc.JQuery.Datatables.Models;
+
+namespace Mvc.JQuery.Datatables
+{
+    public class DataTablesRowIdAttribute : DataTablesAttributeBase
+    {
+        public bool EmitAsColumnName { get; set; }
+
+        public override void ApplyTo(ColDef colDef, PropertyInfo pi)
+        {
+            // This attribute does not affect rendering
+        }
+
+        public DataTablesRowIdAttribute()
+        {
+            EmitAsColumnName = true;
+        }
+    }
+}
diff --git a/Mvc.JQuery.Datatables/Models/DataTablesData.cs b/Mvc.JQuery.Datatables/Models/DataTablesData.cs
@@ -11,7 +11,7 @@ public class DataTablesData
         public object[] aaData { get; set; }
 
      
-        public DataTablesData Transform<TData, TTransform>(Func<TData, TTransform> transformRow)
+        public DataTablesData Transform<TData, TTransform>(Func<TData, TTransform> transformRow, ResponseOptions responseOptions = null)
         {
             var data = new DataTablesData 
             {
diff --git a/Mvc.JQuery.Datatables/Models/ResponseOptions.cs b/Mvc.JQuery.Datatables/Models/ResponseOptions.cs
@@ -0,0 +1,54 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Mvc.JQuery.Datatables.Models
+{
+    public class ResponseOptions
+    {
+        public virtual ArrayOutputType? ArrayOutputType { get; set; }
+
+        public static ResponseOptions<TSource> For<TSource>(IQueryable<TSource> data, 
+            Action<ResponseOptions<TSource>> setOptions) where TSource : class
+        {
+            var responseOptions = new ResponseOptions<TSource>();
+            setOptions(responseOptions);
+            return responseOptions;
+        }
+    }
+
+    public class ResponseOptions<TSource> : ResponseOptions
+    {
+        public Func<TSource, object> DT_RowID
+        {
+            get
+            {
+                return dt_rowid;
+            }
+            set
+            {
+                dt_rowid = value;
+                if (value != null)
+                {
+                    ArrayOutputType = Models.ArrayOutputType.ArrayOfObjects;
+                }
+            }
+        }
+        private Func<TSource, object> dt_rowid;
+
+        public override ArrayOutputType? ArrayOutputType
+        {
+            get { return base.ArrayOutputType; }
+            set
+            {
+                if (DT_RowID != null && value != Models.ArrayOutputType.ArrayOfObjects)
+                {
+                    throw new ArgumentOutOfRangeException("ArrayOutputType", "ArrayOutputType must be ArrayOfObjects when DT_RowID is set");
+                }
+                base.ArrayOutputType = value;
+            }
+        }
+    }
+}
diff --git a/Mvc.JQuery.Datatables/Mvc.JQuery.Datatables.csproj b/Mvc.JQuery.Datatables/Mvc.JQuery.Datatables.csproj
@@ -82,6 +82,7 @@
     <Compile Include="DataTablesExcludeAttribute.cs" />
     <Compile Include="DataTablesFiltering.cs" />
     <Compile Include="DataTablesFilterAttribute.cs" />
+    <Compile Include="DataTablesRowIdAttribute.cs" />
     <Compile Include="LengthMenuVm.cs" />
     <Compile Include="Models\ArrayOutputType.cs" />
     <Compile Include="Models\ColDef.cs" />
@@ -105,6 +106,7 @@
     <Compile Include="DynamicLinq\Signature.cs" />
     <Compile Include="FilterDef.cs" />
     <Compile Include="Models\Language.cs" />
+    <Compile Include="Models\ResponseOptions.cs" />
     <Compile Include="Reflection\DataTablesPropertyInfo.cs" />
     <Compile Include="Reflection\DataTablesTypeInfo.cs" />
     <Compile Include="Reflection\DataTablesTypeInfoHelper.cs" />
diff --git a/Mvc.JQuery.Datatables/Reflection/DataTablesTypeInfo.cs b/Mvc.JQuery.Datatables/Reflection/DataTablesTypeInfo.cs

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ public class DataTablesData`
`11`	`11`	`public object[] aaData { get; set; }`
`12`	`12`
`13`	`13`
`14`		`- public DataTablesData Transform<TData, TTransform>(Func<TData, TTransform> transformRow)`
	`14`	`+ public DataTablesData Transform<TData, TTransform>(Func<TData, TTransform> transformRow, ResponseOptions responseOptions = null)`
`15`	`15`	`{`
`16`	`16`	`var data = new DataTablesData`
`17`	`17`	`{`