including how to use a database to populate the dropdown
First thing is first, you will need to download
jQuery
and the
Jeditable
plugin (I prefer to refer to it as the Jedi-Table!).
Be sure to put these references in your View (or Masterpage).
Next, you have to set up a view on which to use an inline edit.
I find that I often want to use this approach on tables of information.
For this View, I will set it to use an IEnumerable of an Item I have called 'ItemOwner' (this is arbitrary and does not really matter).
It will be a simple table that lists the Name and the Country of the owner, both of which will be editable inline.
Here is the Index in my ExampleController.cs:
myDataContext db = new myDataContext();
public ActionResult Index()
{
// get the info for the 'Countries' dropdown:
ViewData["countries"] = db.Countries
.Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.Id.ToString()
}).ToJson();
// get the 'ItemOwners' I am interested in:
var owners = db.ItemOwners.Take(3);
return View(owners);
}
As you can see there, I am also pulling the countries from the database and throwing them into the ViewState - we will get to this later. Since the Country is actually a foreign key relation, the value is set to an integer which is the identity field in the database. It is also using a .ToJson() extension which takes a IEnumerable<SelectListItem> and puts it into a simple JSON string that I use which is here:
public static string
ToJson(this IEnumerable<SelectListItem> slis)
{
string output = "{";
if (slis != null)
{
for (int i = 0; i < slis.Count(); i++)
{
output += " '" + slis.Skip(i)
.First().Value + "': '" +
slis.Skip(i).First().Text + "'" +
(i == slis.Count() - 1 ? " " : ",");
}
}
return output += "}";
}
There is probably a better way to do that... but I don't know it?!
I am also pulling 3 ItemOwners from the database, I know this is silly, but it just an example. Here is how I am displaying them in the view:
<table>
<thead>
<tr>
<th>Name</th>
<th>Country</th>
</tr>
</thead>
<tbody>
<% foreach(var owner in Model) { %>
<tr>
<td><%= owner.Name %></td>
<td><%= owner.Country.Abbreviation %></td>
</tr>
<% } %>
</tbody>
</table>
Now that there is a simple table we want to make it a bit more interactive. Since we aregoing to make all of these fields editable, we need to add in a way to distinguish exactly what they are. To do that, we will need two things: the id of the item they are editing, and the type of inline editing we will be doing (i.e. dropdown or text input). So to do that, let's add in a few css classes and an identifieng ID:
<td id="name<%= owner.Id %>" class="editable text">
<%= owner.Name %></td>
<td id="ctry<%= owner.Id %>" class="editable dropdown">
<%= owner.Country.Abbreviation %></td>
And now add a little css to make them appear to be clickable:
td.editable:hover
{ cursor:pointer; background-color:Orange; }
Now they all look like you can click on them, so we can move on to making the click actually do something.
This is where the jQuery comes in, and it is very simple. I have made these 'helper' methods in Javascript to make all of my inline calls centrally controllable, I keep this in my sites script folder so if I change one inline edit, I change them all; it also makes for more readable Javascript on each page.
function InlineDropdown(collectionToDropDown, ajaxAddress, dropDownDataSet) {
collectionToDropDown.editable(ajaxAddress,
{
data: dropDownDataSet,
type: 'select',
indicator: 'saving...',
tooltip: 'click to edit...',
submit: 'Save',
style: 'inherit',
placeholder: 'click to edit'
});
}
function InlineTextbox(collectionToInline, ajaxAddress) {
collectionToInline.editable(ajaxAddress,
{
indicator: 'saving...',
tooltip: 'click to edit...',
style: 'inherit',
placeholder: 'click to edit'
});
}
function InlineTextarea(collectionToInline, ajaxAddress) {
collectionToInline.editable(ajaxAddress,
{
type : 'textarea',
rows : 4,
indicator : 'saving...',
tooltip : 'click to edit...',
style : 'inherit',
submit : 'Save',
onblur : 'ignore',
placeholder : 'click to edit'
});
}
Obviously you can read all about the options on the Jeditable page, but this is how I set them. Also notice I have a InineTextarea included as well for a textarea which is not covered here but works the exact same.
Now the jQuery calls are almost trivial:
InlineTextbox(
$('td.editable.text'),
"<%= Url.Content("~/Ajax/ItemOwner.ashx") %>"
);
InlineDropdown(
$('td.editable.dropdown'),
"<%= Url.Content("~/Ajax/ItemOwner.ashx") %>",
<%= ViewData["countries"].ToString() %>
);
What that is doing is sending the POST requests to the specified address. The POST contains a few things:
- id - the id of the element that sent the request
- value - the new value passed by the element
public void ProcessRequest(HttpContext context)
{
string newValue;
try
{
myDataContext db = new myDataContext();
string elementId = context.Request.Form["id"];
// since we made the first 4 of the id the 'field' whic to edit
// we can just pull the first 4 letters for use in our switch:
string fieldToEdit = elementId.Substring(0, 4);
//now take anything after those 4 and it is the Id:
int idToEdit = Convert.ToInt32(elementId.Remove(0, 4));
// the value is simply a string:
newValue = context.Request.Form["value"].Trim();
// now that we have the id, get the ItemOwner from the db
ItemOwner owner = db.ItemOwners.FirstOrDefault(x => x.Id == idToEdit);
// after all is said and done, we will return newValue to the user so the field
// looks as if the change has taken place (which it has)
// using the field we pulled above, decide what to do:
switch (fieldToEdit)
{
// name is easy
case "name": owner.Name = newValue; break;
// since the country is an integer foreign key, we need to Convert.ToInt32:
case "ctry":
owner.CountryId = Convert.ToInt32(newValue);
// now that we have recorded the value, we want to return the text to
// the user and not the id value which would make no sense
newValue = db.Countries.FirstOrDefault(x => x.Id == owner.CountryId).Abbreviation;
break;
// if it wasn't caught, something is wrong:
default: throw new Exception("invalid fieldToEdit passed");
}
db.SubmitChanges(); // save it
}
// now if an exceptions were reported, the user can see what happened
// this also inform the user nothing was saved
// you could easily make this not reported to the user and logged elsewhere
catch (Exception ex)
{ newValue = "Error: " + ex.Message + " [nothing written to db]"; }
//now return what you want in the element:
context.Response.Write(newValue);
}
And that is all it takes.
