## Ajax HTML Grid Control for ASP.NET MVC (Part 3)

Seth Juarez7/10/2008

## Moving to an HTML Helper

As I was looking around at the various HTML helpers out there, I realized that I should probably conform and stick to what is being done. Having said that, I refactored the Grid class to be a new HTML helper. Here is how it is used (similar to an MvcForm actually):

<% using (Html.GridControl<StudentController, StudentEntity, int>(
s => s.EditStudent(),
s => s.DeleteStudent(),
ViewData.Model,
s => s.StudentId,
"Student",
null)) {  %>
Special text here!
<% } %>


The GridControl has now been attached as an extension method to the standard HTML Helper. Doing that required a bit of re-arranging on the parameters that needed to be passed in to the helper. The first are the types being used:

1. The first type is the Controller being used for updates
2. The second is the type of item in the collection
3. The last is the data type of the key of each item

For the parameters:

1. The first specifies the controller action when an item is edited
2. The second specifies the controller action when a item is deleted
3. The third is the actual Collection object
4. The fourth tells the GridControl how to generate the key for each item
5. The fifth is the name to use for the control
6. The last specifies any additional html attributes to use (not implemented currently)

I really liked using the action expressions since it allows a better granularity in handling the actual Ajax requests to the controller. I used the this code to generate the appropriate URLS (strings):

_editAction = helper.BuildUrlFromExpression<t>(editAction);
_deleteAction = helper.BuildUrlFromExpression<t>(deleteAction);


An important thing to note is that the grid is actually printed out when the helper is disposed. This means that anything that is placed inside of the using brackets will be shown before the grid is displayed.

## Getting Data to the Controller

Now for the actual work! The first thing I wanted to ensure was that I sent the data back to the controller via a POST and not a GET method. The $.getJSON function in JQuery performs a GET (see post) so I needed to change that. Here is what the grid produced for the save and delete actions: else if(action == 'save') { var arr =$('#Student_Form').serializeArray();
$.ajax({ type: 'POST', contentType: 'application/x-www-form-urlencoded', url: '/Student/EditStudent', data: arr, dataType: 'json', success: function(msg){ alert( 'Data Saved: ' + msg ); } }); } else if(action == 'delete') { var dat = 'DataId=' + id;$.ajax({
type: 'POST',
contentType: 'application/x-www-form-urlencoded',
url: '/Student/DeleteStudent',
data: dat,
dataType: 'json',
success: function(msg){
alert( 'Delete: ' + msg );
}
});
}


Notice that this is a continuation of the JavaScript from the previous post. The fundamental JQuery call for AJAX is \$.ajax(properties) where the properties are the specifications on how the AJAX call should be made. The first and most important thing was to use POST rather than GET. A GET http call is supposed to be idempotent while a POST call can actually change the state of the server. Both the delete and save actions should change the state of the server. Also, from a security standpoint, it is always easier to craft some form of URL to cause an action to execute on a controller when using GET. This can open things up to malicious attacks. Imagine anyone simply typing http://yoursite/Student/DeleteStudent?DataId=1232 into their browser and the controller deleting that record. That would be bad. With a POST this can be controlled better.

My favorite part of the JQuery code is the .serializeArray() part. This takes each of the valid form members and automagically places the data in a JSON array structure to be passed to the controller.

## Getting the Data in the Controller

Here is a nice screenshot of what happens when the controller save action is fired:

The AJAX postback, in conjunction with the .serializeArray() call placed all of the items of the StudentEntity in the Request.Form collection. Now for the ugly code (reminiscent of ASP 3.0)

public JsonResult EditStudent()
{
StudentEntity student = new StudentEntity();
student.StudentId = int.Parse(Request.Form["StudentId"]);

int age;
if (int.TryParse(Request.Form["Age"], out age)) student.Age = age;
student.FirstName = Request.Form["FirstName"];
student.LastName = Request.Form["LastName"];
student.Phone = Request.Form["Phone"];
student.State = Request.Form["State"];
student.Zip = Request.Form["Zip"];

StudentService.SaveStudent(student);

return new JsonResult
{
Data = "Edited student " + student.StudentId.ToString() + "!"
};
}


The result sent back is a simple message. More could be done here, but I have not thought about it too much. I also dislike the whole Request.Form["val"] stuff. I think this could be automated using the grid somehow so we can get rid of the tedious code. Actually I think adding a generic static method to the Grid class should do the trick. I will probably add it next time.

## Things to do

So far things seem to be going well. Here are some things I would like to add:

1. Better entity population from the Request.Form collection
2. An "Add New" feature to the grid
3. On delete of a row, remove the TR element from the table (the database thinks it is gone, but the HTML says otherwise)
4. CSS Grid customization

If you can think of any other things drop me a line.