the_jobbook_admin_data 1.3.0a

data/app/controllers/admin_data/crud_controller.rb

@@ -0,0 +1,100 @@
+module AdminData
+
+  class CrudController  < ApplicationController
+
+    before_filter :get_class_from_params, :only => [:show, :destroy, :del, :edit, :new, :update, :create]
+
+    before_filter :get_model_and_verify_it, :only => [:destroy, :del, :edit, :update, :show]
+
+    before_filter :ensure_is_allowed_to_update, :only => [:destroy, :del, :edit, :update, :create]
+
+    def show
+      @page_title = "#{@klass.name.underscore}:#{@model.id}"
+      respond_to {|format| format.html}
+    end
+
+    def destroy
+      @klass.send(:destroy, params[:id])
+      redirect_to admin_data_search_path(:klass => @klass.name.underscore)
+    end
+
+    def del
+      @klass.send(:delete, params[:id])
+      flash[:success] = 'Record was deleted'
+      redirect_to admin_data_search_path(:klass => @klass.name.underscore)
+    end
+
+    def edit
+      @page_title = "edit #{@klass.name.underscore}:#{@model.id}"
+      @columns = columns_list
+      respond_to {|format| format.html}
+    end
+
+    def new
+      @page_title = "new #{@klass.name.underscore}"
+      @model = @klass.send(:new)
+      @columns = columns_list
+      respond_to {|format| format.html}
+    end
+
+    def update
+      model_attrs = params[@klass.name.underscore]
+      @columns = columns_list
+
+      respond_to do |format|
+        if @model.update_attributes(model_attrs)
+          format.html do
+            flash[:success] = "Record was updated"
+            redirect_to admin_data_path(:id => @model.id, :klass => @klass.name.underscore)
+          end
+          format.js { render :json => {:success => true}}
+        else
+          format.html { render :action => 'edit' }
+          format.js { render :json => {:error => @model.errors.full_messages.join } }
+        end
+      end
+    end
+
+    def create
+      model_attrs = params[@klass.name.underscore]
+      @model = @klass.create(model_attrs)
+      @columns = columns_list
+
+      respond_to do |format|
+        if @model.errors.any?
+          format.html { render :action => 'new' }
+          format.js { render :json => {:error => @model.errors.full_messages.join() }}
+        else
+          format.html do
+            flash[:success] = "Record was created"
+            redirect_to admin_data_path(:id => @model.id, :klass => @klass.name.underscore)
+          end
+          format.js { render :json => {} }
+        end
+      end
+    end
+
+    private
+
+    def get_model_and_verify_it
+      primary_key = @klass.primary_key.intern
+      conditional_id = params[:id] =~ /^(\d+)-.*/ ? params[:id].to_i : params[:id]
+      condition = {primary_key => conditional_id}
+
+      _proc = AdminData.config.find_conditions[@klass.name]
+      if _proc && (find_conditions = _proc.call(params)) && find_conditions.has_key?(:conditions)
+        condition = find_conditions.fetch(:conditions)
+      end
+
+      unless @model = @klass.find(:first, :conditions => condition)
+        render :text => "#{@klass.name} not found: #{params[:id]}"
+        return
+      end
+    end
+
+    def columns_list
+      params[:attr].blank? ? @klass.columns : @klass.columns.find_all {|col| params[:attr] == col.name}
+    end
+
+  end
+end

data/app/controllers/admin_data/feed_controller.rb

@@ -0,0 +1,48 @@
+module AdminData
+
+  class FeedController < ApplicationController
+
+    before_filter :ensure_is_allowed_to_view_feed
+
+    def index
+      if params[:klasss].blank?
+        render :text => "Usage: http://localhost:3000/admin_data/feed/user replace user with your model name"
+        return
+      end
+
+      begin
+        @klass = Util.camelize_constantize(params[:klasss])
+        @title = "Feeds from admin_data #{@klass.name}"
+        @description = "feeds from AdminData #{@klass.name}"
+        @records = @klass.find(:all, :order => "#{@klass.primary_key} desc", :limit => 100)
+      rescue NameError
+        render :text => "No constant was found with name #{params[:klasss]}"
+      end
+    end
+
+    private
+
+    def ensure_is_allowed_to_view_feed
+      render :text => 'not authorized' unless is_allowed_to_view_feed?(self)
+    end
+
+    def is_allowed_to_view_feed?(controller)
+      return true if Rails.env.development?
+
+      if AdminData.config.feed_authentication_user_id.blank?
+        Rails.logger.info 'No user id has been supplied for feed'
+        return false
+      elsif AdminData.config.feed_authentication_password.blank?
+        Rails.logger.info 'No password has been supplied for feed'
+        return false
+      end
+
+      userid = AdminData.config.feed_authentication_user_id
+      password = AdminData.config.feed_authentication_password
+      authenticator = AdminData::Authenticator.new(userid, password)
+      authenticator.verify(controller)
+    end
+
+  end
+
+end

data/app/controllers/admin_data/home_controller.rb

@@ -0,0 +1,8 @@
+module AdminData
+  class HomeController < ApplicationController
+    respond_to :html
+
+    def index
+    end
+  end
+end

data/app/controllers/admin_data/migration_controller.rb

@@ -0,0 +1,18 @@
+module AdminData
+  class MigrationController < ApplicationController
+
+    before_filter :ensure_is_allowed_to_view
+
+    def index
+      @page_title = 'migration information'
+      @data = ActiveRecord::Base.connection.select_all('select * from schema_migrations')
+      respond_to {|format| format.html}
+    end
+
+    def jstest
+      @page_title = 'jstest'
+      respond_to {|format| format.html { render :layout => false}}
+    end
+
+  end
+end

data/app/controllers/admin_data/public_controller.rb

@@ -0,0 +1,28 @@
+module AdminData
+  class PublicController < ApplicationController
+
+    def serve
+      path = File.join(AdminData::LIBPATH, '..', 'app', 'assets', params[:file])
+
+      unless File.expand_path(path) =~ /admin_data/
+        render :nothing => true, :status => 404 and return
+      end
+
+      case params[:format].to_s.downcase
+      when 'css'
+        content_type = "text/css"
+      when 'js'
+        content_type = "text/javascript"
+      when 'png'
+        content_type = "image/png"
+      when 'jpg'
+        content_type = "image/jpg"
+      else
+        render :nothing => true, :status => 404 and return
+      end
+
+      render({:text => File.read("#{path}.#{params[:format]}"), :cache => true, :content_type => content_type})
+    end
+
+  end
+end

data/app/controllers/admin_data/search_controller.rb

@@ -0,0 +1,143 @@
+class SearchAction
+  attr_accessor :relation, :success_message
+
+  def initialize(relation)
+    @relation = relation
+  end
+
+  def delete
+    count = relation.count
+    relation.delete_all
+    self.success_message = "#{count} #{AdminData::Util.pluralize(count, 'record')} deleted"
+  end
+
+  def destroy
+    count = relation.count
+    relation.find_in_batches do |group|
+      group.each {|record| record.destroy }
+    end
+    self.success_message = "#{count} #{AdminData::Util.pluralize(count, 'record')} destroyed"
+  end
+end
+
+module AdminData
+  class SearchController < ApplicationController
+
+    layout 'search'
+
+    include AdminData::Search
+
+    before_filter :get_class_from_params
+    before_filter :ensure_valid_children_klass, :only => [:quick_search]
+    before_filter :ensure_is_authorized_for_update_opration, :only => [:advance_search]
+    before_filter :set_column_type_info, :only => [:advance_search]
+    before_filter :handle_sorting
+
+
+    def quick_search
+      @page_title = "Search #{@klass.name.underscore}"
+      order = default_order
+
+      if params[:base]
+        klass = Util.camelize_constantize(params[:base])
+        model = klass.find(params[:model_id])
+        has_many_proxy = model.send(params[:children].intern)
+        @total_num_of_children = has_many_proxy.send(:count)
+        h = { :page => params[:page], :per_page => per_page, :order => order }
+        @records = has_many_proxy.send(:paginate, h)
+      else
+        params[:query] = params[:query].strip unless params[:query].blank?
+        cond = build_quick_search_condition(@klass, params[:query])
+        h = { :page => params[:page], :per_page => per_page, :order => order, :conditions => cond }
+        @records = @klass.unscoped.paginate(h)
+      end
+      respond_to {|format| format.html}
+    end
+
+
+    def advance_search
+      @page_title = "Advance search #{@klass.name.underscore}"
+      hash = build_advance_search_condition(@klass, params[:adv_search])
+      relation = hash[:cond]
+      errors = hash[:errors]
+      order = default_order
+
+      respond_to do |format|
+        format.html { render }
+        format.js {
+
+          unless hash[:errors].blank?
+            file = File.join(AdminData::LIBPATH, '..', 'app','views', 'admin_data', 'search', 'search', '_errors.html.erb')
+            render :file =>  file, :locals => {:errors => errors}
+            return
+          end
+
+          search_action = SearchAction.new(relation)
+
+          case params[:admin_data_advance_search_action_type]
+          when 'destroy'
+            search_action.destroy
+          when 'delete'
+            search_action.delete
+          else
+            @records = relation.order(order).paginate(:page => params[:page], :per_page => per_page)
+          end
+
+          if search_action.success_message
+            render :json => {:success => search_action.success_message }
+          else
+            file = "/admin_data/search/search/listing.html.erb"
+            render :partial => file, :locals => {:klass => @klass}, :layout => false
+          end
+        }
+      end
+    end
+
+    private
+
+    def ensure_valid_children_klass
+      if params[:base]
+        begin
+          model_klass = Util.camelize_constantize(params[:base])
+        rescue NameError => e #incase params[:base] is junk value
+          render :text => "#{params[:base]} is an invalid value", :status => :not_found
+          return
+        end
+
+        ar_util = ActiveRecordUtil.new(model_klass)
+        if ar_util.declared_has_many_association_names.include?(params[:children]) || ar_util.declared_habtm_association_names.include?(params[:children])
+          #proceed
+        else
+          render :text => "#{params[:children]} is not a valid has_many association", :status => :not_found
+          return
+        end
+      end
+    end
+
+    def ensure_is_authorized_for_update_opration
+      if %w(destroy delete).include? params[:admin_data_advance_search_action_type]
+        render :text => 'not authorized' unless is_allowed_to_update?
+      end
+    end
+
+    def default_order
+      params[:sortby] || "#{@klass.send(:table_name)}.#{@klass.send(:primary_key)} desc"
+    end
+
+    def set_column_type_info
+      column_type_info = @klass.columns.collect { |column|
+        #JSLint complains if a hash has key named boolean. So I am changing the key to booleant
+        column_type =  (column.type.to_s == 'boolean') ? 'booleant' : column.type.to_s
+        %Q{ "#{column.name}":"#{column_type}" }
+      }.join(',')
+      @column_type_info = "{#{column_type_info}}"
+    end
+
+    def handle_sorting
+      sort_order = params[:sortby] || 'id desc'
+      @sort_by_column_name, @sort_order = sort_order.split
+      @sort_css = @sort_order == 'asc' ? 'sort_by_asc' : 'sort_by_desc'
+    end
+
+  end
+end

data/app/controllers/admin_data/table_structure_controller.rb

@@ -0,0 +1,25 @@
+module AdminData
+  class TableStructureController < ApplicationController
+
+    before_filter :get_class_from_params
+
+    def index
+      @page_title = 'table_structure'
+      @indexes = []
+      if (indexes = ActiveRecord::Base.connection.indexes(@klass.table_name)).any?
+        add_index_statements = indexes.map do |index|
+          statment_parts = [ ('add_index ' + index.table.inspect) ]
+          statment_parts << index.columns.inspect
+          statment_parts << (':name => ' + index.name.inspect)
+          statment_parts << ':unique => true' if index.unique
+
+          '  ' + statment_parts.join(', ')
+        end
+        add_index_statements.sort.each { |index| @indexes << index }
+      end
+      respond_to {|format| format.html}
+    end
+
+  end
+end
+

data/app/helpers/admin_data/application_helper.rb

@@ -0,0 +1,320 @@
+module AdminData
+  module ApplicationHelper
+
+    def get_sort_order(column)
+      if column == @sort_by_column_name && @sort_order == 'desc'
+        "#{column} asc"
+      else
+        "#{column} desc"
+      end
+    end
+
+    def get_sort_title_with_url(column, klass)
+      order = get_sort_order(column)
+      link_to column_title(klass, column), search_path(:klass => klass, :query => params[:query], :sortby => order)
+    end
+
+    def get_sort_class(column)
+      sort_class = 'sortable'
+      if column == @sort_by_column_name
+        sort_class << ' ' + @sort_css
+      end
+      sort_class
+    end
+
+    def parent_layout(layout)
+      content_for(:layout, self.output_buffer)
+      self.output_buffer = render(:file => "layouts/#{layout}")
+    end
+
+    def column_title(klass, column)
+      AdminData.config.column_headers[klass.name].try(:fetch,column.intern, nil) || column
+    end
+
+    # AdminData.config.columns_order might not list all the columns of a given table. However
+    # the listed columns should be at the front in the order mentioned. Primary key will also
+    # be the first column. Consumer might define a new column name that is not listed a column.
+    #
+    def columns_order(klass)
+      columns_symbol = klass.columns.map {|e| e.name.intern}
+
+      # created_at and updated_at should be at the very end by default
+      if columns_symbol.include? :created_at
+        columns_symbol = (columns_symbol - [:created_at]) + [:created_at]
+      end
+      if columns_symbol.include? :updated_at
+        columns_symbol = (columns_symbol - [:updated_at]) + [:updated_at]
+      end
+
+      if requested_order = AdminData.config.columns_order[klass.name]
+        primary_key = klass.send(:primary_key).intern
+        order = [primary_key] + requested_order
+        order.uniq!
+        # add the columns not covered by user at the end of the list
+        sorted_columns = order + (columns_symbol - order)
+        sorted_columns.map(&:to_s)
+      else
+        columns_symbol.map(&:to_s)
+      end
+    end
+
+    def total_records_info(klass)
+      '(Total ' + pluralize(klass.count, 'record') + ' )'
+    end
+
+    def search_result_title(total_num_of_children, records)
+      output = []
+      if params[:base]
+        label = params[:base].camelize + ' ID ' + params[:model_id]
+        output << link_to(label, admin_data_path(:klass => params[:base], :id => params[:model_id]))
+        output << 'has'
+        output << pluralize(total_num_of_children, params[:klass])
+
+      elsif !params[:query].blank? || params[:adv_search]
+        output << 'Search result:'
+        output << pluralize(records.total_entries, 'record')
+        output << 'found'
+
+      else
+        output << 'All '
+        output << params[:klass].camelize
+        output << 'records'
+      end
+      output.join(' ').html_safe
+    end
+
+    def column_native(klass, column)
+      klass.send(:columns).select {|r| r.instance_variable_get('@name') == column}.first || column
+    end
+
+    def has_one(model, klass)
+      tmp = ActiveRecordUtil.new(klass).declared_has_one_association_names
+      tmp.inject('') do |output, ho|
+        begin
+          label = ho
+          if model.send(ho)
+            output << link_to(label, admin_data_path(:klass => ho.underscore, :id => model.send(ho)))
+          else
+            output << label
+          end
+        rescue => e
+          Rails.logger.debug Util.exception_info(e)
+        end
+        output
+      end
+    end
+
+    def has_many_data(model, klass)
+      array = ActiveRecordUtil.new(klass).declared_has_many_association_names.map do |m|
+        begin
+          count = model.send(m.intern).count
+          label = m.to_s + '(' + count.to_s + ')'
+          output = label
+          if count > 0
+            has_many_klass_name = ActiveRecordUtil.new(model.class).klass_for_association_type_and_name(:has_many, m).name.underscore
+            output = link_to(label, search_path(  :klass => has_many_klass_name,
+            :children => m,
+            :base => klass.name.underscore,
+            :model_id => model.id))
+          end
+        rescue => e
+          Rails.logger.debug Util.exception_info(e)
+        end
+        output
+      end
+      array.join(', ')
+    end
+
+    def belongs_to_data(model, klass)
+      ActiveRecordUtil.new(klass).declared_belongs_to_association_names.map do |assoc_name|
+        begin
+          output = assoc_name
+          if belongs_to_record = model.send(assoc_name)
+            output = link_to(assoc_name, admin_data_path(:klass => belongs_to_record.class.name.underscore, :id => belongs_to_record.id))
+          end
+        rescue => e
+          Rails.logger.info Util.exception_info(e)
+        end
+        output
+      end.join(', ')
+    end
+
+    def habtm_data(model, klass)
+      ActiveRecordUtil.new(klass).declared_habtm_association_names.map do |assoc_name|
+        begin
+          count = model.send(assoc_name.intern).count
+          label = assoc_name + '(' + count.to_s + ')'
+          output = label
+
+          if count > 0 then
+            has_many_klass_name = ActiveRecordUtil.new(model.class).klass_for_association_type_and_name(:has_and_belongs_to_many, assoc_name).name.underscore
+            output = link_to(label, search_path(  :klass => has_many_klass_name,
+            :children => assoc_name,
+            :base => klass.name.underscore,
+            :model_id => model.id))
+          end
+        rescue => e
+          Rails.logger.info Util.exception_info(e)
+        end
+        output
+      end.join(', ')
+    end
+
+    def breadcrum(&block)
+      render(:partial => '/admin_data/shared/breadcrum', :locals => {:data => capture(&block)})
+    end
+
+    def form_field(klass, model, col, f)
+      html = []
+      column_value = model.send(col.name)
+
+      if klass.serialized_attributes.has_key?(col.name)
+        return Util.get_serialized_value(html,column_value)
+      end
+
+      if col.primary
+        html <<  model.new_record? ? '(auto)' : model.id
+      elsif get_reflection_for_column(klass, col) && AdminData.config.display_assoc?( klass.name )
+        form_field_for_association_records(klass, col, f, html)
+      else
+        handle_column_type(col, html, model, column_value, f)
+      end
+    end
+
+
+    def form_field_for_association_records(klass, col, f, html)
+      begin
+        reflection = get_reflection_for_column(klass, col)
+
+        # in some edge cases following code throws exception. investigating ..
+        options = reflection.options
+        if options.keys.include?(:polymorphic) && options.fetch(:polymorphic)
+          build_text_field(html, f, col)
+        else
+          ref_klass = reflection.klass
+          association_name = ref_klass.columns.map(&:name).include?('name') ? :name : ref_klass.primary_key
+          all_for_dropdown = ref_klass.all(:order => "#{association_name} asc")
+          html << f.collection_select(col.name, all_for_dropdown, :id, association_name, :include_blank => true)
+        end
+        html.join
+      rescue Exception => e
+        Rails.logger.info Util.exception_info(e)
+        'could not retrieve' # returning nil
+      end
+    end
+
+    def form_field_for_habtm_records(klass, model, f, html)
+      begin
+        html = []
+        ActiveRecordUtil.new(klass).delcared_habtm_association_names.each do |k|
+          assoc_klass = Util.get_class_name_for_habtm_association(model, k)
+
+          html << "<div class='col_box'>"
+          html << "  <span class='col_name'>#{assoc_klass.table_name}</span>"
+          html << "  <span class='col_type'>[integer]</span>"
+          html << "</div>"
+
+          order_by = assoc_klass.columns.map(&:name).include?('name') ? :name : assoc_klass.primary_key
+          all = assoc_klass.all(:order => order_by)
+          selected = model.send(assoc_klass.table_name).map{|e| e.id}
+          html << f.collection_select(assoc_klass.table_name, all, :id, order_by,
+          {:include_blank => false, :selected => selected},
+          {:multiple => true, :size => (all.count > 10 ? 8 : 4)})
+        end
+        html.join
+      rescue Exception => e
+        Rails.logger.info Util.exception_info(e)
+        'could not retrieve' # returning nil
+      end
+    end
+
+    def handle_column_type(col, html, model, column_value, f)
+      case col.type
+      when :text
+        html << f.text_area(col.name, :rows => 6, :cols => 70)
+
+      when :datetime
+        if ['created_at', 'updated_at'].include?(col.name)
+          html <<  '(auto)'
+        else
+          value = params[:action] == 'new' ? Time.now : column_value
+          year_value = value.year if value
+          datetime_selects = f.datetime_select(col.name, :include_blank => true)
+          html << datetime_selects.gsub('type="hidden"', 'type="text" size="4" class="nice-field"')
+        end
+
+      when :date
+        value = params[:action] == 'new' ? Time.now : column_value
+        year_value = value.year if value
+        date_selects = f.date_select(col.name, :discard_year => true, :include_blank => true)
+        html << date_selects.gsub('type="hidden"', 'type="text" size="4" class="nice-field"')
+
+      when :time
+        # time_select method of rails is buggy and is causing problem
+        # 1 error(s) on assignment of multiparameter attributes
+        #
+        # will try again this method with Rails 3
+        #html << f.time_select(col.name, :include_blank => true, :include_seconds => true)
+
+      when :boolean
+        html << f.select(col.name, [['True', true], ['False', false]], :include_blank => true)
+
+      else
+        build_text_field(html, f, col)
+      end
+      html.join
+    end
+
+
+    def build_text_field(html, f, col)
+      options = {:class => 'nice-field'}
+      if AdminData.config.ignore_column_limit
+        options[:size] = 60
+        options[:maxlength] = 255
+      else
+        options[:size] = (col && col.limit && col.limit < 60) ? col.limit : 60
+        options[:maxlength] = col.limit if col.limit
+      end
+      html << f.text_field(col.name, options)
+      html.join
+    end
+
+    # uses truncate method
+    # options supports :limit which is applied if the column type is string or text.
+    # calls the inspect method to convert to a string if the column is serialized.
+    # TODO rspec test limit option
+    def get_value_for_column(column, model, options = {})
+      options.reverse_merge!(:limit => 400)
+
+      value = Util.custom_value_for_column(column, model)
+
+      if column.is_a?(String)
+        value
+      elsif column.type == :datetime
+        value.strftime('%d-%B-%Y %H:%M:%S %p') unless value.blank?
+      elsif column.type == :string || column.type == :text
+        value = value.inspect if model.class.serialized_attributes.keys.include?(column.name)
+        return value if options[:limit].blank?
+        begin
+          truncate(value,:length => options[:limit])
+        rescue # truncate method failed
+          '<actual data is not being shown because truncate method failed.>'
+        end
+      else
+        value.to_s
+      end
+    end
+
+    def get_reflection_for_column(klass, col)
+      klass.reflections.values.detect { |reflection| reflection.foreign_key.to_sym == col.name.to_sym }
+    end
+
+    def record_id(record)
+      if record.respond_to?(:primary_key)
+        record.send(:primary_key)
+      else
+        record.id
+      end
+    end
+  end
+end