theKindOfMe

February 5, 2009

A Grid with Ajax/Pagination/Sorting/Filtering on ASP.net MVC with ExtJS and Enitiy Framework

Filed under: Uncategorized — Tags: , , , , , , , — yasi8h @ 9:18 am

I am new to all these JS libraries like jQuery and ExtJS(there are many more out there…). when i got started with asp.net mvc i looked in to jQuery. and i was absolutely amazed with all the functionality it offered with very simple and neat syntax! a while ago i did a post on “Ajax Enabling MVCContrib Grid’s Pagination with jQuery”. In which i added AJAX/pagination support to MVCContrib’s Grid. but with time i needed more and more features from the grid. like sorting and filtering(through AJAX of course). then i came across the wonderful JS library called ExtJS. it have grate UI components done and ready to be used. i love all ExtJS stuff that is related to UI. and their components seems to be very extensible as well.

Ext JS Overview

Ext JS is a cross-browser JavaScript library for building rich Internet applications. It includes:

  • High performance, customizable UI widgets
  • Well designed and extensible Component model
  • An intuitive, easy to use API
  • Commercial and Open Source licenses available

i liked there Grid and it had all the features i needed. so i decided to go ahead with it.

extjs_grid_screenshot

the main points i had to look at:

  • including a ExtJS distribution with my asp.net mvc project which is already using jQuery
  • inserting the relevant JS to render the grid in my views
  • creating the necessary controller actions to support the grid’s actions(get data/sort/filter data…etc)

Including a ExtJS distribution

ExtJS JS library can use other libraries(such as jQuery…) as its base library. so been a fan of jQuery, i choose to build a custom version of ExtJS which uses jQuery as its base.  this version of the library includes the jQuery adapter within it self. but you still need to include the jQuery library by your self. it is NOT included in the custom version that you built for your self.  so in your site.master(you can put these where ever you like, not necessary in the site.master. just make sure these are included where ever you use them) you have to include the libraries in the following order: include jQuery first, then include any jQuery plugins you use and finally include ExtJS(any of your custom JS files should be included afterward).

now you are done including the JS libraries necessary . but ExtJS’s UI components need a few more things to be included in your site.master for them to work correctly. you need to include the necessary style sheets/images used by ExtJS components. to get these download ExtJS SDK. this includes all the style sheets and the images among other things. you will need to include the necessary plugins as well.

  • ext-2.2resourcescssext-all.css
  • ext-2.2resourcesimages – images used by ExtJS components
  • all JS files under ext-2.2examplesgrid-filteringgrid – includes necessary plugins needed for the grid filtering functionality

now you are ready to roll. note that we can use what ever jQuery we want when we are working with extjs components. and as we are using the jQuery core(and also because we are already using jQuery in out mvc project) the size of the ExtJS library is much lower.

Rendering the grid

looking at the samples(look under ext-2.2examplesgrid-filtering) included in the extjs sdk. its not that hard to figure out how to render the grid using javascript. the extjs API reference would be helpful as well.

i ran across a bug in the GridView component when i tried to use disable ‘autoHeight’ ‘feature’ of the grid. how ever there was a fix available for it in the the extjs forums.  following is the JS code that i used in my view(in which the grid resides). i just included them in a script tag within the view. but the best way to use them would be to extract them in to some helper methods and then using the helpers.

some notes about ExtJs grids

  • a grid is ‘bound’ to a data store.
  • when rendering a grid you will have to create a data record, column modal and a data reader(JsonReader in this case).
  • column modal – how the columns are structured
  • data record – how a data record(or a person object, in the context of this example) is structured. what fields does it contain…etc
  • data reader – where to get/ how to read data
  • filters and paging is connected to the grid in a ‘pluggable’ manner

        //Sugguested Fix for the bug: "Grid autoHeight disables horizontal scrolling too"
        Ext.override(Ext.grid.GridView, {
            layout: function() {
                if (!this.mainBody) {
                    return;
                }
                var g = this.grid;
                var c = g.getGridEl(), cm = this.cm,
                expandCol = g.autoExpandColumn,
                gv = this;
                var csize = c.getSize(true);
                var vw = csize.width;
                if (vw < 20 || csize.height < 20) {
                    return;
                }
                if (g.autoHeight) {
                    csize.height = this.mainHd.getHeight() + this.mainBody.getHeight();
                    if (!this.forceFit) {
                        csize.height += this.scrollOffset;
                    }
                }
                this.el.setSize(csize.width, csize.height);
                var hdHeight = this.mainHd.getHeight();
                var vh = csize.height - (hdHeight);
                this.scroller.setSize(vw, vh);
                if (this.innerHd) {
                    this.innerHd.style.width = (vw) + 'px';
                }
                if (this.forceFit) {
                    if (this.lastViewWidth != vw) {
                        this.fitColumns(false, false);
                        this.lastViewWidth = vw;
                    }
                } else {
                    this.autoExpand();
                }
                this.onLayout(vw, vh);
            }
        });
        //end bug fix here
        //////////////////

        Ext.onReady(function() {
            Ext.QuickTips.init(); //for enabling tool tips

            Ext.menu.RangeMenu.prototype.icons = {
                gt: '/Scripts/extjs/plugins/grid-filter/img/greater_then.png',
                lt: '/Scripts/extjs/plugins/grid-filter/img/less_then.png',
                eq: '/Scripts/extjs/plugins/grid-filter/img/equals.png'
            };
            Ext.grid.filter.StringFilter.prototype.icon = '/Scripts/extjs/plugins/grid-filter/img/find.png';

            createAndShowGrid();
        });

        function createAndShowGrid() {

            order = Ext.data.Record.create(&#91;
	        { name: 'Id' },
	        { name: 'FirstName' },
	        { name: 'Email' }
        &#93;);

            orderReader = new Ext.data.JsonReader({
                root: 'dataitems',
                totalProperty: 'totalItems' //number of total records
            },
		    order
	    );
            //data store creation
            ds = new Ext.data.Store({
                proxy: new Ext.data.HttpProxy({
                    url: '/Person/ListJson'
                }),
                reader: orderReader,
                sortInfo: { field: 'Id', direction: "ASC" },
                remoteSort: true
            });

            columnModel = new Ext.grid.ColumnModel(&#91;{
                header: 'Person Id',
                dataIndex: 'Id'
            }, {
                header: 'Person Name',
                dataIndex: 'FirstName'
            }, {
                header: 'Person Email',
                dataIndex: 'Email'
            }
	    &#93;);

            columnModel.defaultSortable = true;

            var filters = new Ext.grid.GridFilters({
                filters: &#91;
	                { type: 'string', dataIndex: 'Id' },
	                { type: 'string', dataIndex: 'FirstName' },
	                { type: 'string', dataIndex: 'Email' }
	            &#93;
            });

            var pagingBar = new Ext.PagingToolbar({
                pageSize: 10,
                store: ds,
                displayInfo: true,
                displayMsg: 'Displaying Persons {0} - {1} of {2}',
                emptyMsg: "No Persons to display",
                plugins: filters
            });

            grid = new Ext.grid.GridPanel({
                store: ds,
                cm: columnModel,
                width: 500,
                autoHeight: true,
                title: 'Persons List',
                frame: true,
                loadMask: true,
                stripeRows: true,
                plugins: filters,
                bbar: pagingBar // paging bar on the bottom
            });

            grid.render('personGrid');
            grid.store.load({ params: { start: 0, limit: 10} });
        }
<div id="personGrid"

&#91;/sourcecode&#93;
<h4>Controller actions to support the grid's actions(get data/sort/filter data...etc)</h4>
A ExtJS grid can be fed data in various ways. i am going use a controller action to give the grid the data it needs to render it self. the data would be in json format. we would have a controller action like the following, that returns a JsonResult. we can use the Json method in the mvc framework to serialize the data to json with ease. i am doing it by constructing a anonymous type that hosts the data and then serializing it to json. please note that the following example uses the Entity Framework to deal with the back-end data. although this is example uses the EF. you can easily port it to use any other ORM technology(Linq...etc).

source of /Person/ListJson action


public JsonResult ListJson()
        {
            int totalOjectCount;
            var personsList = ExtJSGridFilterHelper.GetResults(Request, new ObjectEntities().Person,out totalOjectCount);
            var list = new ArrayList();
            foreach (var person in personsList) //populate data containers with read data
            {
                list.Add(new
                             {
                                 Id = person.ID,
                                 FirstName = person.FirstName,
                                 person.Email
                             });
            }
            return Json(new { dataitems = list.ToArray(), totalItems = totalOjectCount });
        }

note that the json result that is returned, basically contains a array of items and a another property called totalItems. this total items property tell the grid, the number of(obviously ) total items that it will have to display. this is helpfule for the grid when pagination is enabled. and you should make sure that this property is specified in your json output if you want the pagination to work correctly.

example json output that is produced by the above action

{"dataitems":[{"Id":"5","FirstName":"jhon Lalic","Email":"jhon@gmail.com"},{"Id":"6","FirstName":"Maureen Joesph","Email"
:"maureen@gmail.com"}],"totalItems":2}

this contains two records. and the totalItems property.

ExtJSGridFilterHelper is a helper class that harbours most of the logic related to implementing sorting/paging and filtering of data. i am not going to explain what the source code is doing, step by step. but you can always read the source ;). 

parsing of parameters sent by the grid…(for the full source code please look at the source of ExtJSGridFilterHelper)

parameters related to paging

  • start
  • limit

parameters related to the sorting

  • sort => the name of the property to be sorted(as given in the client side(aka field name))
  • dir => direction
if (sort != null) //do sorting
            {
                objectsList = query.OrderBy("it." + sort).ToList();
                if (dir == "DESC") objectsList.Reverse();
            }
            else
            {
                objectsList = query.ToList();
            }

parameters related to the filters

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)];
            }

how filters are processed, extract from the getExpression() method

</pre>
<pre>public FilterExpressionResult getExpression()
            {
                string expressionString = null;
                var expressionParams = new List(); //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 == "true") ? 1 : 0);
                        break;
                    case "numeric":
                        switch (Datacomparison)
                        {
                            case "gt":
                                Datacomparison = ">";
                                break;
                            case "lt":
                                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&#91;&#93; { ',' });
                        var r = new string&#91;split.Length&#93;;
                        for (var i = 0; i < split.Length; i++)
                        {
                            r&#91;i&#93; = string.Format("(it.{0} = '{1}')", Field, split&#91;i&#93;);
                        }
                        expressionString = string.Format("({0})", string.Join("OR", r));
                        break;
                }
<pre>

source of ExtJSGridFilterHelper

public class ExtJSGridFilterHelper
{
public static List GetResults(HttpRequestBase request, ObjectQuery query, out int totalOjectCount)
{
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 objectsList;

totalOjectCount = query.Count();
var i = 0;
var exspressions = new List();
var parameters = new List();
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 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(); //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 == “true”) ? 1 : 0);
break;
case “numeric”:
switch (Datacomparison)
{
case “gt”:
Datacomparison = “>”;
break;
case “lt”:
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 Parameters { get; set; } } #endregion } #endregion } [/sourcecode] ah! that's it for now. i might post some helpers that can be used in your views when you want to render the grid. the advantage of using this would be, so you won't need to repeat all that javascript code in each and every view that you want to display a grid in. hope this will be helpful to someone. cheers!

Advertisements

January 12, 2009

Ajax Enabling MVCContrib Grid’s Pagination with jQuery

Filed under: Uncategorized — Tags: , , , , — yasi8h @ 8:16 am

The MVCContrib project(at http://www.codeplex.com/MVCContrib ) provides a nice Grid ‘control'(and a lot more of course…) for use with MVC framework. Currently it does not support some what magical generation of javascript. so that you can have a ajaxified grid control. but with jQuery its pretty easy to ajaxify it. Today i finished ajaxifiying the paging of the grid, with a little bit of jQuery. So this is how i did it. i am sure that there must be betters ways of doing it. but this is what i came up with 😛

Structure

First of all for this to work you will need some ‘structure’ in your app. let’s take a little example. if you want to display a list of People in your application using a grid. you will have a controller for people: PeopleController. this would have a two actions. one would be List. while the other one would be ListForGrid. List action would be a plain action that will just return a normal view: List.aspx. while ListForGrid would return a asp ‘control’ or a partial view: ListForGrid.ascx. ListForGrid.ascx would know how to render a grid. it will use the normal Grid helpers to render a grid that displays people. List.aspx will contain an empty div:grid_holder and some java script that would add the Ajax goodness.

How it works

when a user asks for the People/List. the List.aspx would be rendered. and upon the document.ready() it would call ListForGrid action via ajax and load the resulting html in to the page. ListForGrid uses the ListForGrid.ascx to render the grid. ListForGrid action will also accept the necessary parameters to support Grid’s pagination(ListForGrid(int? page)).

this is all good. but still we have not archived our main goal. the rendered grid will have pagination links that would take us back to theListForGrid action directly. so if we click on them we would go to that resulting view with out any ajax ‘magic’. to get the grid to render them with ajax we are going to have to use jQuery to ‘hook’ in to the click event’s of the pagination related links( first | prev | next | last) that are in the rendered grid. and we will ‘intercept’ any events(clicks) and load the grid through ajax as necessary. so if you click on the next link in the grid we will stop the page from going to the relevant page, we will ‘read’ what ‘location’ that he is trying to take us to and we will load that through ajax.

now if you don’t understand what i am trying to tell you, please take a look at the source code bellow. i am sure you will understand that 🙂

relavant JS/jQuery source code
$gridHolder = "#grid_holder";
$ListForGridURL = "/People/ListForGrid";

//load the grid when the document loads. this code will run only once
$(document).ready(function() {
    $($gridHolder).load($ListForGridURL, null, function() {
        //now the grid is loaded call ajazPaging,
        //this will hook on to the click events
        ajaxPaging();
    });
});

//hook on to the click events(in a recursive way) of all pagination
//related links, and when clicked load the updated grid through AJAX
function ajaxPaging() {
    //this will zero in on the needed <a> elements in the Grid
    $(".paginationRight > a")
        .click(function(event) {
            //stop the browser from going to the relevant URL
            event.preventDefault();
            //this.href will give us the href value of the current
            //element, which have the URL from which we should update our grid
            $($gridHolder).load(this.href, null, function() {
                //call the function recursively so that the same code would
                //run when the user click on the pagination links after the loading happens
                ajaxPaging();
            });
        });
}

Update: with the release of jQuery 1.3 you can write this in a more simpler way using the live(). more info

Live Events

jQuery now supports “live events” – events that can be bound to all current – and future – elements. Using event delegation, and a seamless jQuery-style API, the result is both easy to use and very fast.

$gridHolder = "#grid_holder";
$ListForGridURL = "/People/ListForGrid";

//load the grid when the document loads. this code will run only once
$(document).ready(function() {
    $($gridHolder).load($ListForGridURL, null, function() {
        //now the grid is loaded call ajazPaging,
        //this will hook on to the click events

    //hook on to the click events of all pagination
    //related links, and when clicked load the updated grid through AJAX
    //this will zero in on the needed <a> elements in the Grid
    $(".paginationRight > a")
        .live("click", function(event) {
            //stop the browser from going to the relevant URL
            event.preventDefault();
            //this.href will give us the href value of the current
            //element, which have the URL from which we should update our grid
            $($gridHolder).load(this.href);
        });
    });
});
rest of the sample source code(controller, actions and views…)
<em>PeopleController </em>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Ajax;

using MvcContrib.Pagination;
using MvcContrib;

namespace MvcLocalization.Controllers
{
    public class PeopleController : Controller
    {
        public ActionResult List()
        {
            return View();
        }

        public ActionResult ListForGrid(int? page)
        {
            ViewData["people"] = GetListOfPeopel().AsPagination(page ?? 1, 1);
            return View("UserListGrid");
        }
    }
}

<em>
List.aspx</em>


<h2>People</h2>
<div id="grid_holder"></div>

        $gridHolder = "#grid_holder";
        $ListForGridURL = "/People/ListForGrid";

        //load the grid when the document loads. this code will run only once
        $(document).ready(function() {
            $($gridHolder).load($ListForGridURL, null, function() {
                //now the grid is loaded call ajazPaging, this will hook on to the click events
                ajaxPaging();
            });
        });

//hook on to the click events(in a recursive way) of all pagination
related links, and when clicked load the updated grid through AJAX
        function ajaxPaging() {
            //this will zero in on the needed <a> elements in the Grid
            $(".paginationRight > a")
                 .click(function(event) {
                       //stop the browser from going to the relevant URL
                     event.preventDefault();
                    //this.href will give us the href value of the current <a> element, which have the URL from which we should update our grid
                     $($gridHolder).load(this.href, null, function() {
                          //call the function recursively so that the same code would run when the user click on the pagination links after the loading happens
                         ajaxPaging();
                     });
                 });
        }

    


<em>ListForGrid.ascx</em>


<%
    Html.Grid(
        "people",
            column =>
            {
                column.For(p => p.Name);
                column.For(p => p.Age);
                column.For(p => p.Address);
            }
            );
%>

Aha! that’s it. jQuery rocks eh!
hope this will be useful to someone/myself.

Note 1: if you are completely new to MVCContrib Grid, you might want to read this
Note 2: a article on “Using MVCContrib Grid in a Web 2.0 World with jquery and AJAX” (btw this article does not cover implementing paging through ajax…)

November 27, 2008

ASP.NET MVC and Ruby on Rails

Filed under: Uncategorized — Tags: , , , , — yasi8h @ 5:31 pm

the last few days i have been learning about asp.net and about the new asp.net mvc framework. i am very new to asp.net. i’ve never ever used asp before. but as per a requirement at my work place i had to look in to it. i was rather excited to look in to it really. because i always admired mvc design pattern! 🙂 i am one of those people who love the separation of concerns. as a side project(and for my ‘final year’ project) i have been learning ruby and rails at home. so when i started looking in to asp.net mvc i had a considerable understanding of the rails framework. so while learning asp.net mvc, i really felt that its a lot similar to rails. there are lots of mvc frameworks out there and i am sure that most of them learn from each other. so thats is a grate thing. i mean as far as technology is concerned ‘copying’ is a good thing. so then you can build up something new on top of something that is already there. so anyways there were a lot of things that i felt was shared between rails and asp.net mvc. for example the way you write out the configuration for url routing in your application. in rails you put that stuff in application.rb(applicationcontroller). and you write all the configuration on the routing using ruby. so in asp.net mvc we do it in the applicationcontroller which is in the global.aspx. and in asp.net mvc there are many instances where the convention over configuration principal is applied. in controller classes. each and every public method is a action. but in the early version of the mvc fw this was not the case, you had to mark the action methods using a attribute. the url routing was configured using xml in the early releases, but later on you can now configure them in c#. i also noted that new additions to c# 3 language spec makes it a bit more like ruby. now i am not saying c# is like ruby. it is of course NOT. but microsoft have introduced some new features like anonymous methods… that is been used a lot in mvc fw(at least in the samples/blog posts found on the net…).

whats more it seems that mvc fw will have some kind of scaffolding capabilities in the future! 🙂 right now even there is the asp.net dynamic data project. it offers you something more like scaffolding. you can give it a model and it will generate all the CURD stuff for you. dynamically. and these forms have basic validation stuff built in. further more these generated asp pages use ajax controls. i am not very educated about dynamic scaffolding capabilities with rails so i can’t compare it with dynamic data. but i am sure rails have some exciting stuff none the less.

all in all, mvc(the design pattern) rocks! 🙂 that i am sure of. for me it have been easy to learn these two frameworks together in parallel. because most of the things that you learn in one framework can be applied to the other. i am not talking about very low level implementation details. but how things get done in the higher level. (ie: implementing authorization with the use of filters…). i love these two fws. microsoft been what it is, becomes inherently ‘evil’, so i can’t really show my love towards asp.net mvc fw. but anyways its exciting. i am enjoying learning mvc fm and rails. i have been missing out on these grate frameworks been in the mobile development side. but not anymore.

Blog at WordPress.com.