class Admin::ActivitiesController < ApplicationController include AdminLayoutHelper include ExtensibleObjectHelper # TODO: Put in a helper? def self.activities_scaffold_config(&block) @activities_scaffold_configs ||= [] @activities_scaffold_configs << block.to_proc end def self.activities_scaffold_init # I dont love this mechanism of scaffold_init - but I think its going to work quite well... configs = @activities_scaffold_configs active_scaffold(:activity){|c| configs.each{|ac| ac.call c if ac.respond_to? :call} } end # /TODO: Put in a helper? activities_scaffold_config do |config| config.label = "Activity Quick-Review" config.show.link = nil config.search.link = nil config.create.link = nil config.list.per_page = 6 config.list.sorting = { :occurred_on => :asc } config.columns = [:activity,:invoice, :occurred_on] config.columns[:occurred_on].form_ui = :calendar config.list.columns = [:activity, :occurred_on] config.create.columns = config.update.columns = [:occurred_on] config.full_list_refresh_on = [:update, :create, :destroy] # This allows us to use the for_activity_type parameter to selectively constriain fields to the appropriate record types. config.columns.instance_eval do # Column selective inclusion, based on activity_type: alias :add_without_activities :add unless self.respond_to? :add_without_activities def extend_activity_column(col) def col.for_activity_type?(type); (for_activities.length == 0 or for_activities.include? type) ? true : false; end def col.for_activities; @for_activities ||= []; end end # Extend the existing columns: @set.each{|col| extend_activity_column col} # And ensure that we continue to do the same for new ones here on: def add(*args) add_without_activities *args args.flatten.collect { |a| extend_activity_column find_by_name(a.to_sym) } end alias :<< :add end end private def do_activity_type_for_method?(method_name) self.respond_to? "#{@record.activity_type}_#{method_name}".to_sym end def do_activity_type_for_method(*args) method_name = args.shift unless @record.nil? activity_action = "#{@record.activity_type}_#{method_name}".to_sym self.send( *([activity_action] + args) ) if self.respond_to? activity_action end end def conditions_for_collection ['activities.is_published = ?', 0] if params[:parent_model].nil? end def list_row_class(record) record.activity_type end def do_edit super do_activity_type_for_method :do_edit end def do_update super do_activity_type_for_method :do_update end def before_update_save(record) super(record) record.is_published = true do_activity_type_for_method :before_update_save, record end def update_record_from_params(activity_record, columns, attributes) activity_params = HashWithIndifferentAccess.new subactivity_params = HashWithIndifferentAccess.new attributes.delete 'apply_tax' attributes.each_pair { |k,v| ((/^(occurred_on|is_published|cost|tax|client_id)/.match k) ? activity_params : subactivity_params )[k] = v } activity_record = super(activity_record, columns, activity_params) activity_record.sub_activity.attributes = subactivity_params if subactivity_params.length > 0 activity_record end def do_list super records_by_type = {} @records.each do |r| records_by_type[r.activity_type] ||= [] records_by_type[r.activity_type] << r end records_by_type.each_pair do |activity_type, records| do_list_action = "#{activity_type}_do_list".to_sym self.send( do_list_action, records) if self.respond_to? do_list_action end end public def row # I think they should have had a do_row in active scaffold .... record = find_if_allowed(params[:id], :read) do_list_action = "#{record.activity_type}_do_list".to_sym self.send( do_list_action, [record]) if self.respond_to? do_list_action render :partial => 'list_record', :locals => {:record => record} end handle_extensions activities_scaffold_init end