thekindofme

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Data.Objects;
using System.Linq;
using System.Web;

namespace EMS.Lib.Helpers
{
    public class EmExtJSGridFilterHelper
    {
        public static List<T> GetResults<T>(HttpRequestBase request, ObjectQuery<T> query, out int totalOjectCount)
        {
            return GetResults(request, query, out totalOjectCount, "");
        }

        public static List<T> GetResults<T>(HttpRequestBase request, ObjectQuery<T> query, out int totalOjectCount, string includes)
        {
            var sort = request.Params["sort"];
            var dir = request.Params["dir"];

            //get non null values
            int intStart, intLimit;
            if (!int.TryParse(request.Params["start"], out intStart)) intStart = 0;
            if (!int.TryParse(request.Params["limit"], out intLimit)) intLimit = 10;

            List<T> objectsList;

            if(!string.IsNullOrEmpty(includes)) query = query.Include(includes);//ex:- if Category was passed in with includes, a resulting Item list's item's would have the category property loaded(a category object will be there)
            totalOjectCount = query.Count();
            var i = 0;
            var exspressions = new List<string>();
            var parameters = new List<ObjectParameter>();
            while (true) //check for filters starting from 0, if one exists move to the next one(0 -> 1...), .
            {
                if (!Filter.checkExistence(i, request.Params)) break; //...if not stop looking further
                var expression = new Filter(i, request).getExpression();
                exspressions.Add(expression.Expression);
                parameters.AddRange(expression.Parameters);
                i++; //keep track of index
            }
            var exspression = string.Format("({0})", string.Join("AND", exspressions.ToArray()));
            //build the final expression
            if (exspression != "()") query = query.Where(exspression, parameters.ToArray()); //filter agents collection on the expression

            if (sort != null) //do sorting
            {
                objectsList = query.OrderBy("it." + sort).ToList();
                if (dir == "DESC") objectsList.Reverse();
            }
            else
            {
                objectsList = query.ToList();
            }

            if (intStart + intLimit > objectsList.Count)intLimit = objectsList.Count - intStart; //make sure the range we select is valid
            objectsList = objectsList.GetRange(intStart, intLimit);
            return objectsList;
        }

        #region Nested type: Filter

        public class Filter
        {
            public string Datacomparison { get; set; }
            public string DataType { get; set; }
            public string DataValue { get; set; }
            public string Field { get; set; }

            public int Id { get; set; }

            public static bool checkExistence(int filterIndex, NameValueCollection @params)
            {
                return (@params[string.Format("filter[{0}][field]", filterIndex)] != null);
            }

            public Filter(int id, HttpRequestBase request)
            {
                Id = id;
                Field = request.Params[string.Format("filter[{0}][field]", id)];
                DataType = request.Params[string.Format("filter[{0}][data][type]", id)];
                DataValue = request.Params[string.Format("filter[{0}][data][value]", id)];
                Datacomparison = request.Params[string.Format("filter[{0}][data][comparison]", id)];
            }

            public FilterExpressionResult getExpression()
            {
                string expressionString = null;
                var expressionParams = new List<ObjectParameter>(); //paramerters collection
                switch (DataType)
                {
                    case "string":
                        expressionString = string.Format("(it.{0} like '{1}%')", Field, DataValue);
                        break;
                    case "boolean":
                        expressionString = string.Format("(it.{0} = {1})", Field, DataValue);
                        break;
                    case "numeric":
                        switch (Datacomparison)
                        {
                            case "gt":
                                Datacomparison = ">";
                                break;
                            case "lt":
                                Datacomparison = "<";
                                break;
                            default:
                                Datacomparison = "=";
                                break;
                        }
                        expressionString = string.Format("(it.{0} {2} {1})", Field, DataValue, Datacomparison);
                        break;
                    case "date":
                        switch (Datacomparison)
                        {
                            case "gt":
                                Datacomparison = ">";
                                break;
                            case "lt":
                                Datacomparison = "<";
                                break;
                            default:
                                Datacomparison = "=";
                                break;
                        }

                        expressionParams.Add(new ObjectParameter("Param" + Id, DateTime.Parse(DataValue)));
                        expressionString = string.Format("(it.{0} {2} {1})", Field, "@" + "Param" + Id, Datacomparison);
                        break;
                    case "list":
                        var split = DataValue.Split(new[] { ',' });
                        var r = new string[split.Length];
                        for (var i = 0; i < split.Length; i++)
                        {
                            r[i] = string.Format("(it.{0} = '{1}')", Field, split[i]);
                        }
                        expressionString = string.Format("({0})", string.Join("OR", r));
                        break;
                }
                return expressionString != null
                           ? new FilterExpressionResult { Expression = expressionString, Parameters = expressionParams }
                           : null;
            }

            #region Nested type: FilterExpressionResult

            public class FilterExpressionResult
            {
                public string Expression { get; set; }
                public List<ObjectParameter> Parameters { get; set; }
            }

            #endregion
        }

        #endregion
    }
}