Richard White gives a bit more info about it on his blog.

This will pretty much draw to a close this blog being used for the docs as AjaxScaffold will get an EOL stamp once ActiveScaffold reaches v1.0. So thank you to all who have given us feedback and supported the project so far.

This is simply a fix for the v3 plugin and contains none of the new (and very exciting stuff) coming in v4. It should be a straight upgrade for anyone on 3.2.2.

Patch Prototype

Simply open prototype.js and around line 915 replace this:

for (var name in headers)
  this.transport.setRequestHeader(name, headers[name]);

with this:

for( var name in headers ) {
  if( typeof( headers[name] ) != 'function' ) {
    this.transport.setRequestHeader(name,headers[name]);
  }
}

and all should be well again.

Remove Rico

Open up the ajax_scaffold_plugin.rb file in vendor/plugins/ajaxscaffoldp (or wherever it was installed) and at the bottom remove the ‘rico_corner’ include from this method:

def ajax_scaffold_includes
  js = javascript_include_tag(:defaults, 'rico_corner', 'ajax_scaffold', 'dhtml_history')
  css = stylesheet_link_tag('ajax_scaffold')
  js + "\n" + css
end

You should also remove the call to Rico.corner in table.rhtml, now all should function again just without rounded corners….. ]]> http://blog.thatsuseful.com/2007/01/22/ajaxscaffold-and-rails-1-2-1/feed/ 0 http://blog.thatsuseful.com/2006/10/28/dynamic-columns-with-ajax-scaffold/ http://blog.thatsuseful.com/2006/10/28/dynamic-columns-with-ajax-scaffold/#comments Sat, 28 Oct 2006 06:11:06 +0000 Scott http://blog.caronsoftware.com/2007/11/25/dynamic-columns-with-ajax-scaffold I”ve been asked a couple of times how to dynamically setup the columns displayed by the AS plugin dependant on the permissions of the user, so I though a quick post would be a good idea.

Basically its very simple, you simply define a hash of all the columns you potentially wish to display keyed by the column name, so something like:

@@columns_hash[:user] = ScaffoldColumn.new(..)
@@columns_hash[:foo] = ScaffoldColumn.new(:name => 'bar')

Then define a before_filter along the lines of:

before_filter :create_columns,  nly => ['table', 'update_table']

Finally all you need to do is write the create_columns method to assign the appropriate columns dependant on the user:

def create_columns
  if user.is_administrator
    @@scaffold_columns = [ @@columns_hash[:user], @@columns_hash[:foo] ]
  else
    @@scaffold_columns = [ @@columns_hash[:user] ]
  end
end

A bit contrived but you get the idea.

This method should continue working in the upcoming 4.0 version of the plugin (associations, search, all sorts of loveliness in that…..) however I think it will have been refined a bit to get rid of the class variables. But for now, it should solve the problem.

1. Single table inheritance now works
2. Legacy table names are now supported
3. The table formats properly under IE

The 3 extra extra extension points are

1. do_new
2. do_edit
3. do_delete

I will update the post on extending the plugin to fully cover these new features.

The wiki contains links to various bits of documentation for both the plugin and the generator. Plugin specific posts from myself can be found here

Right, free beer and pizza……

There are a couple of other changes to do with the install and version numbers, but that is all internal to the plugin.

demo

This version fixes a problem with having multiple editors open at once on the same page and also adds a helper to allow multiple editors on the same Ajax form. This also now works with static html forms but you can just use the standard form helpers for that.

To create an ajax form using multiple editors use the fckeditor_form_remote_tag helper and pass the :editors option. This takes an hash of model symbol keys with each having an array as its value. The array should contain the list of fields that will have editors attached to them.

<%= fckeditor_form_remote_tag :url => some_great_url,
     :editors => { :multinote => ['text1', 'text2'] } %>

    <%= fckeditor_textarea( "multinote", "text1", :ajax => true ) %>
    <%= fckeditor_textarea( "multinote", "text2", :ajax => true ) %>

<%= end_form_tag %>

You can of course use the same helper for a single editor or for static html forms as it is a bit neater than having to declare the :before javascript method yourself.

The aim of this post is to show how to extend or replace the default functionality of the Ajax Scaffold plugin (ASp). I will go over two areas, firstly how you filter the dataset the table displays, and secondly the methods you can override to really gain control.

Simple Filtering of the Dataset

In order to filter the data that the table displays you need to simply override a single method (for each model) in your controller.

conditions_for_{table_name}_collection

This method is expected to return the same array that the Rails find() method accepts as its :conditions parameter.

Lets take a simple user model as an example. The db table has the following columns: id, name, password, employer_id where the employer_id represents a has-one relationship to the user’s employer (represented by another table). Now lets say we only want to see users from the current employer in our table, then all we need to do is define the following method in our controller:

def conditions_for_users_collection
  [ 'employer_id = ?', params[:current_employer] ]
end

This of course assumes that the current request defines :current_employer as the employer’s id.

You can use any conditional statements you like, if they would work in the Rails find() method, they will work here.

More Complex Filtering

At a lower level the collection used by the table is provided by a combination of three methods:

1. count_{table_name}_collection(model, options)
2. page_and_sort_{table_name}_collection(model, options, paginator)
3. page_and_sort_{table_name}_collection_with_method(model, options, paginator)

These methods represent a slightly extended version of the methods found in the Rails paginator. The first two are called for any normal page or sort (i.e not using a ScaffoldColumn defined using the :sort parameter) and the last is called only for ScaffoldColumns defined with, wait for it, the :sort parameter.

For example lets say we have a set of Report objects that are displayed using the following column definitions:

@@scaffold_columns = [
    AjaxScaffold::ScaffoldColumn.new(Report, {
        :name => "title",
        :eval => "row.current_definition.title",
        :sort => 'current_definition.title'}),
    AjaxScaffold::ScaffoldColumn.new(Report, {
        :name => "viewed",
        :eval => "row.views",
        :sort => 'views' }),
]

We also have defined a method that returns the reports for a particular project, or the reports for a project in a particular category (all of which would be difficult to do with a simple :conditions statement):

def get_reports
  project = get_project
  reports = project.reports

  if request.post?
    selected_category = params[:category]
    reports = project.reports_for_category(selected_category) if selected_category
  end
  reports
end

We could then define the three methods above as follows (in ReportsController.rb):

def count_reports_collection(model, options)
  get_reports.size
end

def page_and_sort_reports_collection_with_method(model, options, paginator)
  collection = get_reports
  order_parts = options[:order].split(' ')
  sort_collection_by_method(collection, order_parts[0], order_parts[1]).slice(paginator.current.offset,options[:per_page])
end

def page_and_sort_reports_collection(model, options, paginator)
  page_and_sort_reports_collection_with_method(model, options, paginator)
end

This would cause every sort / page to use the with_method methods, as we need due to all columns using the :sort parameter. Our count would come from our get_reports method and everything should work as expected.

Other Extension Points

Here are some of the other methods that you can override to change the behaviour of the scaffold, its probably a good idea to actually look at the plugin code to see how each method is used, although some are pretty self explanatory.

In all of these {prefix} is defined as {table_name}_.That is the table name with an underscore appended. {suffix} is defined as _{model_name_in_lower_case}. That is the model name in lower case with an underscore prepended. These are only required in multi table scenarios (I have written it like this here to match the actual code). The reason for doing this is to give CRUD like methods when only using a single table.

Default Sort Column

By default the rows are sorted using the primary key, id. To change this you can override: default_sort / default_{prefix}sort

def default_{prefix}sort
   "users.name"
end

Default Sort Direction

To change this from ‘asc’ you can override: default_sort_direction / default_{prefix}sort_direction. The only other possible return value is “desc”.

def default_{prefix}sort_direction
   "desc"
end

Create

If you want to change the default behaviour when a model is created you can override the following method which is called internally:

def do_create#{suffix}
    @user = User.new(params[:user])
    @successful = @user.save
end

Update

If you want to change the default behaviour when a model is updated you can override the following method which is called internally:

def do_update#{suffix}
    @user = User.find(params[:id])
    @successful = @user.update_attributes(params[:user])
end

Table

To add custom behvaiour to the table rendering you can use this method. This is really to add functionality, you still need to call the methods as shown or things may go a little wrong:

def #{prefix}table
    self.#{prefix}table_setup

    OTHER CODE GOES IN HERE

    render#{suffix}_template(:action => 'table')
end

Added in 3.2.2

New

Called before the new form appears

def do_new#{suffix}
  @user = User.new
  @successful = true
end

Edit

Called to find the object to edit

def do_edit#{suffix}
  @user = User.find(params[:id])
  @successful = !@user.nil?
end

Destroy

Called to find and destroy an object

def do_destroy#{suffix}
  @successful = User.find(params[:id]).destroy
end

One of the first things you will probably notice with the Ajax Scaffold plugin (ASp) is that works great if all you want to do is display a table showing all the fields a model has to offer. However, suppose we want to produce a table showing values that come from user defined methods on a model.

For example lets take a User model with the following fields: name, password, created_at, number_of_logins. To create a table that simply shows these fields is easy, simply add the following to the UsersController:

ajax_scaffold: user

but suppose we want one of the columns to contain only the name and the average number of logins per week / per month / per year….

To this end we have coded up following 3 methods in our model:

def logins_per_month
  some great code
end

def logins_per_week
...
end

def logins_per_year
..
end

Now to get ASp to use these as columns we need to declare a set of AjaxScaffold::ScaffoldColumn objects. N.B the generator does this in the model – the plugin does it in the controller

Before going into the detail of how to implement this example lets take a quick look at the ScaffoldColumn object.

AjaxScaffold::ScaffoldColumn

This class is used internally (although we will override this in a min) by ASp (and the generator) to create the columns to be displayed. Its constructor takes the following form:

AjaxScaffold::ScaffoldColumn.new(class name, options)

The constructor of the ScaffoldColumn object takes the following options:

name – declares the column on the model we are defining, this is the only required value and will be used to infer everything else unless explicitly defined.

label – represents the display name of the column. This will be displayed as the titleized version of the name unless given explicitly.

class_name – this defines a css class name to be appended to column class declaration.

eval – is where we define the method to be called. It can be declared as row.method_name, where “row” means the actual string “row”, or as model_name.method_name

sort_sql – defines the table column to be used for sorting, usually the same as the SQL column name

sort – used to define a class method to be used for sorting (like the logins_per_year)

Users Example (single table on the page)

So back to the example, with only one table on the page (i.e the :suffix option not passed to the plugin) our custom columns can be defined by adding the following declaration to the controller:

@@scaffold_columns = [
   Array of ScaffoldColumn objects here
]

Seems easy enough, what about the columns. Ok so we have 4 columns we want displaying the first is the name of the user and then the 3 with our user defined methods. This leads to the following:

@@scaffold_columns = [
        AjaxScaffold::ScaffoldColumn.new(User, { :name => "name" }),
        AjaxScaffold::ScaffoldColumn.new(User, { :name => "per week",
          :eval => "row.logins_per_week", :sort => 'logins_per_week' }),
        AjaxScaffold::ScaffoldColumn.new(Report, { :name => "per month",
          :eval => "row.logins_per_month", :sort => 'logins_per_month' }),
        AjaxScaffold::ScaffoldColumn.new(Report, { :name => "per year",
          :eval => "row.logins_per_year", :sort => 'logins_per_year' })
]

It is worth noting that if you had an association on the User model, lets say Address (in a has relationship) you could access that information for the sort by defining something like:

AjaxScaffold::ScaffoldColumn.new(User, { :name => "postcode",
   :eval => "row.address.postcode", :sort => 'address.postcode' })

This will work to as many levels as you see fit to play with.

Users Example (multiple tables on the page)

With multiple tables on a page (:suffix passed as true), you need to update the code above to include the prefix users_:

@@users_scaffold_columns = [
.......
]

You can then do the same for any other tables in the page.

Totalling Custom Columns

To cause totals of any of your columns to be calculated and displayed simply add a second array containing the names of the columns you want to total:

@@scaffold_column_totals = ['per month', 'per year']

Remember to use the prefix if you have more than one table in the controller.