Example #1
0
        private Expression GenerateFilter <T>(ParameterExpression pe, JQGridSearch search)
        {
            //multiple search query
            Expression Query = null;

            if (search.groups.Count() > 0)
            {
                //multiple group query
                foreach (JQGridSearch item in search.groups)
                {
                    if (Query == null)
                    {
                        Query = GenerateFilter <T>(pe, item);
                    }
                    else
                    {
                        if (search.groupOp == "AND")
                        {
                            Query = Expression.AndAlso(Query, GenerateFilter <T>(pe, item));
                        }
                        else
                        {
                            Query = Expression.OrElse(Query, GenerateFilter <T>(pe, item));
                        }
                    }
                }
            }
            else if (search.rules.Count() > 0)
            {
                foreach (JQGridSearchRule item in search.rules)
                {
                    if (Query == null)
                    {
                        Query = FilterExpression <T>(pe, item);
                    }
                    else
                    {
                        if (search.groupOp == "AND")
                        {
                            Query = Expression.AndAlso(Query, FilterExpression <T>(pe, item));
                        }
                        else
                        {
                            Query = Expression.OrElse(Query, FilterExpression <T>(pe, item));
                        }
                    }
                }
            }

            return(Query);
        }
Example #2
0
        public JQGridResponse <T> Query <T>(Entities entity, HttpRequestMessage Request)
        {
            dynamic instance = Activator.CreateInstance(typeof(T));

            int    PageSize                  = 0;
            int    Page                      = 0;
            string SortColumn                = "";
            string SortOrder                 = "";
            bool   search                    = false;
            string SingleSearch_Field        = "";
            string SingleSearch_Value        = "";
            string SingleSearch_Oper         = "";
            MethodCallExpression WhereClause = null;

            var model = entity.Set(typeof(T)).OfType <T>();

            if (Request.GetQueryNameValuePairs().Where(x => x.Key == "rows").First().Value != "")
            {
                PageSize = int.Parse(Request.GetQueryNameValuePairs().Where(x => x.Key == "rows").First().Value);
            }

            if (Request.GetQueryNameValuePairs().Where(x => x.Key == "page").First().Value != "")
            {
                Page = int.Parse(Request.GetQueryNameValuePairs().Where(x => x.Key == "page").First().Value);
            }

            if (Request.GetQueryNameValuePairs().Where(x => x.Key == "sidx").First().Value != "")
            {
                SortColumn = Request.GetQueryNameValuePairs().Where(x => x.Key == "sidx").First().Value;
            }

            if (Request.GetQueryNameValuePairs().Where(x => x.Key == "sord").First().Value != "")
            {
                SortOrder = Request.GetQueryNameValuePairs().Where(x => x.Key == "sord").First().Value;
            }

            Type type = typeof(T);
            ParameterExpression pe = Expression.Parameter(type, "p");

            //search options
            if (Request.GetQueryNameValuePairs().Where(x => x.Key == "_search").First().Value == "true")
            {
                search = true;
                Expression Queryfilter = null;

                if (Request.GetQueryNameValuePairs().Where(x => x.Key == "searchField").First().Value != "")
                {
                    //single search
                    SingleSearch_Field = Request.GetQueryNameValuePairs().Where(x => x.Key == "searchField").First().Value;
                    SingleSearch_Value = Request.GetQueryNameValuePairs().Where(x => x.Key == "searchString").First().Value;
                    SingleSearch_Oper  = Request.GetQueryNameValuePairs().Where(x => x.Key == "searchOper").First().Value;

                    Queryfilter = FilterExpression <T>(pe, SingleSearch_Oper, SingleSearch_Field, SingleSearch_Value);
                }
                else
                {
                    //get Search options
                    string searchstring = Request.GetQueryNameValuePairs().Where(x => x.Key == "filters").First().Value;

                    JQGridSearch objJSON = new JQGridSearch();
                    JObject      jobject = JObject.Parse(searchstring);
                    objJSON.groupOp = (string)jobject["groupOp"];
                    objJSON.rules   = JsonConvert.DeserializeObject <List <JQGridSearchRule> >(jobject["rules"].ToString());
                    if (jobject["groups"] != null)
                    {
                        objJSON.groups = JsonConvert.DeserializeObject <List <JQGridSearch> >(jobject["groups"].ToString());
                    }
                    else
                    {
                        objJSON.groups = new List <JQGridSearch>();
                    }
                    //groups = (List<JQGridSearch>)jobject.Children()["groups"].Values().ToList();

                    Queryfilter = GenerateFilter <T>(pe, objJSON);
                }

                WhereClause = Expression.Call(
                    typeof(Queryable),
                    "Where",
                    new Type[] { model.ElementType },
                    model.Expression,
                    Expression.Lambda <Func <T, bool> >(Queryfilter, new ParameterExpression[] { pe }));

                model = model.Provider.CreateQuery <T>(WhereClause);
            }

            JQGridResponse <T> response = new JQGridResponse <T>();

            response.page    = Page;
            response.records = model.LongCount();
            response.total   = (response.records % PageSize) == 0 ? response.records / PageSize : (response.records / PageSize) + 1;

            if (PageSize != 0 && Page != 0 && SortColumn != "" && SortOrder != "")
            {
                if (search)
                {
                    model         = model.Provider.CreateQuery <T>(WhereClause);
                    response.rows = SortBy <T>(model, SortColumn, SortOrder).Skip((Page - 1) * PageSize).Take(PageSize);
                }
                else
                {
                    response.rows = SortBy <T>(model, SortColumn, SortOrder).Skip((Page - 1) * PageSize).Take(PageSize);
                }
            }
            else
            {
                if (search)
                {
                    response.rows = model.Provider.CreateQuery <T>(WhereClause);
                }
                else
                {
                    response.rows = model;
                }
            }

            return(response);
        }