crud 0.0.3

data/app/controllers/crud/crud_base_controller.rb

@@ -0,0 +1,28 @@
+module Crud
+  #class CrudBaseController < ActionController::Base
+  class CrudBaseController < ::Crud.parent_controller.constantize
+
+    helper ::Crud::CrudHelper
+
+    # Make these methods available to views
+    helper_method :is_allowed_to_view?
+    helper_method :is_allowed_to_update?
+
+    def is_allowed_to_view?
+      ::Crud.is_allowed_to_view
+    end
+
+    def is_allowed_to_update?
+      ::Crud.is_allowed_to_update
+    end
+
+    protected
+
+    def back_url
+      params[:back_url] || request.env['HTTP_REFERER'] || root_url
+    end
+
+    private
+
+  end
+end

data/app/controllers/crud/crud_controller.rb

@@ -0,0 +1,149 @@
+require_dependency "crud/crud_base_controller"
+
+module Crud
+  class CrudController < CrudBaseController
+    around_filter :catch_not_found
+
+    before_filter :is_allowed_to_view?, :only => [:index, :show]
+    before_filter :is_allowed_to_update?, :only => [:new, :create, :edit, :update, :destroy, :delete]
+    before_filter :get_klass_info_from_params
+    before_filter :get_visible_attributes
+
+    # GET
+    def index
+      @search_prompt = I18n.t(:search_prompt)
+
+      page = (params[:page]) ? params[:page].to_i : 1
+      per_page = (params[:per_page]) ? params[:per_page].to_i : 10
+
+      if( params[:search] && !params[:search].empty? && params[:search] != @search_prompt)
+        where_clause = ''
+        @visible_attributes.each do |attribute|
+          where_clause += "LOWER(#{attribute[:column_name]}) LIKE '%#{params[:search].downcase}%' OR " if attribute[:column_data_type] == :string
+        end
+        where_clause.sub!(/ OR $/,'')
+      else
+        where_clause = nil
+      end
+
+      primary_key_name = @klass_info.primary_key(@klass_info[:class])
+      if primary_key_name
+        @klass_data = @klass_info[:class].where(where_clause).paginate(:page => page, :per_page => per_page).order("#{primary_key_name} ASC")
+      else
+        @klass_data = @klass_info[:class].where(where_clause).paginate(:page => page, :per_page => per_page)
+      end
+
+      respond_to do |format|
+        format.html # index.html.erb
+        format.js   # index.js.erb
+        format.json { render :json => @klass_data }
+        format.xml  { render :xml => @klass_data }
+      end
+    end
+
+    # GET
+    def show
+      @klass_data = @klass_info[:class].find(params[:id])
+
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render :json => @klass_data }
+        format.xml  { render :xml => @klass_data }
+      end
+    end
+
+    # GET
+    def new
+      @klass_data = @klass_info[:class].new
+
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render :json => @klass_data }
+        format.xml  { render :xml => @klass_data }
+      end
+    end
+
+    # GET
+    def edit
+      @klass_data = @klass_info[:class].find(params[:id])
+    end
+
+    # POST
+    def create
+      @klass_data = @klass_info[:class].new(params[@klass_info[:name_as_sym]])
+
+      respond_to do |format|
+        if @klass_data.save
+          format.html { redirect_to show_path(:class_name => @klass_info[:name], :id => @klass_data.id), :notice => "#{@klass_info[:name]} was successfully created" }
+          format.json { render :json => @klass_data, :status => :created, :location => @klass_data }
+          format.xml  { head :ok }
+        else
+          format.html { render :action => 'new' }
+          format.json { render :json => @klass_data.errors, :status => :unprocessable_entity }
+          format.xml  { render :xml => @klass_data.errors, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+    # PUT
+    def update
+      @klass_data = @klass_info[:class].find(params[:id])
+
+      respond_to do |format|
+        if @klass_data.update_attributes(params[@klass_info[:name_as_sym]])
+          format.html { redirect_to show_path(:class_name => @klass_info[:name], :id => @klass_data.id), :notice => "#{@klass_info[:name]} was successfully updated" }
+          format.json { head :no_content }
+          format.xml  { head :ok }
+        else
+          format.html { render :action => 'edit' }
+          format.json { render :json => @klass_data.errors, :status => :unprocessable_entity }
+          format.xml  { render :xml => @klass_data.errors, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE
+    def delete
+      @klass_data = @klass_info[:class].find(params[:id])
+      @klass_data.delete
+
+      respond_to do |format|
+        format.html { redirect_to index_path(:class_name => @klass_info[:name]), :notice => "#{@klass_info[:name]}[#{params[:id]}] was successfully deleted" }
+        format.json { head :no_content }
+        format.xml  { head :ok }
+      end
+    end
+
+    # DELETE
+    def destroy
+      @klass_data = @klass_info[:class].find(params[:id])
+      @klass_data.destroy
+
+      respond_to do |format|
+        format.html { redirect_to index_path(:class_name => @klass_info[:name]), :notice => "#{@klass_info[:name]}[#{params[:id]}] was successfully destroyed" }
+        format.json { head :no_content }
+        format.xml  { head :ok }
+      end
+    end
+
+    private
+
+    def get_klass_info_from_params
+      if params[:class_name]
+        @klass_info = ::Crud::KlassInfo.new(params[:class_name].constantize)
+      else
+        render :text => "Missing class identifier"
+      end
+    end
+
+    def get_visible_attributes
+      @visible_attributes =  @klass_info.visible_attributes(self.action_name.to_sym)
+    end
+
+    def catch_not_found
+      yield
+    rescue ActiveRecord::RecordNotFound
+      redirect_to back_url, :flash => { :error => "#{@klass_info[:name]} record with id=[#{params[:id]}] not found" }
+    end
+  end
+end

data/app/controllers/crud/dashboard_controller.rb

@@ -0,0 +1,17 @@
+require_dependency "crud/crud_base_controller"
+
+module Crud
+  class DashboardController < CrudBaseController
+    before_filter :is_allowed_to_view?, :only => [:index]
+    before_filter :get_klass_list
+
+    def index
+    end
+
+    private
+
+    def get_klass_list
+      @klass_list = Crud::KlassList.new() unless @klass_list
+    end
+  end
+end

data/app/helpers/crud/crud_helper.rb

@@ -0,0 +1,104 @@
+module Crud
+  module CrudHelper
+
+    def options_for_select_tag
+      options_for_select(@klass_list.all.collect{|klass| [klass.to_s, index_path(:class_name => klass)]})
+    end
+
+    def edit_field_for_attribute(klass_info, row, attribute, f)
+      begin
+        html = []
+        if ['id','created_at', 'updated_at'].include?(attribute[:column_name])
+          html << '(auto)'
+        elsif attribute[:association] == :belongs_to
+          unless(attribute[:association_polymorphic])
+            html << f.collection_select(attribute[:column_name].to_sym, attribute[:association_class].all, :id, :to_s, :include_blank => true)
+          else
+            associated_attribute = klass_info.associated_polymorphic_attribute(attribute)
+            if associated_attribute && associated_attribute.length == 1 && row.attributes[associated_attribute[0][:column_name]]
+              html << f.collection_select(attribute[:column_name].to_sym, row.attributes[associated_attribute[0][:column_name]].constantize.all, :id, :to_s, :include_blank => true)
+            else
+              html << f.text_field(attribute[:column_name].to_sym)
+            end
+          end
+        else
+          case attribute[:column_data_type]
+          when :text
+            html << f.text_area(attribute[:column_name].to_sym, :rows => 6, :cols => 80)
+          when :datetime
+            html << f.datetime_select(attribute[:column_name].to_sym, :include_blank => true)
+          when :date
+            html << f.date_select(attribute[:column_name].to_sym, :discard_year => false, :include_blank => true)
+          when :time
+            html << f.time_select(attribute[:column_name].to_sym, :include_seconds => true, :include_blank => true)
+          when :boolean
+            html << f.select(attribute[:column_name].to_sym, [['True', true], ['False', false]], :include_blank => true)
+          else
+            html << f.text_field(attribute[:column_name].to_sym)
+          end
+        end
+        html.join
+      rescue Exception => e
+        Rails.logger.info "#{e.class}: #{e.message}#$/#{e.backtrace.join($/)}"
+        "problem constructing edit field for '#{attribute[:column_name].to_s}'"
+      end
+    end
+
+    def render_attribute_value(attribute, klass_data)
+      # Parameters :attribute => attribute, :klass_data => row_data
+      custom_fields = @klass_info.custom_fields(attribute[:column_name], controller.action_name.to_sym)
+      custom_fields_contain_a_replacement = @klass_info.custom_fields_contain_a_replacement(custom_fields)
+
+      unless custom_fields_contain_a_replacement
+        attribute_value_from_row = @klass_info.attribute_value_from_row(attribute, klass_data)
+        formatted_output = attribute_value_from_row[1] ? "[#{attribute_value_from_row[0]}] #{attribute_value_from_row[1]}" : "#{attribute_value_from_row[0]}"
+
+        unless (attribute[:association] && attribute[:association] == :belongs_to)
+          return formatted_output
+        else
+          unless attribute[:association_polymorphic]
+            return link_to formatted_output, show_path(:class_name => attribute[:association_class].name, :id => attribute_value_from_row[0])
+          else
+            associated_polymorphic_class = @klass_info.associated_polymorphic_class(attribute, klass_data)
+            if associated_polymorphic_class
+              return link_to formatted_output, show_path(:class_name => associated_polymorphic_class.name, :id => attribute_value_from_row[0])
+            else
+              return formatted_output
+            end
+          end
+        end
+      else
+        ''.html_safe
+      end
+
+    end
+
+    def render_custom_fields(attribute, klass_data, klass_info)
+      out = ''
+
+      custom_fields = klass_info.custom_fields(attribute[:column_name], controller.action_name.to_sym)
+      custom_fields.each do |field|
+        out += render field[:partial], {field[:record_data_parameter].to_sym => klass_data}.merge(field[:additional_partial_parameters])
+        out += '<br/>'
+      end
+
+      out.html_safe
+    end
+
+    def render_attribute_value_and_custom_fields(attribute, klass_data, klass_info)
+      (render_attribute_value(attribute, klass_data) + render_custom_fields(attribute, klass_data, klass_info)).html_safe
+    end
+
+    private
+
+    # Handler to send application URIs back to the application
+    def method_missing(method, *args, &block)
+      if (method.to_s.end_with?('_path') || method.to_s.end_with?('_url')) && main_app.respond_to?(method)
+        main_app.send(method, *args)
+      else
+        super
+      end
+    end
+
+  end
+end

data/app/helpers/crud/dashboard_helper.rb

@@ -0,0 +1,4 @@
+module Crud
+  module DashboardHelper
+  end
+end

data/app/models/crud/klass_info.rb

@@ -0,0 +1,166 @@
+# Model data
+module Crud
+  class KlassInfo < Hash
+
+    def initialize(class_name)
+      self[:name] = class_name.to_s
+      namespace_parts = self[:name].match(/(.+)::(.+)/)
+      self[:namespace] = namespace_parts ? "::#{namespace_parts[1]}::" : ''
+      self[:name_as_sym] = self[:name].gsub(/::/,'_').underscore.to_sym
+      self[:class] = self[:name].constantize
+      self[:column_settings] = ::Crud.column_settings.select {|v| ["::#{self[:name]}", self[:name], 'all'].include?(v[:class].to_s)}
+      self[:custom_fields] = ::Crud.custom_fields.select {|v| ["::#{self[:name]}", self[:name]].include?(v[:class].to_s)}
+      self[:custom_fields].each {|field| field[:additional_partial_parameters] ||= {}}
+
+      if self[:class].respond_to?(:reflections)
+
+        self[:attributes] = []
+
+        self[:class].columns.each_index do |i|
+          self[:attributes][i] = {}
+          self[:attributes][i][:column_name] = self[:class].column_names[i]
+          self[:attributes][i][:column_class_type] = self[:class].column_names[i].class
+          self[:attributes][i][:column_data_type] = self[:class].columns[i].type
+
+          # Initialise belongs_to associations
+          reflection_value = belongs_to_reflection_values.select {
+            |k| k.name == self[:attributes][i][:column_name].sub(/_id$/,'').to_sym
+          }[0]
+
+          if reflection_value
+            self[:attributes][i][:association] = reflection_value.macro
+            self[:attributes][i][:association_polymorphic] = reflection_value.options[:polymorphic] ? reflection_value.options[:polymorphic] : false
+            self[:attributes][i][:association_class] = association_class_for_reflection_value(reflection_value, :belongs_to, self[:attributes][i])
+          end
+        end
+
+        self[:has_one] = []
+        self[:has_many] = []
+        self[:has_and_belongs_to_many] = []
+
+        has_one_reflection_values.each_with_index do |reflection_value, i|
+          self[:has_one][i] = {}
+          self[:has_one][i][:association_name] = reflection_value.name
+          self[:has_one][i][:association_class] = association_class_for_reflection_value(reflection_value, :has_one)
+        end
+
+        has_many_reflection_values.each_with_index do |reflection_value, i|
+          self[:has_many][i] = {}
+          self[:has_many][i][:association_name] = reflection_value.name
+          self[:has_many][i][:association_class] = association_class_for_reflection_value(reflection_value, :has_many)
+        end
+
+        habtm_reflection_values.each_with_index do |reflection_value, i|
+          self[:has_and_belongs_to_many][i] = {}
+          self[:has_and_belongs_to_many][i][:association_name] = reflection_value.name
+          self[:has_and_belongs_to_many][i][:association_class] = association_class_for_reflection_value(reflection_value, :has_and_belongs_to_many)
+        end
+      end
+    end
+
+    def primary_key(klass)
+      klass.respond_to?(:primary_key) ? klass.primary_key : 'id'
+    end
+
+    def self.primary_key_is_id?(klass)
+      (klass.respond_to?(:primary_key) && klass.primary_key == 'id')
+    end
+
+    def row_id(row)
+      row.send( self.primary_key(row) )
+    end
+
+    def attribute_value_from_row(attribute, row)
+      if attribute[:association] == :belongs_to
+        association_id = row.attributes[attribute[:column_name]].to_i
+
+        unless(attribute[:association_polymorphic])
+          association_value = attribute[:association_class].find(association_id)
+        else
+          associated_attribute = associated_polymorphic_attribute(attribute)
+          if associated_attribute && associated_attribute.length == 1
+            association_value = row.attributes[associated_attribute[0][:column_name]].constantize.find(association_id)
+          end
+        end unless (association_id==0)
+      end
+
+      ["#{row.attributes[attribute[:column_name]]}", (association_value ? "#{association_value}" : nil)]
+    end
+
+    def associated_polymorphic_class(attribute, row = nil)
+      associated_class = nil
+      if (row)
+        associated_attribute = associated_polymorphic_attribute(attribute)
+        if associated_attribute && associated_attribute.length == 1 && row.attributes[associated_attribute[0][:column_name]]
+          associated_class = row.attributes[associated_attribute[0][:column_name]].constantize
+        end
+      end
+      associated_class
+    end
+
+    def associated_polymorphic_attribute(attribute)
+      self[:attributes].select do |attr|
+        attr[:column_name] == attribute[:column_name].sub(/_id$/,"_type")
+      end if attribute[:association_polymorphic]
+    end
+
+    def visible_attributes(page)
+      self[:attributes].select { |v| is_visible_attribute?(v[:column_name], page) }
+    end
+
+    def is_visible_attribute?(column, page)
+      ( self[:column_settings].select {|v| (v[:hidden_fields] ? v[:hidden_fields].include?(column.to_sym) : false) && (v[:only] ? v[:only].include?(page.to_sym) : true)} ).empty?
+    end
+
+    def custom_fields(column, page = nil)
+      self[:custom_fields].select {|v| (v[:column_name] ? v[:column_name] == column.to_s : false) && (v[:global] ? v[:global] == false : true) && ((page && v[:only]) ? v[:only].include?(page.to_sym) : true)}
+    end
+
+    def global_custom_fields(page = nil)
+      self[:custom_fields].select {|v| (v[:global] ? v[:global] == true : false) && ((page && v[:only]) ? v[:only].include?(page.to_sym) : true)}
+    end
+
+    def custom_fields_contain_a_replacement(fields)
+      replacement_fields = fields.select {|v| (v[:column_replacement] ? v[:column_replacement] == true : false)}
+      (replacement_fields.length > 0)
+    end
+
+    private
+
+    def belongs_to_reflection_values()
+      reflection_values_for_klass(:belongs_to)
+    end
+
+    def has_one_reflection_values()
+      reflection_values_for_klass(:has_one)
+    end
+
+    def has_many_reflection_values()
+      reflection_values_for_klass(:has_many)
+    end
+
+    def habtm_reflection_values()
+      reflection_values_for_klass(:has_and_belongs_to_many)
+    end
+
+    def reflection_values_for_klass(association_type)
+      self[:class].reflections.values.select do |value|
+        value.macro == association_type
+      end
+    end
+
+    def association_class_for_reflection_value(reflection_value, association_type, attribute = nil, row = nil)
+      association_class = reflection_value.options[:class_name] ?
+        reflection_value.options[:class_name].to_s.sub(/^class_name/,'') :
+        [:has_many, :has_and_belongs_to_many].include?(association_type) ?
+        "#{self[:namespace]}#{reflection_value.name.to_s.camelize.classify}" : "#{self[:namespace]}#{reflection_value.name.to_s.camelize}"
+
+      if (attribute && attribute[:association_polymorphic])
+        associated_polymorphic_class(attribute, row)
+      else
+        association_class.constantize
+      end
+    end
+
+  end
+end