adminsite 2.0.0

data/app/controllers/adminsite/admin_application_controller.rb

@@ -0,0 +1,9 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class Adminsite::AdminApplicationController < ActionController::Base
+  helper :all, "admin/adminsite_application"
+  layout 'adminsite/admin'
+  before_filter :authenticate_adminsite_admin_user!
+
+end

data/app/controllers/adminsite/admin_user_sessions_controller.rb

@@ -0,0 +1,5 @@
+class Adminsite::AdminUserSessionsController < Devise::SessionsController
+  skip_filter :verify_authenticity_token, only: [:destroy]
+
+  layout 'adminsite/admin'
+end

data/app/controllers/adminsite/contents_controller.rb

@@ -0,0 +1,88 @@
+class Adminsite::ContentsController < ApplicationController
+  include ActionController::Caching::Pages
+  self.page_cache_directory = Adminsite::Engine.config.action_controller.page_cache_directory
+
+  before_filter :set_p3p
+
+  def show
+    retrive_page_or_404(params[:page_url], params[:id], params[:format])
+  end
+
+  def render_404(format = params[:format])
+    page = find_page_by_url('404', format)
+    if page.nil?
+      render :file => Rails.root.join('public', '404.html'), :status => 404, layout: nil
+    else
+      render :text => page.render(liquid_attributes), :status => 404 and return
+    end
+  end
+
+  class << self
+
+    def fallback_format
+      'html'
+    end
+
+    def find_page_by_url(url, format)
+      page = nil
+      urls = ["#{url}.#{format || fallback_format}" ]
+      urls.unshift(url) if format.nil?
+      urls.push(url) if format == 'html'
+      urls.each do |full_url|
+        page ||= Adminsite::Page.find_by_url(full_url)
+      end
+      page
+    end
+  end
+
+  private
+
+  def find_page_by_url(url, format)
+    self.class.find_page_by_url(url, format)
+  end
+
+  def set_p3p
+    response.headers['P3P'] = 'CP="CAO PSA OUR"'
+  end
+
+  def content_params
+    { :authenticity_token => form_authenticity_token,
+      :authenticity_param => request_forgery_protection_token,
+      :notice => flash[:notice],
+      :error  => flash[:error]
+    }
+  end
+
+  def liquid_attributes
+    return @liquid_attributes if @liquid_attributes.present?
+
+    @liquid_attributes = {}
+    if defined?(liquid_params)
+      @liquid_attributes = content_params.merge(liquid_params)
+    else
+      @liquid_attributes = content_params
+      Rails.logger.warn("Please define liquid_params in your application controller")
+    end
+    Rails.logger.debug("Content params: #{@liquid_attributes.inspect}")
+    @liquid_attributes
+  end
+
+  def retrive_page_or_404(url, id, format)
+    page = find_page_by_url(url, format)
+    unless page.nil?
+      return if page.requires_login && !authenticate_content_user
+
+      render :text => page.render(liquid_attributes)
+      if page.cacheable?
+        cache_page
+        logger.info("Caching page: #{page.url}")
+      else
+        logger.info("Not caching page: #{page.url}")
+      end
+      return
+    else
+      render_404(format)
+    end
+  end
+
+end

data/app/helpers/admin/adminsite_application_helper.rb

@@ -0,0 +1,174 @@
+module Admin::AdminsiteApplicationHelper
+
+  def column_of_attr(search_attr)
+    return if search_attr.blank?
+    resource_class.columns.each{|c| return c if c.name == search_attr.to_s.downcase }
+    nil
+  end
+
+  def input_type_of_column(column)
+    case
+    when column.sql_type.match(/\Acharacter varying/)
+      return :string
+    when column.sql_type.match(/\Atimestamp/)
+      return :date
+    when column.sql_type.match(/\integer/)
+      return :number
+    else
+      column.sql_type.try(:to_sym)
+    end
+  end
+
+  def ransack_predicate_input_type(input_type)
+    case input_type
+    when :boolean
+      return [:eq]
+    when :text
+      return [:eq, :cont]
+    when :string
+      return [:eq, :cont]
+    when :date
+      return [:lteq, :gteq]
+    when :number
+      return [:eq, :lteq, :gteq]
+    else
+      [:eq]
+    end
+  end
+
+  def format_response_value(value)
+    value = value.url if defined?(PictureUploader) && value.is_a?(PictureUploader)
+    response = '<td>'
+    if is_url?(value)
+      response += link_to(value,value, target: :blank)
+      response += "<br/>#{image_tag(value)}" if is_image?(value)
+    else
+      response += h value
+    end
+    response + '</td>'
+  end
+
+  def is_url?(value)
+    value.is_a?(String) && value.match(/\A[\/]|\Ahttp[s]*:/)
+  end
+
+  def image_extensions
+    %w(.png .gif .jpg .tif)
+  end
+
+  def is_image?(path)
+    image_extensions.include?( File.extname(path).split('?').first.try(:downcase) )
+  end
+
+  def error_messages_for(obj)
+    return if obj.errors.blank?
+    msgs = obj.errors.full_messages.collect{|msg| "<li>#{ h msg }</li>" }
+    raw ['<ul>', msgs, '</ul>'].flatten.join
+  end
+
+  def recognize_path(path)
+    return {} if path.try(:strip).blank?
+    begin
+      return Adminsite::Engine.routes.recognize_path(path) # '/admin/profiles'
+      return Rails.application.routes.recognize_path(path)
+    rescue Exception => e
+    end
+  end
+
+  def current_admin_menu
+    @current_admin_menu ||= params[:admin_menu]
+  end
+
+  def menu_item(label, url, child_controller_names = [], klasses = nil, method = nil, admin_menu = label)
+    link = link_to(label, "#{url}?admin_menu=#{admin_menu}", method: method, )
+    result = raw "<li class='#{html_classes(url, nil, klasses, admin_menu, label )}'>#{link}</li>"
+
+    if current_url?(url, label) || ( child_controller_active?(child_controller_names) && current_admin_menu == admin_menu)
+      child_controller_names.each do |child_controller_name|
+        child_menu = content_menu_item(child_controller_name, admin_menu, nil, nil )
+        content_for(:content_menu, child_menu)
+      end
+    end
+    result
+  end
+
+  def content_menu_label(url, controller_name)
+    menu_controller = recognize_path(url)[:controller]
+    return controller_name.titlecase if menu_controller.blank?
+    eval("#{menu_controller}_controller".classify).content_menu_label
+  end
+
+  def content_menu_item(controller_name, admin_menu, klasses, method )
+    if controller_name != controller_name.pluralize
+      url = eval("admin_#{controller_name}_index_path")
+    else
+      url = eval("admin_#{controller_name}_path")
+    end
+    link = link_to(content_menu_label(url, controller_name), "#{url}?admin_menu=#{admin_menu}", method: method, )
+    raw "<li class='#{html_classes(url, controller_name, klasses, admin_menu )}'>#{link}</li>"
+  end
+
+  def current_url?(url, label = '')
+    if label.present?
+      return request.fullpath == "#{url}?admin_menu=#{label}"
+    else
+      return request.fullpath == url
+    end
+  end
+
+  def child_controller_active?(child_controller_names)
+    child_controller_names.include?(controller.controller_name)
+  end
+
+  def html_classes(url, controller_name, klasses = nil, admin_menu = '', label = '')
+    result = []
+    result |= [klasses].flatten if klasses.present?
+    result |= ['current'] if current_url?(url, admin_menu)
+    result |= ['active']  if current_admin_menu == label || controller_name == controller.controller_name
+    result.join(' ')
+  end
+
+  def label_resource
+    @resource.send(resource_admin_config.label_attribute)
+  end
+
+  def label_resource_class
+    resource_class.name.underscore.gsub('_', ' ')
+  end
+
+  def label_resource_class_plural
+    label_resource_class.pluralize
+  end
+
+  def link_to_back(text, path = admin_resource_path)
+    link_to text, path, :class => 'back'
+  end
+
+  def link_to_new(text, path = admin_resource_path(nil, :new) )
+    link_to text, path, :class => 'add'
+  end
+
+  def link_to_show(resource)
+    link_to image_tag('adminsite/admin/magnifier.png', :size => '16x16'), admin_resource_path(resource.id), target: :blank
+  end
+
+  def link_to_edit(resource)
+    link_to image_tag('adminsite/admin/pencil.png', :size => '16x16'), admin_resource_path(resource.id, :edit)
+  end
+
+  def link_to_destroy(resource)
+    link_to image_tag('adminsite/admin/cross.png', :size => '16x16'), admin_resource_path(resource.id), :confirm => 'Are you sure?', :method => :delete
+  end
+
+  def display_resource_value(resource, attr)
+    value = nil
+    attr.to_s.split('.').each{|a| value = (value || resource).send(a) }
+    value = display_referenced_resource(value) if value.is_a?(ActiveRecord::Base)
+    format_response_value(value).html_safe
+  end
+
+  def display_referenced_resource(resource)
+    link_to resource.title, send("edit_admin_#{resource.class.name.underscore.gsub('/','_')}_path", resource.id, admin_menu: params[:admin_menu])
+  end
+
+end

data/app/helpers/admin_application_helper.rb

@@ -0,0 +1,3 @@
+# Methods added to this helper will be available to all templates in the application.
+module AdminApplicationHelper
+end

data/app/models/adminsite/admin_config/base.rb

@@ -0,0 +1,100 @@
+module Adminsite
+  module AdminConfig
+    class Base   #
+
+      @@admin_configs = {}
+
+      class << self
+
+        def admin_default_config_class(class_name)
+          config_class = 'Adminsite::AdminConfig::Base'
+          return config_class if class_name.blank?
+
+          config_class_name = class_name.to_s.gsub('::','')
+          begin
+            # Test if "Adminsite::AdminConfig::#{config_class_name.gsub('::','')}" is defined
+            config_class = "Adminsite::#{config_class_name}AdminConfig"
+            eval(config_class)
+          rescue NameError, LoadError => e
+            puts("AdminConfig for #{config_class_name} not found. Use fallback: #{config_class}")
+            Rails.logger.warn("AdminConfig for #{config_class_name} not found. Use fallback: #{config_class}")
+          end
+          config_class
+        end
+
+        def admin_config_of_class(class_name, admin_config_class = nil)
+          admin_config_class ||= @@admin_configs[class_name.to_s]
+          if admin_config_class.blank?
+            admin_config_class = admin_default_config_class(class_name.to_s)
+            register_admin_configs(class_name.to_s, admin_config_class)
+          end
+          eval(admin_config_class).new(class_name)
+        end
+
+        def register_admin_configs(class_name, admin_config, override = true)
+          if override
+            @@admin_configs[class_name] = admin_config
+          else
+            @@admin_configs[class_name] ||= admin_config
+          end
+        end
+
+        def all_registered_admin_configs
+          @@admin_configs
+        end
+      end
+
+      attr_reader :resource_class
+
+      def ignore_columns
+        ['created_at', 'updated_at', 'id']
+      end
+
+      def column_names
+        @column_names ||= resource_class.column_names
+      end
+
+      def attributes_index
+        column_names
+      end
+
+      def attributes_edit
+        @attributes_edit ||= (column_names - ignore_columns)
+      end
+
+      def attributes_show
+        attributes_edit
+      end
+
+      def attributes_search
+        attributes_index
+      end
+
+      def default_member_actions
+        [ :show,
+          :edit,
+          :destroy]
+      end
+
+      def actions_index
+        [ :new ]
+      end
+
+      def label_attribute
+        :title
+      end
+
+      def scopes
+        [:all]
+      end
+
+      protected
+
+      def initialize(resource_class)
+        require Adminsite::Engine.root.join("app/models/#{resource_class.name.underscore}") unless defined?(resource_class)
+        @resource_class = resource_class
+      end
+
+    end
+  end
+end

data/app/models/adminsite/admin_user.rb

@@ -0,0 +1,10 @@
+module Adminsite
+  class AdminUser < ActiveRecord::Base
+    # Include default devise modules. Others available are:
+    # :token_authenticatable, :confirmable, :lockable and :timeoutable
+    devise :database_authenticatable, :registerable,
+           :recoverable, :rememberable, :trackable, :validatable
+
+  end
+
+end

data/app/models/adminsite/file_asset.rb

@@ -0,0 +1,22 @@
+module Adminsite
+  class FileAsset < ActiveRecord::Base
+
+    has_attached_file :attachment
+
+    validates_with AttachmentPresenceValidator, :attributes => :attachment
+    validates_with AttachmentSizeValidator, :attributes => :attachment, :less_than => 2.megabytes
+    validates_attachment :attachment, content_type: { content_type: /\A.*\Z/ }
+    # do_not_validate_attachment_file_type :image
+
+    class << self
+      def attachment_url_for(name)
+        asset = find_by_attachment_file_name(name)
+        if asset.nil?
+          "http://missing.jpg?#{name}"
+        else
+          asset.attachment.url(:original, false)
+        end
+      end
+    end
+  end
+end

data/app/models/adminsite/page.rb

@@ -0,0 +1,59 @@
+class Adminsite::Page < ActiveRecord::Base
+  belongs_to :page_layout
+  validates_presence_of :title
+  validates_presence_of :page_layout
+  validates_presence_of :url
+
+  class << self
+
+    def cleanup_all_cached
+      Adminsite::Page.all.each do |p|
+        p.cleanup_cached
+      end
+      logger.info("Page cache has been wiped out: deleted all cached pages.")
+    end
+
+    def cacheable
+      where(cacheable: true)
+    end
+
+    def requires_login
+      where(requires_login: true)
+    end
+
+  end
+
+  def cache_dir
+    @cache_dir ||= Adminsite::ContentsController.page_cache_directory # Adminsite::Engine.config.action_controller.page_cache_directory
+  end
+
+  def cleanup_cached
+    return if self.url.blank?
+    logger.info("Removing cached page for: #{self.url}")
+    cache_file_path = "#{cache_dir}/#{self.url}"
+    if !remove_cache_file(cache_file_path)
+      remove_cache_file("#{cache_file_path}.html")
+    end
+  end
+
+  def remove_cache_file(file_path)
+    if File.exist?(file_path)
+      logger.info("Removing cached page at: #{file_path}")
+      FileUtils.rm(file_path)
+      true
+    end
+  end
+
+  def render(args)
+    page_layout.render(layout_args(args))
+  end
+
+  def layout_args(args)
+    args.stringify_keys.merge(:content_for_template => content_for_template(args))
+  end
+
+  def content_for_template(liquid_params)
+    liquid_template = Liquid::Template.parse(body)
+    liquid_template.render(liquid_params.stringify_keys)
+  end
+end