obitum-rails_admin 0.0.1

data/app/assets/stylesheets/rails_admin/ra.calendar-additions.css.scss

@@ -0,0 +1,25 @@
+.ui-timepicker-table table th.periods {
+  padding:0;
+}
+
+.ui-datepicker {
+  /* fix glitches */
+  border-width:0px;
+  table{
+    margin:0px;
+  }
+  /* make present day stand out */
+  td.ui-datepicker-today {
+    background:#ccc;
+    -webkit-box-shadow:inset 0 1px 1px #333;
+    -moz-box-shadow:inset 0 1px 1px #333;
+    box-shadow:0 1px 1px #333 inset;
+    .ui-state-highlight{
+      background:transparent;
+      border:none;
+      -webkit-box-shadow:none;
+      -moz-box-shadow:none;
+      box-shadow:none;
+    }
+  }
+}

data/app/assets/stylesheets/rails_admin/ra.filtering-multiselect.css.scss

@@ -0,0 +1,85 @@
+.ra-multiselect {
+
+  .ra-multiselect-header {
+    margin-bottom: 5px;
+    clear: right;
+    .help {
+      float: left;
+      font-size: 10px;
+    }
+    .ui-icon {
+      position: relative;
+      top: 10px;
+      left: 3px;
+    }
+  }
+  
+  .ra-multiselect-search {
+    width: 180px;
+  }
+  
+  .ra-multiselect-column {
+    width: 190px;
+    float: left;
+  }
+
+  .ra-multiselect-center {
+    width: 30px;
+    padding-top: 15px;
+    text-align: center;
+    .ui-icon {
+      margin: 5px auto;
+    }
+  }
+  .ra-multiselect-collection, .ra-multiselect-selection {
+    height: 130px;
+    margin-bottom: 5px;
+    width: 100%;
+  }
+
+  span.ui-icon {
+    margin-right: 4px;
+  }
+  .ui-icon {
+    cursor: pointer;
+    display: inline-block;
+    vertical-align: top;
+    &.ui-icon-circle-triangle-e {
+      background-position: -16px -32px !important;
+      background-image: image-url("rails_admin/multiselect/icon_sprite.png");
+    }
+    &.ui-icon-circle-triangle-e:hover {
+      background-position: -16px -48px !important;
+      background-image: image-url('rails_admin/multiselect/icon_sprite.png');
+    }
+    &.ui-icon-circle-triangle-w {
+      background-position: 0px -32px !important;
+      background-image: image-url('rails_admin/multiselect/icon_sprite.png');
+    }
+    &.ui-icon-circle-triangle-w:hover {
+      background-position: 0px -48px !important;
+      background-image: image-url('rails_admin/multiselect/icon_sprite.png');
+    }
+    &.ui-icon-circle-triangle-n {
+      background-position: 0px 0px !important;
+      margin-left: 1px;
+      background-image: image-url('rails_admin/multiselect/ui-icon-circle-triangle-n-light.png');
+    }
+    &.ui-icon-circle-triangle-n:hover {
+      background-position: 0px 0px !important;
+      margin-left: 1px;
+      background-image: image-url('rails_admin/multiselect/ui-icon-circle-triangle-n-dark.png');
+    }
+    &.ui-icon-circle-triangle-s {
+      background-position: 0px 0px !important;
+      margin-left: 1px;
+      background-image: image-url('rails_admin/multiselect/ui-icon-circle-triangle-s-light.png');
+    }
+    &.ui-icon-circle-triangle-s:hover {
+      background-position: 0px 0px !important;
+      margin-left: 1px;
+      background-image: image-url('rails_admin/multiselect/ui-icon-circle-triangle-s-dark.png');
+    }
+  }
+}
+

data/app/assets/stylesheets/rails_admin/rails_admin.css

@@ -0,0 +1,4 @@
+/*
+ *= require rails_admin/imports.css.scss
+*/
+/* Nothing else here (sass @import statements create weird pbs in a self required scss file) */

data/app/assets/stylesheets/rails_admin/themes/default/mixins.css.scss

@@ -0,0 +1,8 @@
+/*
+  Customize Sass mixins from Twitter-Bootstrap/RailsAdmin theme or add new ones for your own use.
+
+  Available mixins to use/override:
+  
+  https://github.com/thomas-mcdonald/bootstrap-sass/blob/master/vendor/assets/stylesheets/bootstrap/mixins.css.scss
+  https://github.com/sferik/rails_admin/blob/master/app/assets/stylesheets/rails_admin/base/mixins.css.scss
+*/

data/app/assets/stylesheets/rails_admin/themes/default/theming.css.scss

@@ -0,0 +1,11 @@
+/*
+  Customize RailsAdmin theme here.
+
+  Look at the markup in RailsAdmin and go there to get inspiration from:
+  
+  http://twitter.github.com/bootstrap/
+
+  Test me: (actual color should be the one defined in variables.css.scss if you did)
+  
+  body{ background-color: $linkColor; }
+*/

data/app/assets/stylesheets/rails_admin/themes/default/variables.css.scss

@@ -0,0 +1,12 @@
+/*
+  Customize Sass variables from Twitter-Bootstrap/RailsAdmin theme or add new ones for your own use.
+
+  Available variables to use/override:
+  
+  https://github.com/thomas-mcdonald/bootstrap-sass/blob/master/vendor/assets/stylesheets/bootstrap/variables.css.scss
+  https://github.com/sferik/rails_admin/blob/master/app/assets/stylesheets/rails_admin/base/variables.css.scss
+  
+  Test me: pink links
+  
+  $linkColor: #F0F;
+*/

data/app/controllers/rails_admin/application_controller.rb

@@ -0,0 +1,87 @@
+require 'rails_admin/abstract_model'
+
+module RailsAdmin
+  class ModelNotFound < ::StandardError
+  end
+  
+  class ObjectNotFound < ::StandardError
+  end
+  
+  class ApplicationController < ::ApplicationController
+    newrelic_ignore if defined?(NewRelic)
+    
+    before_filter :_authenticate!
+    before_filter :_authorize!
+    before_filter :_audit!
+
+    helper_method :_current_user, :_attr_accessible_role, :_get_plugin_name
+    
+    attr_reader :object, :model_config, :abstract_model
+
+    def get_model
+      @model_name = to_model_name(params[:model_name])
+      @abstract_model = RailsAdmin::AbstractModel.new(@model_name) rescue begin
+        raise RailsAdmin::ModelNotFound
+      end
+      @model_config = RailsAdmin.config(@abstract_model)
+      raise(RailsAdmin::ModelNotFound) if @model_config.excluded?
+      @properties = @abstract_model.properties
+    end
+    
+    def get_object
+      unless (@object = @abstract_model.get(params[:id]))
+        raise RailsAdmin::ObjectNotFound
+      end
+    end
+
+    def to_model_name(param)
+      model_name = param.split("~").map(&:camelize).join("::")
+    end
+
+    private
+    
+    def _get_plugin_name
+      @plugin_name_array ||= [RailsAdmin.config.main_app_name.is_a?(Proc) ? instance_eval(&RailsAdmin.config.main_app_name) : RailsAdmin.config.main_app_name].flatten
+    end
+
+    def _authenticate!
+      instance_eval &RailsAdmin::Config.authenticate_with
+    end
+
+    def _authorize!
+      instance_eval &RailsAdmin::Config.authorize_with
+    end
+    
+    def _audit!
+      instance_eval &RailsAdmin::Config.audit_with
+    end
+
+    def _current_user
+      instance_eval &RailsAdmin::Config.current_user_method
+    end
+
+    def _attr_accessible_role
+      instance_eval &RailsAdmin::Config.attr_accessible_role
+    end
+    
+    rescue_from RailsAdmin::ObjectNotFound do
+      flash[:error] = I18n.t('admin.flash.object_not_found', :model => @model_name, :id => params[:id])
+      params[:action] = 'index'
+      index
+    end
+    
+    rescue_from RailsAdmin::ModelNotFound do
+      flash[:error] = I18n.t('admin.flash.model_not_found', :model => @model_name)
+      params[:action] = 'dashboard'
+      dashboard
+    end
+    
+    def not_found
+      render :file => Rails.root.join('public', '404.html'), :layout => false, :status => :not_found
+    end
+
+    def rails_admin_controller?
+      true
+    end
+  end
+end

data/app/controllers/rails_admin/main_controller.rb

@@ -0,0 +1,148 @@
+module RailsAdmin
+
+  class MainController < RailsAdmin::ApplicationController
+            
+    include ActionView::Helpers::TextHelper
+    include RailsAdmin::MainHelper
+    include RailsAdmin::ApplicationHelper
+    
+    layout "rails_admin/application"
+    
+    before_filter :get_model, :except => RailsAdmin::Config::Actions.all(:root).map(&:action_name)
+    before_filter :get_object, :only => RailsAdmin::Config::Actions.all(:member).map(&:action_name)
+    before_filter :check_for_cancel
+    
+    RailsAdmin::Config::Actions.all.each do |action|
+      class_eval %{
+        def #{action.action_name}
+          @action = RailsAdmin::Config::Actions.find('#{action.action_name}'.to_sym, {:controller => self, :abstract_model => @abstract_model, :object => @object})
+          
+          @authorization_adapter.try(:authorize, @action.authorization_key, @abstract_model, @object)
+          @page_name = wording_for(:title)
+          @page_type = @abstract_model && @abstract_model.pretty_name.downcase || "dashboard"
+          
+          instance_eval &@action.controller
+        end
+      }
+    end
+    
+    def bulk_action
+      self.send(params[:bulk_action]) if params[:bulk_action].in?(RailsAdmin::Config::Actions.all(:controller => self, :abstract_model => @abstract_model).select(&:bulkable?).map(&:route_fragment))
+    end
+
+    def list_entries(model_config = @model_config, auth_scope_key = :index, additional_scope = get_association_scope_from_params, pagination = !(params[:associated_collection] || params[:all]))
+      scope = @authorization_adapter && @authorization_adapter.query(auth_scope_key, model_config.abstract_model)
+      scope = model_config.abstract_model.scoped.merge(scope)
+      scope = scope.instance_eval(&additional_scope) if additional_scope
+      
+      get_collection(model_config, scope, pagination)
+    end
+
+    private
+    
+    def back_or_index
+      params[:return_to].presence && params[:return_to].include?(request.host) && (params[:return_to] != request.fullpath) ? params[:return_to] : index_path
+    end
+
+    def get_sort_hash(model_config)
+      abstract_model = model_config.abstract_model
+      params[:sort] = params[:sort_reverse] = nil unless model_config.list.fields.map {|f| f.name.to_s}.include? params[:sort]
+
+      params[:sort] ||= model_config.list.sort_by.to_s
+      params[:sort_reverse] ||= 'false'
+
+      field = model_config.list.fields.find{ |f| f.name.to_s == params[:sort] }
+
+      column = if field.nil? || field.sortable == true # use params[:sort] on the base table
+        "#{abstract_model.model.table_name}.#{params[:sort]}"
+      elsif field.sortable == false # use default sort, asked field is not sortable
+        "#{abstract_model.model.table_name}.#{model_config.list.sort_by}"
+      elsif field.sortable.is_a?(String) && field.sortable.include?('.') # just provide sortable, don't do anything smart
+        field.sortable
+      elsif field.sortable.is_a?(Hash) # just join sortable hash, don't do anything smart
+        "#{field.sortable.keys.first}.#{field.sortable.values.first}"
+      elsif field.association? # use column on target table
+        "#{field.associated_model_config.abstract_model.model.table_name}.#{field.sortable}"
+      else # use described column in the field conf.
+        "#{abstract_model.model.table_name}.#{field.sortable}"
+      end
+
+      reversed_sort = (field ? field.sort_reverse? : model_config.list.sort_reverse?)
+      {:sort => column, :sort_reverse => (params[:sort_reverse] == reversed_sort.to_s)}
+    end
+
+
+    def get_attributes
+      attributes = params[@abstract_model.to_param.gsub('~','_')] || {}
+      attributes.each do |key, value|
+        # Deserialize the attribute if attribute is serialized
+        if @abstract_model.model.serialized_attributes.keys.include?(key) and value.is_a? String
+          attributes[key] = YAML::load(value)
+        end
+      end
+      attributes
+    end
+    
+    def redirect_to_on_success
+      notice = t("admin.flash.successful", :name => @model_config.label, :action => t("admin.actions.#{@action.key}.done"))
+      if params[:_add_another]
+        redirect_to new_path(:return_to => params[:return_to]), :flash => { :success => notice }
+      elsif params[:_add_edit]
+        redirect_to edit_path(:id => @object.id, :return_to => params[:return_to]), :flash => { :success => notice }
+      else
+        redirect_to back_or_index, :flash => { :success => notice }
+      end
+    end
+
+    def handle_save_error whereto = :new
+      action = params[:action]
+
+      flash.now[:error] = t("admin.flash.error", :name => @model_config.label, :action => t("admin.actions.#{@action.key}.done"))
+      flash.now[:error] += ". #{@object.errors[:base].to_sentence}" unless @object.errors[:base].blank?
+
+      respond_to do |format|
+        format.html { render whereto, :status => :not_acceptable }
+        format.js   { render whereto, :layout => false, :status => :not_acceptable  }
+      end
+    end
+
+    def check_for_cancel
+      if params[:_continue]
+        redirect_to(back_or_index, :flash => { :info => t("admin.flash.noaction") })
+      end
+    end
+
+    def get_collection(model_config, scope, pagination)
+      associations = model_config.list.fields.select {|f| f.type == :belongs_to_association && !f.polymorphic? }.map {|f| f.association[:name] }
+      options = {}
+      options = options.merge(:page => (params[:page] || 1).to_i, :per => (params[:per] || model_config.list.items_per_page)) if pagination
+      options = options.merge(:include => associations) unless associations.blank?
+      options = options.merge(get_sort_hash(model_config)) unless params[:associated_collection]
+      options = options.merge(model_config.abstract_model.get_conditions_hash(model_config, params[:query], params[:f])) if (params[:query].present? || params[:f].present?)
+      options = options.merge(:bulk_ids => params[:bulk_ids]) if params[:bulk_ids]
+
+      objects = model_config.abstract_model.all(options, scope)
+    end
+
+    def get_association_scope_from_params
+      return nil unless params[:associated_collection].present?
+      source_abstract_model = RailsAdmin::AbstractModel.new(to_model_name(params[:source_abstract_model]))
+      source_model_config = RailsAdmin.config(source_abstract_model)
+      source_object = source_abstract_model.get(params[:source_object_id])
+      action = params[:current_action].in?(['create', 'update']) ? params[:current_action] : 'edit'
+      association = source_model_config.send(action).fields.find{|f| f.name == params[:associated_collection].to_sym }.with(:controller => self, :object => source_object)
+      association.associated_collection_scope
+    end
+
+    def associations_hash
+      associations = {}
+      @abstract_model.associations.each do |association|
+        if [:has_many, :has_and_belongs_to_many].include?(association[:type])
+          records = Array(@object.send(association[:name]))
+          associations[association[:name]] = records.collect(&:id)
+        end
+      end
+      associations
+    end
+  end
+end

data/app/helpers/rails_admin/application_helper.rb

@@ -0,0 +1,97 @@
+require 'rails_admin/i18n_support'
+
+module RailsAdmin
+  module ApplicationHelper
+
+    include RailsAdmin::I18nSupport
+
+    def authorized?(*args)
+      @authorization_adapter.nil? || @authorization_adapter.authorized?(*args)
+    end
+    
+    def current_action?(action)
+      @action.custom_key == action.custom_key
+    end
+    
+    def action(key, abstract_model = nil, object = nil)
+      action = RailsAdmin::Config::Actions.find(key, { :controller => self.controller, :abstract_model => abstract_model, :object => object })
+      action && authorized?(action.authorization_key, (action.collection? || action.member?) && abstract_model || nil, action.member? && object || nil) ? action : nil
+    end
+    
+    def actions(scope = :all, abstract_model = nil, object = nil)
+      RailsAdmin::Config::Actions.all(scope, { :controller => self.controller, :abstract_model => abstract_model, :object => object }).select do |action|
+        authorized?(action.authorization_key, (action.collection? || action.member?) && abstract_model || nil, action.member? && object || nil)
+      end
+    end
+    
+    def edit_user_link
+      return nil unless authorized?(:edit, _current_user.class, _current_user) && _current_user.respond_to?(:email)
+      return nil unless abstract_model = RailsAdmin.config(_current_user.class).abstract_model
+      return nil unless edit_action = RailsAdmin::Config::Actions.find(:edit, {:controller => self.controller, :abstract_model => abstract_model, :object => _current_user })
+      link_to _current_user.email, url_for(:action => edit_action.action_name, :model_name => abstract_model.to_param, :id => _current_user.id, :controller => 'rails_admin/main')
+    end
+
+    
+    def wording_for(label, action = @action, abstract_model = @abstract_model, object = @object)
+      
+      model_config = abstract_model && RailsAdmin.config(abstract_model)
+      object = abstract_model && object.is_a?(abstract_model.model) ? object : nil
+      action = RailsAdmin::Config::Actions.find(action.to_sym) if (action.is_a?(Symbol) || action.is_a?(String))
+      
+      I18n.t("admin.actions.#{action.i18n_key}.#{label}", 
+        :model_label => model_config.try(:label), 
+        :model_label_plural => model_config.try(:label_plural), 
+        :object_label => model_config && object.try(model_config.object_label_method)
+      )
+    end
+    
+    def breadcrumb action = @action, acc = []
+      
+      acc << content_tag(:li, :class => "#{"active" if current_action?(action)}") do
+        if action.http_methods.include?(:get)
+          link_to wording_for(:breadcrumb, action), { :action => action.action_name, :controller => 'rails_admin/main' }
+        else
+          content_tag(:span, wording_for(:breadcrumb, action))
+        end
+      end
+
+      unless action.breadcrumb_parent && (parent = action(action.breadcrumb_parent, @abstract_model, @object)) # rec tail
+        content_tag(:ul, :class => "breadcrumb") do
+          acc.reverse.join('<span class="divider">/</span>').html_safe
+        end
+      else
+        breadcrumb parent, acc # rec
+      end
+    end
+    
+    # parent => :root, :collection, :member
+    def menu_for(parent, abstract_model = nil, object = nil) # perf matters here (no action view trickery)
+      actions = actions(parent, abstract_model, object).select{ |action| action.http_methods.include?(:get) }
+      actions.map do |action|
+        %{
+          <li class="#{action.key}_#{parent}_link #{'active' if current_action?(action)}">
+            <a href="#{url_for({ :action => action.action_name, :controller => 'rails_admin/main', :model_name => abstract_model.try(:to_param), :id => object.try(:id) })}">
+              #{wording_for(:menu, action)}
+            </a>
+          </li>
+        }
+      end.join.html_safe
+    end
+    
+    def bulk_menu abstract_model = @abstract_model
+      actions = actions(:bulkable, abstract_model)
+      return '' if actions.empty?
+      content_tag :li, { :class => 'dropdown', :style => 'float:right', :'data-dropdown' => "dropdown" } do
+        content_tag(:a, { :class => 'dropdown-toggle', :href => '#' }) { t('admin.misc.bulk_menu_title') } +
+        content_tag(:ul, :class => 'dropdown-menu') do
+          actions.map do |action|
+            content_tag :li do
+              link_to_function wording_for(:bulk_link, action), "jQuery('#bulk_action').val('#{action.action_name}'); jQuery('#bulk_form').submit()"
+            end
+          end.join.html_safe
+        end
+      end
+    end
+  end
+end
+