releaf 0.1.1

data/app/controllers/releaf/roles_controller.rb

@@ -0,0 +1,36 @@
+module Releaf
+  class RolesController < BaseController
+
+    def current_object_class
+      Releaf::Role
+    end
+
+    def columns( view = nil )
+      fields = (super(view) - ['default']).insert(1, 'default')
+      if view == 'index'
+        fields - ['permissions'] + ['admin_permission']
+      else
+        fields
+      end
+    end
+
+    protected
+
+    def role_params( action )
+      return [] unless [:update, :create].include? action
+
+      fields = ['name', 'default']
+      AdminAbility::PERMISSIONS.each do |permission|
+        if permission.is_a? String
+          fields.push "#{permission}_permission"
+        elsif permission.is_a? Array
+          fields.push "#{permission[0]}_permissions"
+        else
+          raise RuntimeError, 'invalid permissions'
+        end
+      end
+      return fields
+    end
+
+  end
+end

data/app/controllers/releaf/sessions_controller.rb

@@ -0,0 +1,5 @@
+module Releaf
+  class SessionsController < Devise::SessionsController
+    layout "releaf/admin"
+  end
+end

data/app/controllers/releaf/tinymce_assets_controller.rb

@@ -0,0 +1,26 @@
+module Releaf
+  class TinymceAssetsController < BaseController
+    skip_authorization_check :only => [:create]
+
+    def create
+      asset = TinymceAsset.new
+      asset.file_type = params[:file].content_type
+      asset.file = params[:file]
+      asset.save!
+
+
+      render json: {
+        image: {
+          # url: serve_tinymce_asset_path(asset)
+          url: asset.file.url
+        }
+      }, content_type: "text/html"
+    end
+
+    # def serve
+    #   asset = TinymceAsset.find(params[:id])
+    #   send_file asset.file.path, :type => asset.file_type
+    # end
+
+  end
+end

data/app/controllers/releaf/translations_controller.rb

@@ -0,0 +1,121 @@
+module Releaf
+  class TranslationsController < BaseController
+
+    def setup
+      super
+      @object_class = I18n::Backend::Releaf::TranslationGroup
+      @features[:show] = false
+      @continuous_scroll = true
+    end
+
+    def current_object_class
+      @object_class
+    end
+
+    def build_secondary_panel_variables
+      @groups = I18n::Backend::Releaf::TranslationGroup.order(:scope).all
+      super
+    end
+
+    def columns( view = nil )
+      return super + (Settings.i18n_locales || [])
+    end
+
+    def index
+      authorize! :manage, I18n::Backend::Releaf::Translation
+      @list = @object_class = I18n::Backend::Releaf::Translation.includes(:translation_data).filter(:search => params[:search])
+      if !params[:ajax].blank?
+        render :layout => false
+      end
+    end
+
+    def edit
+      authorize! :manage, I18n::Backend::Releaf::Translation
+      @item = current_object_class.find(params[:id])
+    end
+
+    def show
+      authorize! :manage, I18n::Backend::Releaf::Translation
+      redirect_to url_for( :action => "edit", :id => params[:id] )
+    end
+
+    def create
+      authorize! :manage, I18n::Backend::Releaf::Translation
+      @item = current_object_class.new(item_params)
+
+      respond_to do |format|
+        if @item.save
+          update_translations
+          Settings.i18n_updated_at = Time.now
+          format.html { redirect_to url_for(:action => "edit", :id => @item.id) }
+        else
+          format.html { render :action => "new" }
+        end
+      end
+    end
+
+    def update
+      authorize! :manage, I18n::Backend::Releaf::Translation
+      @item = current_object_class.find(params[:id])
+
+      unless params[:translations].blank?
+        ids_to_keep = update_translations
+        @item.translations.where('id NOT IN (?)', ids_to_keep).destroy_all
+      else
+        @item.translations.destroy_all
+      end
+      Settings.i18n_updated_at = Time.now
+
+
+      respond_to do |format|
+        format.html { redirect_to url_for(:action => "edit", :id => @item.id) }
+      end
+    end
+
+
+    private
+
+    def update_translations
+      return [] if params[:translations].blank?
+
+      ids_to_keep = [];
+      params[:translations].each_pair do |id,t|
+        next if t['key'].blank?
+
+        translation = nil
+        if id =~ /\A\d+\z/
+          translation = I18n::Backend::Releaf::Translation.find(id)
+        else
+          translation = @item.translations.new
+        end
+
+        translation.key = params[:translation_group][:scope] + '.' + t['key']
+        translation.save
+
+
+        unless id =~ /\A\d+\z/
+          id = translation.id
+        end
+
+        ids_to_keep.push  id
+
+
+        (Settings.i18n_locales || []).each do |locale|
+          translation_data = I18n::Backend::Releaf::TranslationData.find_or_initialize_by_translation_id_and_lang(id, locale)
+          unless t['localization'][locale].blank?
+            translation_data.localization = t['localization'][locale]
+            translation_data.save
+          else
+            translation_data.destroy
+          end
+        end
+      end
+      return ids_to_keep
+    end
+
+    def item_params
+      params.require(current_object_class_name).permit(:scope)
+    end
+
+  end
+end

data/app/helpers/releaf/admin_helper.rb

@@ -0,0 +1,79 @@
+module Releaf
+  module AdminHelper
+
+    def polymorphic_association_names obj
+      poly_asoc = obj.class.reflect_on_all_associations.map { |r| r.options[:polymorphic] ? r.name : nil }
+      poly_asoc.delete(nil)
+      poly_asoc.map { |pa| pa.to_s }
+    end
+
+    def has_many_association_names obj
+      reflect_all_asoc = obj.reflect_on_all_associations(:has_many)
+      has_many_asoc_names = reflect_all_asoc.map { |asoc| asoc.name }
+
+      reflect_all_asoc.each do |asoc|
+        next unless asoc.options.has_key?(:through)
+        has_many_asoc_names.delete(asoc.name)
+      end
+
+      # don't show translations associaton which is created by globalize3
+      has_many_asoc_names - [:translations]
+    end
+
+
+    def is_this_main_menu_item_active? releaf_main_menu_item
+      _check_if_this_is_valid_releaf_main_menu_item releaf_main_menu_item
+
+      unless releaf_main_menu_item.start_with?('*')
+        return params[:controller] == _menu_item_controller_name(releaf_main_menu_item)
+      else
+        return base_menu_items(releaf_main_menu_item).include? params[:controller]
+      end
+    end
+
+    def main_menu_item_url releaf_main_menu_item, options={}
+      # TODO implement options
+      _check_if_this_is_valid_releaf_main_menu_item releaf_main_menu_item
+
+      unless releaf_main_menu_item.start_with?('*')
+        return url_for(:controller => _menu_item_controller_name(releaf_main_menu_item), :action => _menu_item_action_name(releaf_main_menu_item))
+      else
+        submenu_items = Releaf.base_menu[releaf_main_menu_item]
+
+        # TODO find first item in submenu_items list, that current admin can access
+        first_accessible_item = submenu_items[0][1][0] # currently will find first
+
+        return url_for(:controller => _menu_item_controller_name(first_accessible_item), :action => _menu_item_action_name(first_accessible_item))
+      end
+    end
+
+    def base_menu_items base_menu_name
+      submenu_items = Releaf.base_menu[base_menu_name]
+      return [] if submenu_items.blank?
+
+      all_submenu_items = []
+      submenu_items.each do |group|
+        group[1].each { |item| all_submenu_items.push _menu_item_controller_name(item) }
+      end
+
+      return all_submenu_items
+    end
+
+    private
+
+    def _menu_item_controller_name releaf_menu_item
+      releaf_menu_item.split(/#/, 2).first
+    end
+
+    def _menu_item_action_name releaf_menu_item
+      releaf_menu_item.split(/#/, 2)[2] || 'index'
+    end
+
+    def _check_if_this_is_valid_releaf_main_menu_item item
+      raise ArgumentError, "not a string" unless item.is_a? String
+      raise ArgumentError, "no such Releaf main menu item" unless Releaf.main_menu.include? item
+    end
+
+
+  end
+end

data/app/helpers/releaf/application_helper.rb

@@ -0,0 +1,4 @@
+module Releaf
+  module ApplicationHelper
+  end
+end

data/app/helpers/releaf/pagination_renderer.rb

@@ -0,0 +1,44 @@
+module Releaf
+  module PaginationRenderer
+    # This class does the heavy lifting of actually building the pagination
+    # links. It is used by +will_paginate+ helper internally.
+
+    # This is used in admin/base/_index.footer view
+
+    class LinkRenderer < WillPaginate::ActionView::LinkRenderer
+
+      protected
+
+      def page_number(page)
+        unless page == current_page
+          link(page, page, :rel => rel_value(page), :class => 'button')
+        else
+          tag(:em, "<span>#{page}</span>", :class => 'current active button')
+        end
+      end
+
+      def gap
+        text = '&hellip;'
+        %(<span class="gap button disabled">#{text}</span>)
+      end
+
+      def previous_or_next_page(page, text, classname)
+        if page
+          link(text, page, :class => classname + ' button')
+        else
+          tag(:span, "<span>#{text}</span>", :class => classname + ' button disabled')
+        end
+      end
+
+      def link(text, target, attributes = {})
+        if target.is_a? Fixnum
+          attributes[:rel] = rel_value(target)
+          target = url(target)
+        end
+        attributes[:href] = target
+        tag(:a, "<span>#{text}</span>", attributes)
+      end
+
+    end
+  end
+end

data/app/helpers/releaf/releaf_devise_helper.rb

@@ -0,0 +1,8 @@
+module Releaf
+  module ReleafDeviseHelper
+    # FIXME need better name
+    def self.devise_admin_model_name
+      Releaf.devise_for.underscore.tr('/', '_')
+    end
+  end
+end

data/app/models/releaf/admin.rb

@@ -0,0 +1,51 @@
+module Releaf
+  class Admin < ActiveRecord::Base
+    self.table_name = 'releaf_admins'
+
+    # Include default devise modules. Others available are:
+    # :token_authenticatable, :confirmable,
+    # :lockable, :timeoutable and :omniauthable
+    # :registerable
+    devise :database_authenticatable, :recoverable, :rememberable, :trackable, :validatable
+
+    validates_presence_of :name, :surname, :role_id, :email
+    validates_uniqueness_of :email, :case_sensitive => false
+    belongs_to :role
+
+    image_accessor :avatar
+
+    scope :filter, lambda {|params|
+        fields = []
+        values = {}
+
+        if !params.empty?
+          if !params[:search].blank?
+            params[:search].strip.split(" ").each_with_index do|word, i|
+              fields << "email LIKE :email#{i}"
+              values["email#{i}".to_sym] = '%' + word + '%'
+            end
+          end
+        end
+
+        if !fields.empty?
+          where(fields.join(' AND '), values)
+        end
+    }
+
+    def display_name
+      [self.name, self.surname].join(' ')
+    end
+    alias :to_text :display_name
+
+    def role
+      super || Role.default
+    end
+
+    protected
+
+    def password_required?
+      self.new_record? || self.encrypted_password.blank?
+    end
+
+  end
+end

data/app/models/releaf/node.rb

@@ -0,0 +1,221 @@
+module Releaf
+  class Node < ActiveRecord::Base
+    COMMON_FIELD_NAME_PREFIX = 'data_'
+
+    acts_as_nested_set
+    acts_as_list :scope => :parent_id
+    include Slug
+    self.table_name = 'releaf_nodes'
+
+    serialize :data, Hash
+    default_scope :order => 'position'
+
+    validates_presence_of :name, :slug, :content_type
+    validates_uniqueness_of :slug, :scope => :parent_id
+
+    alias_attribute :to_text, :name
+
+    belongs_to :content, :polymorphic => true, :dependent => :destroy
+    accepts_nested_attributes_for :content
+
+    # FIXME get rid of attr_protected
+    attr_protected :none
+
+    acts_as_url :name, :url_attribute => :slug, :scope => :parent_id #, :only_when_blank => true, :limit => 255
+
+    def content_object
+      self.content
+    end
+
+    def content_object_attributes=(new_attr)
+      if self.content
+        self.content.update_attributes(new_attr)
+      else
+        nc = new_content(new_attr)
+        nc.save
+
+        self.content = nc
+        self.update_attribute(:content_id, nc.id)
+      end
+    end
+
+    ##
+    # Return node public url
+
+    def url
+      if parent_id
+        url = parent.url + "/" + slug.to_s
+      else
+        url = slug.to_s
+      end
+
+      url
+    end
+
+    ##
+    # Return node content object public controller
+
+    def controller
+      raise "Missing content object" if content_object.blank?
+      return "#{content_type}_controller".classify.constantize
+    end
+
+    def self.get_object_from_path path, params = {}
+      node = nil
+      parent_node = nil
+
+      if path.class == String
+        path = path.split("/").reject(&:empty?)
+      end
+
+      unless params[:locale].nil?
+        parent_node = Node.roots.find_by_slug(params[:locale])
+      end
+
+      path.each do |part|
+        node = Node.where(:parent_id => (parent_node ? parent_node.id : nil), :slug => part).first
+        if node
+          parent_node = node
+        else
+          unless params[:strict].blank?
+            node = nil
+          else
+            node = parent_node
+          end
+          break
+        end
+      end
+
+      unless params[:controller].nil?
+        if params[:controller] != node.controller.to_s
+          node = nil
+        end
+      end
+
+      node
+    end
+
+    def to_s
+      name
+    end
+
+    def method_missing(method, *args, &block)
+      if self.class.column_names.include?('data')
+        case method.to_s
+        when /^(#{COMMON_FIELD_NAME_PREFIX}(.+))=$/ then
+          if common_field_names.include? $1
+            return common_field_setter($2, args[0])
+          end
+        when /^(#{COMMON_FIELD_NAME_PREFIX}(.+))$/ then
+          if common_field_names.include? $1
+            return common_field_getter($2)
+          end
+        end
+      end
+
+      return super(method, *args, &block)
+    end
+
+    def respond_to? method_id, include_private = false
+      # this is needed for mass asignment (update_attributes) to work with common_fields
+      rt = super(method_id, include_private)
+      return true if rt
+      return common_field_names.include?(method_id.to_s.sub(/=$/, ''))
+    end
+
+    def common_fields_schema
+      @_common_fields_schema ||= common_fields_schema_for_instance
+    end
+
+    def common_field_names
+      @_common_field_names ||= common_fields_schema.map { |f| "#{COMMON_FIELD_NAME_PREFIX}#{f['field_name']}" }
+    end
+
+    def common_field_field_type(field_name)
+      common_field_options(field_name.sub(/^#{COMMON_FIELD_NAME_PREFIX}/, ''))['field_type']
+    end
+
+    def self.load_common_fields_schema
+
+      common_fields_schema_file = Rails.root.to_s+ '/config/common_fields.yml'
+      cfschema = if File.exists?(common_fields_schema_file)
+        YAML::load_file(common_fields_schema_file)
+      else
+        []
+      end
+
+      raise "common_fields common_fields_schema is not an array" unless cfschema.is_a? Array
+      cfschema.each_with_index do |field,i|
+        raise "common_fields common_fields_schema contains non-hash element in root node"       unless field.is_a? Hash
+        raise "field_name not defined for field ##{i}"                            unless field.has_key?('field_name')
+        raise "field_name must be string"                                         unless field['field_name'].is_a? String
+        raise "field_type not defined for #{field['field_type']} field"           unless field.has_key?('field_type')
+        raise "apply_to not defined for #{field['apply_to']} field"               unless field.has_key?('apply_to')
+      end
+      return cfschema
+    end
+
+    private
+
+    def common_fields_schema_for_instance
+
+      full_schema =if defined?(COMMON_FIELDS_SCHEMA)
+                     COMMON_FIELDS_SCHEMA.dup
+                   else
+                     self.class.load_common_fields_schema.dup
+                   end
+
+      full_schema.delete_if do |field|
+        keep = false
+
+        if field['apply_to'].is_a?(String) && (field['apply_to'] == '*' || field['apply_to'] == self.content_type)
+          keep = true
+        elsif field['apply_to'].is_a?(Array) && field['apply_to'].include?(self.content_type)
+          keep = true
+        else
+          keep = false
+        end
+
+        if keep == true && field.has_key?('deny_for')
+          if field['deny_for'].is_a?(String) && (field['deny_for'] == '*' || field['deny_for'] == self.content_type)
+            keep = false
+          elsif field['deny_for'].is_a?(Array) && field['deny_for'].include?(self.content_type)
+            keep = false
+          end
+        end
+
+        if keep == true && field.has_key?('levels')
+          keep = false unless field['levels'].include? level
+        end
+
+        !keep
+      end
+
+      return full_schema
+    end
+
+    def common_field_setter(key, value)
+      self.data[key] = value
+    end
+
+    def common_field_getter(key)
+      self.data.has_key?(key) ? self.data[key] : common_field_default_value(key)
+    end
+
+    def common_field_options(key)
+      common_fields_schema.each do |field|
+        return field if field['field_name'] == key
+      end
+    end
+
+    def common_field_default_value(key)
+      common_field_options(key)['default']
+    end
+
+    def new_content(attr)
+      raise RuntimeError, 'content_type must be set' unless content_type
+      self.content_type.constantize.new(attr)
+    end
+
+  end
+end