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

Author: mcintyre321

Mvc.JQuery.Datatables/DataTablesResult.cs

@@ -58,6 +58,7 @@ public class DataTablesResult<T, TRes> : DataTablesResult<TRes>
             Guard<IEnumerable<bool>>(s => s.ToArray()),
             Guard<IEnumerable<double>>(s => s.ToArray()),
             Guard<IEnumerable<object>>(s => s.Select(o => GetTransformedValue(o.GetType(), o)).ToArray()),
+            Guard<bool>(s => s),
             Guard<object>(o => (o ?? "").ToString())
         };
 

Mvc.JQuery.Datatables/TypeExtensions.cs

@@ -4,29 +4,32 @@
 using System.Linq;
 using System.Reflection;
 
-public static class TypeExtensions
+namespace Mvc.JQuery.Datatables
 {
-    public static IEnumerable<PropertyInfo> GetSortedProperties(this Type t)
+    public static class TypeExtensions
     {
-        return from pi in t.GetProperties()
-               let da = (DisplayAttribute)pi.GetCustomAttributes(typeof(DisplayAttribute), false).SingleOrDefault()
-               let order = ((da != null && da.Order != 0) ? da.Order : int.MaxValue)
-               orderby order
-               select pi;
-    }
+        public static IEnumerable<PropertyInfo> GetSortedProperties(this Type t)
+        {
+            return from pi in t.GetProperties()
+                   let da = (DisplayAttribute)pi.GetCustomAttributes(typeof(DisplayAttribute), false).SingleOrDefault()
+                   let order = ((da != null && da.GetOrder() != null && da.GetOrder() >= 0) ? da.Order : int.MaxValue)
+                   orderby order
+                   select pi;
+        }
 
-    public static IEnumerable<PropertyInfo> GetSortedProperties<T>()
-    {
-        return typeof(T).GetSortedProperties();
-    }
-    public static IEnumerable<PropertyInfo> GetProperties(this Type t)
-    {
-        return from pi in t.GetProperties()
-               select pi;
-    }
+        public static IEnumerable<PropertyInfo> GetSortedProperties<T>()
+        {
+            return typeof(T).GetSortedProperties();
+        }
+        public static IEnumerable<PropertyInfo> GetProperties(this Type t)
+        {
+            return from pi in t.GetProperties()
+                   select pi;
+        }
 
-    public static IEnumerable<PropertyInfo> GetProperties<T>()
-    {
-        return typeof(T).GetSortedProperties();
+        public static IEnumerable<PropertyInfo> GetProperties<T>()
+        {
+            return typeof(T).GetSortedProperties();
+        }
     }
 }

Mvc.JQuery.Datatables/TypeFilters.cs

@@ -99,13 +99,12 @@ public static string StringFilter(string q, string columnname, Type columntype,
         {
             if (q.StartsWith("^"))
             {
-                return columnname + ".ToLower().StartsWith(\"" + q.ToLower().Replace("\"", "\"\"") + "\")";
+                return "(!string.IsNullOrEmpty(" + columnname + ") && " + columnname + ".ToLower().StartsWith(\"" + q.ToLower().Replace("\"", "\"\"") + "\"))";
             }
             else
             {
-                return columnname + ".ToLower().Contains(\"" + q.ToLower().Replace("\"", "\"\"") + "\")";
+                return "(!string.IsNullOrEmpty(" + columnname + ") && " + columnname + ".ToLower().Contains(\"" + q.ToLower().Replace("\"", "\"\"") + "\"))";
             }
         }
-
     }
 }

Mvc.Jquery.DataTables.Tests/EF/EntityFramework.cs

@@ -1,38 +1,84 @@
 using System.Data.Entity;
 using System.Data.Entity.Infrastructure;
 using System.IO;
-using Mvc.JQuery.Datatables;
 using NUnit.Framework;
 using System;
 using System.Linq;
-using System.Collections.Generic;
+using Mvc.JQuery.Datatables;
 
 namespace Mvc.JQuery.DataTables.Tests
 {
-    public abstract class EntityFramework : Linq
+    public class EntityFramework : Linq, IDisposable
     {
         public class SomeContext : DbContext
         {
             public DbSet<SomeModel> Models { get; set; }
         }
 
-        protected readonly SomeContext DataContext;
-
-        public EntityFramework(SomeContext dataContext)
+        private readonly IDbConnectionFactory _defaultConnectionFactory;
+        private SomeContext _dataContext;
+        protected SomeContext DataContext
         {
-            DataContext = dataContext;
-            if (DataContext.Models.Any())
+            get { return _dataContext; }
+            set
             {
-                DataContext.Database.ExecuteSqlCommand("DELETE FROM SomeModels");
+                _dataContext = value;
+                SomeModelQueryable = (_dataContext==null)?null:_dataContext.Models.AsQueryable();
             }
-            foreach (var sm in SomeModelQueryable)
+        }
+
+        protected const string DbFile = "Test.sdf";
+        protected const string Password = "1234567890";
+
+        public EntityFramework()
+            : this(new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0", "",
+                string.Format("Data Source=\"{0}\";Password={1}", DbFile, Password))) { }
+
+        public EntityFramework(IDbConnectionFactory connectionFactory)
+        {
+            _defaultConnectionFactory = Database.DefaultConnectionFactory;
+            Database.DefaultConnectionFactory = connectionFactory;
+            var oldQueryable = SomeModelQueryable;
+            DataContext = new SomeContext();
+            DataContext.Database.Initialize(true);
+            foreach (var sm in oldQueryable)
             {
                 DataContext.Models.Add(sm);
             }
             DataContext.SaveChanges();
+        }
 
-            SomeModelQueryable = DataContext.Models;
+        [Test, TestCaseSource(typeof(MyFactoryClass), "TestCases")]
+        public override int[] ExecuteParams(DataTablesParam dataTablesParam)
+        {
+            DataContext.Dispose(); //reset datacontext in order to clear local 
+            DataContext = new SomeContext();
+            int[] returnVar = base.ExecuteParams(dataTablesParam);
+            Assert.AreEqual(returnVar.Length, DataContext.Models.Local.Count, "records loaded in memory");
+            return returnVar;
+        }
+
+        #region IDisposable implementation
+        private bool _disposed = false;
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    if (DataContext != null) { DataContext.Dispose(); }
+                    if (File.Exists(DbFile)) { File.Delete(DbFile); }
+                    Database.DefaultConnectionFactory = _defaultConnectionFactory;
+                }
+                _disposed = true;
+            }
+        }
+        #endregion
     }
 }