releaf 0.1.2 → 1.0.2

data/app/controllers/releaf/content_controller.rb

@@ -1,183 +0,0 @@
-module Releaf
-  class ContentController < BaseController
-    helper_method :content_fields_to_display
-
-    def content_fields_to_display obj_class
-      if obj_class.respond_to? :releaf_fields_to_display
-        obj_class.releaf_fields_to_display params[:action]
-      else
-        obj_class.column_names - %w[id created_at updated_at position]
-      end
-    end
-
-    def fields_to_display
-      return super unless params[:action] == 'show'
-      return %w[name parent_id visible protected content]
-    end
-
-    def build_secondary_panel_variables
-      @nodes = Node.roots
-      super
-    end
-
-    def index
-      authorize! :index, Node
-      respond_to do |format|
-        format.html
-      end
-    end
-
-    def create
-      content_type = _node_params[:content_type].constantize
-      authorize! :create, content_type
-      @resource = resource_class.new(_node_params)
-
-      respond_to do |format|
-        if @resource.save
-          format.html { redirect_to url_for(:action => "edit", :controller => 'content', :id => @resource.id)}
-        else
-          form_extras
-          @order_nodes = Node.where(:parent_id => (params[:parent_id] ? params[:parent_id] : nil))
-          format.html { render action: "new" }
-        end
-      end
-    end
-
-    def generate_url
-      tmp_resource = nil
-
-      if params[:id]
-        tmp_resource = Node.find(params[:id])
-      elsif params[:parent_id].blank? == false
-        parent = Node.find(params[:parent_id])
-        tmp_resource = parent.children.new
-      else
-        tmp_resource = Node.new
-      end
-
-      tmp_resource.name = params[:name]
-      tmp_resource.slug = nil
-      # FIXME calling private method
-      tmp_resource.send(:ensure_unique_url)
-
-      respond_to do |format|
-        format.js { render :text => tmp_resource.slug }
-      end
-    end
-
-    def update
-      @resource = resource_class.find(params[:id])
-      authorize! :edit, @resource
-
-      form_extras
-      @order_nodes = Node.where(:parent_id => (@resource.parent_id ? @resource.parent_id : nil)).where('id != :id', :id => params[:id])
-
-      @resource.assign_attributes(_node_params)
-
-
-      respond_to do |format|
-        if @resource.save
-          format.html { redirect_to url_for(:action => "edit") }
-        else
-          format.html { render action: "edit" }
-        end
-      end
-    end
-
-    def new
-      authorize! :create, resource_class
-      unless params[:ajax] == '1'
-        super
-        @order_nodes = Node.where(:parent_id => (params[:parent_id] ? params[:parent_id] : nil))
-        @position = 1
-        @resource.parent_id = params[:parent_id]
-        form_extras
-      else
-        Rails.application.eager_load!
-        get_base_models
-        render 'ajax.new', :layout => nil
-      end
-    end
-
-    def edit
-      super
-      @order_nodes = Node.where(:parent_id => (@resource.parent_id ? @resource.parent_id : nil)).where('id != :id', :id => params[:id])
-
-      if @resource.higher_item
-        @position = @resource.position
-      else
-        @position = 1
-      end
-
-      form_extras
-    end
-
-    def setup
-      super
-      @features[:show] = false
-    end
-
-    def get_content_form
-      Rails.application.eager_load!
-      raise ArgumentError unless content_type_class_names.include? params[:content_type]
-      @node = resource_class.find(params[:id])
-      authorize! :edit, @resource
-
-      @resource = params[:content_type].constantize.new
-
-      respond_to do |format|
-        format.html { render :partial => 'get_content_form', :layout => false }
-      end
-
-    end
-
-    def resource_class
-      Node
-    end
-
-    protected
-
-    def _node_params
-      params.require(:resource).permit!
-    end
-
-    private
-
-    def content_type_class_names
-      content_type_classes.map { |nc| nc.name }.sort
-    end
-
-    def content_type_classes
-      NodeBase.node_classes + BlankNodeBase.node_classes
-    end
-
-    def form_extras
-      Rails.application.eager_load!
-      get_base_models
-
-      new_content_if_needed
-    end
-
-    def resource_params
-      []
-    end
-
-    def new_content_if_needed
-      return if @resource.content
-      if params[:content_type]
-        if get_base_models.map { |bm| bm.name }.include? params[:content_type]
-          @resource.content_type = params[:content_type]
-          content_class = @resource.content_type.constantize
-          if content_class.node_type == 'Releaf::NodeBase'
-            @resource.content = @resource.content_type.constantize.new
-          end
-        end
-      end
-    end
-
-    def get_base_models
-      @base_models ||= content_type_classes
-    end
-
-  end
-end

data/app/controllers/releaf/roles_controller.rb

@@ -1,38 +0,0 @@
-module Releaf
-  class RolesController < BaseController
-
-    def resource_class
-      Releaf::Role
-    end
-
-    def fields_to_display
-      case params[:action].to_sym
-      when :index
-        %w[name default_controller default]
-      when :create, :edit, :new, :update, :show
-        %w[name default default_controller permissions]
-      else
-        []
-      end
-    end
-
-    protected
-
-    def resource_params
-      return [] unless %w[update create].include? params[:action]
-
-      fields = ['name', 'default', 'default_controller']
-      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

@@ -1,27 +0,0 @@
-module Releaf
-  class SessionsController < Devise::SessionsController
-    layout "releaf/devise"
-
-    def after_sign_in_path_for(resource)
-      controller_name = resource.role.default_controller
-
-      if controller_name
-        if controller_name == 'content'
-          default_path = releaf_nodes_path
-        elsif controller_name == 'translations'
-          default_path = releaf_translation_groups_path
-        else
-          default_path = send("admin_#{controller_name}_path")
-        end
-      else
-        default_path = releaf_nodes_path
-      end
-
-      return default_path
-    end
-
-    def full_controller_name
-      self.class.name.sub(/Controller$/, '').underscore
-    end
-  end
-end

data/app/controllers/releaf/tinymce_assets_controller.rb

@@ -1,26 +0,0 @@
-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

@@ -1,117 +0,0 @@
-module Releaf
-  class TranslationsController < BaseController
-
-    def resource_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
-      @resources = @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
-      @resource = resource_class.find(params[:id])
-    end
-
-    def create
-      authorize! :manage, I18n::Backend::Releaf::Translation
-      @resource = resource_class.new(resource_params)
-
-      respond_to do |format|
-        if @resource.save
-          update_translations
-          Settings.i18n_updated_at = Time.now
-          format.html { redirect_to url_for(:action => "edit", :id => @resource.id) }
-        else
-          format.html { render :action => "new" }
-        end
-      end
-    end
-
-    def update
-      authorize! :manage, I18n::Backend::Releaf::Translation
-      @resource = resource_class.find(params[:id])
-
-      unless params[:translations].blank?
-        ids_to_keep = update_translations
-        @resource.translations.where('id NOT IN (?)', ids_to_keep).destroy_all
-      else
-        @resource.translations.destroy_all
-      end
-      Settings.i18n_updated_at = Time.now
-
-
-      respond_to do |format|
-        format.html { redirect_to url_for(:action => "edit", :id => @resource.id) }
-      end
-    end
-
-    protected
-
-    def setup
-      super
-      @object_class = I18n::Backend::Releaf::TranslationGroup
-      @features[:show] = false
-      @continuous_scroll = true
-    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 = @resource.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 resource_params
-      params.require(:resource).permit(:scope)
-    end
-
-  end
-end

data/app/helpers/releaf/admin_helper.rb

@@ -1,59 +0,0 @@
-module Releaf
-  module AdminHelper
-
-    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