alchemy_cms 2.9.1 → 3.0.0.rc5

data/app/controllers/alchemy/admin/essence_files_controller.rb

@@ -1,13 +1,14 @@
 module Alchemy
   module Admin
     class EssenceFilesController < Alchemy::Admin::BaseController
+      authorize_resource class: Alchemy::EssenceFile
 
       helper "Alchemy::Admin::Contents"
 
       def edit
         @content = Content.find(params[:id])
+        @options = options_from_params
         @essence_file = @content.essence
-        render layout: !request.xhr?
       end
 
       def update
@@ -16,8 +17,8 @@ module Alchemy
       end
 
       def assign
-        @content = Content.find_by_id(params[:id])
-        @attachment = Attachment.find_by_id(params[:attachment_id])
+        @content = Content.find_by(id: params[:content_id])
+        @attachment = Attachment.find_by(id: params[:attachment_id])
         @content.essence.attachment = @attachment
         @options = options_from_params
       end

data/app/controllers/alchemy/admin/essence_pictures_controller.rb

@@ -1,16 +1,17 @@
 module Alchemy
   module Admin
     class EssencePicturesController < Alchemy::Admin::BaseController
+      authorize_resource class: Alchemy::EssencePicture
+
       before_filter :load_essence_picture, only: [:edit, :crop, :update]
       before_filter :load_content, only: [:edit, :update, :assign]
       before_filter :load_options
 
-      helper "alchemy/admin/contents"
-      helper "alchemy/admin/essences"
-      helper "alchemy/url"
+      helper 'alchemy/admin/contents'
+      helper 'alchemy/admin/essences'
+      helper 'alchemy/url'
 
       def edit
-        render layout: !request.xhr?
       end
 
       def crop
@@ -23,11 +24,10 @@ module Alchemy
         else
           @no_image_notice = _t(:no_image_for_cropper_found)
         end
-        render layout: !request.xhr?
       end
 
       def update
-        @essence_picture.update_attributes(params[:essence_picture])
+        @essence_picture.update(essence_picture_params)
       end
 
       # Assigns picture, but does not saves it.
@@ -47,10 +47,10 @@ module Alchemy
         @element = @content.element
         @content_id = @content.id
         @content.destroy
-        @essence_pictures = @element.contents.find_all_by_essence_type('Alchemy::EssencePicture')
+        @essence_pictures = @element.contents.essence_pictures
       end
 
-    private
+      private
 
       def load_options
         @options = options_from_params
@@ -75,14 +75,7 @@ module Alchemy
 
       def sizes_from_essence
         return if @essence_picture.render_size.blank?
-        size_x, size_y = @essence_picture.render_size.split('x').map(&:to_i)
-        if size_x.zero? || size_y.nil? || size_y.zero?
-          size_x_of_original = @essence_picture.picture.image_file_width 
-          size_y_of_original = @essence_picture.picture.image_file_height
-          size_x = size_x_of_original * size_y / size_y_of_original if size_x.zero?
-          size_y = size_y_of_original * size_x / size_x_of_original if size_y.nil? || size_y.zero?
-        end
-        [size_x, size_y]
+        @essence_picture.render_size.split('x')
       end
 
       def sizes_string
@@ -110,6 +103,10 @@ module Alchemy
         end
       end
 
+      def essence_picture_params
+        params.require(:essence_picture).permit(:alt_tag, :caption, :css_class, :render_size, :title, :crop_from, :crop_size)
+      end
+
     end
   end
 end

data/app/controllers/alchemy/admin/languages_controller.rb

@@ -5,7 +5,6 @@ module Alchemy
       def new
         @language = Alchemy::Language.new
         @language.page_layout = (configured_page_layout or @language.page_layout)
-        render :layout => !request.xhr?
       end
 
     protected

data/app/controllers/alchemy/admin/layoutpages_controller.rb

@@ -1,10 +1,11 @@
 module Alchemy
   module Admin
     class LayoutpagesController < Alchemy::Admin::BaseController
+      authorize_resource class: :alchemy_admin_layoutpages
 
       def index
         @locked_pages = Page.from_current_site.all_locked_by(current_alchemy_user)
-        @layout_root = Page.find_or_create_layout_root_for(session[:language_id])
+        @layout_root = Page.find_or_create_layout_root_for(Language.current.id)
         @languages = Language.all
       end
 

data/app/controllers/alchemy/admin/pages_controller.rb

@@ -1,30 +1,25 @@
 module Alchemy
   module Admin
     class PagesController < Alchemy::Admin::BaseController
-      include Ferret::Search
+      helper 'alchemy/pages'
 
-      helper "alchemy/pages"
+      before_action :set_translation,
+        except: [:show]
 
-      before_filter :set_translation, :except => [:show]
+      before_action :load_page,
+        only: [:show, :info, :unlock, :visit, :publish, :configure, :edit, :update, :destroy, :fold]
 
-      filter_access_to [:show, :info, :unlock, :visit, :publish, :configure, :edit, :update, :destroy, :fold], :attribute_check => true, :load_method => :load_page, :model => Alchemy::Page
-      filter_access_to [:index, :link, :layoutpages, :new, :switch_language, :create, :move, :flush], :attribute_check => false
+      before_action :set_root_page,
+        only: [:index, :show, :sort, :order]
 
-      cache_sweeper Alchemy::PagesSweeper, :only => [:publish], :if => proc { Alchemy::Config.get(:cache_pages) }
-      cache_sweeper Alchemy::ContentSweeper, :only => [:create, :update, :destroy]
+      authorize_resource class: Alchemy::Page
 
       def index
-        @page_root = Page.language_root_for(session[:language_id])
         @locked_pages = Page.from_current_site.all_locked_by(current_alchemy_user)
         @languages = Language.all
         if !@page_root
-          if @languages.length == 1
-            @language = @languages.first
-            store_language_in_session(@language)
-          else
-            @language = @languages.find { |language| language.id == session[:language_id] }
-          end
-          @languages_with_page_tree = Language.all_for_created_language_trees if @language
+          @language = Language.current
+          @languages_with_page_tree = Language.with_root_page
         end
       end
 
@@ -32,13 +27,13 @@ module Alchemy
       #
       def show
         @preview_mode = true
-        @root_page = Page.language_root_for(session[:language_id])
-        # Setting the locale to pages language. so the page content has its correct translation
+        Page.current_preview = @page
+        # Setting the locale to pages language, so the page content has it's correct translations.
         ::I18n.locale = @page.language_code
-        render :layout => layout_for_page
+        render layout: 'application'
       rescue Exception => e
         exception_logger(e)
-        render :file => Rails.root.join('public', '500.html'), :status => 500, :layout => false
+        render file: Rails.root.join('public', '500.html'), status: 500, layout: false
       end
 
       def info
@@ -46,28 +41,21 @@ module Alchemy
       end
 
       def new
-        @page = Page.new(:layoutpage => params[:layoutpage] == 'true', :parent_id => params[:parent_id])
-        @page_layouts = PageLayout.layouts_for_select(session[:language_id], @page.layoutpage?)
-        @clipboard_items = Page.all_from_clipboard_for_select(get_clipboard[:pages], session[:language_id], @page.layoutpage?)
-        render layout: !request.xhr?
+        @page = Page.new(layoutpage: params[:layoutpage] == 'true', parent_id: params[:parent_id])
+        @page_layouts = PageLayout.layouts_for_select(Language.current.id, @page.layoutpage?)
+        @clipboard_items = Page.all_from_clipboard_for_select(get_clipboard[:pages], Language.current.id, @page.layoutpage?)
       end
 
       def create
-        if params[:paste_from_clipboard]
-          source = Page.find(params[:paste_from_clipboard])
-          parent = Page.find_by_id(params[:page][:parent_id]) || Page.root
-          @page = Page.paste_from_clipboard(source, parent, params[:page][:name])
-        else
-          @page = Page.new(params[:page])
-          @page.set_language_from_parent_or_default_language
-        end
+        @page = paste_from_clipboard || Page.new(page_params)
         if @page.save
-          redirect_path = redirect_path_after_page_create
+          flash[:notice] = _t("Page created", name: @page.name)
+          do_redirect_to(redirect_path_after_create_page)
         else
-          # TODO: Make a rollback, because the page is already persisted here.
-          redirect_path = admin_pages_path
+          @page_layouts = PageLayout.layouts_for_select(Language.current.id, @page.layoutpage?)
+          @clipboard_items = Page.all_from_clipboard_for_select(get_clipboard[:pages], Language.current.id, @page.layoutpage?)
+          render :new
         end
-        render_errors_or_redirect(@page, redirect_path, _t("Page created", :name => @page.name))
       end
 
       # Edit the content of the page and all its elements and contents.
@@ -77,7 +65,7 @@ module Alchemy
           flash[:notice] = _t("This page is locked by %{name}", name: @page.locker_name)
           redirect_to admin_pages_path
         else
-          @page.lock!(current_alchemy_user)
+          @page.lock_to!(current_alchemy_user)
           @locked_pages = Page.from_current_site.all_locked_by(current_alchemy_user)
         end
         @layoutpage = @page.layoutpage?
@@ -85,24 +73,22 @@ module Alchemy
 
       # Set page configuration like page names, meta tags and states.
       def configure
-        # fetching page via before filter
-        if @page.redirects_to_external?
-          render action: 'configure_external', layout: !request.xhr?
-        else
-          @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, session[:language_id], @page.layoutpage?)
-          render layout: !request.xhr?
-        end
+        @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, Language.current.id, @page.layoutpage?)
+        render @page.redirects_to_external? ? 'configure_external' : 'configure'
       end
 
+      # Updates page
+      #
+      # * fetches page via before filter
+      #
       def update
-        # fetching page via before filter
-        # storing old page_layout value, because unfurtunally rails @page.changes does not work here.
+        # stores old page_layout value, because unfurtunally rails @page.changes does not work here.
         @old_page_layout = @page.page_layout
-        if @page.update_attributes(params[:page])
+        if @page.update_attributes(page_params)
           @notice = _t("Page saved", :name => @page.name)
           @while_page_edit = request.referer.include?('edit')
         else
-          render_remote_errors(@page)
+          configure
         end
       end
 
@@ -112,7 +98,7 @@ module Alchemy
         @page_id = @page.id
         @layoutpage = @page.layoutpage?
         if @page.destroy
-          @page_root = Page.language_root_for(session[:language_id])
+          set_root_page
           @message = _t("Page deleted", :name => name)
           flash[:notice] = @message
           respond_to do |format|
@@ -128,7 +114,7 @@ module Alchemy
         if configuration(:show_real_root)
           @page_root = Page.root
         else
-          @page_root = Page.language_root_for(session[:language_id])
+          set_root_page
         end
         @area_name = params[:area_name]
         @content_id = params[:content_id]
@@ -137,9 +123,8 @@ module Alchemy
           @url_prefix = current_server
         end
         if multi_language?
-          @url_prefix = "#{session[:language_code]}/"
+          @url_prefix = "#{Language.current.code}/"
         end
-        render layout: !request.xhr?
       end
 
       def fold
@@ -169,7 +154,8 @@ module Alchemy
         redirect_to show_page_path(:urlname => @page.urlname, :lang => multi_language? ? @page.language_code : nil)
       end
 
-      # Sets the page public and sweeps the page cache
+      # Sets the page public and updates the published_at attribute that is used as cache_key
+      #
       def publish
         # fetching page via before filter
         @page.publish!
@@ -178,62 +164,38 @@ module Alchemy
       end
 
       def copy_language_tree
-        # copy language root from old to new language
-        if params[:layoutpage]
-          original_language_root = Page.layout_root_for(params[:languages][:old_lang_id])
-        else
-          original_language_root = Page.language_root_for(params[:languages][:old_lang_id])
-        end
-        new_language_root = Page.copy(
-          original_language_root,
-          :language_id => params[:languages][:new_lang_id],
-          :language_code => session[:language_code]
-        )
-        new_language_root.move_to_child_of Page.root
-        original_language_root.copy_children_to(new_language_root)
+        language_root_to_copy_from.copy_children_to(copy_of_language_root)
         flash[:notice] = _t(:language_pages_copied)
-        redirect_to params[:layoutpage] == "true" ? admin_layoutpages_path : :action => :index
+        redirect_to admin_pages_path
       end
 
       def sort
-        @page_root = Page.language_root_for(session[:language_id])
         @sorting = true
       end
 
-      # Receives a JSON object representing a language tree to be ordered
-      # and updates all pages in that language structure to their correct indexes
       def order
+        # Taken from https://github.com/matenia/jQuery-Awesome-Nested-Set-Drag-and-Drop
         neworder = JSON.parse(params[:set])
-        rootpage = Page.language_root_for(session[:language_id])
-
-        tree = create_tree(neworder, rootpage)
-
-        Alchemy::Page.transaction do
-          tree.each do |key, node|
-            dbitem = Page.find(key)
-            dbitem.update_node!(node)
-          end
+        prev_item = nil
+        neworder.each do |item|
+          dbitem = Page.find(item['id'])
+          prev_item.nil? ? dbitem.move_to_child_of(@page_root) : dbitem.move_to_right_of(prev_item)
+          sort_children(item, dbitem) unless item['children'].nil?
+          prev_item = dbitem.reload
         end
 
         flash[:notice] = _t("Pages order saved")
-        @redirect_url = admin_pages_path
-        render :action => :redirect
+        do_redirect_to admin_pages_path
       end
 
       def switch_language
-        set_language(params[:language_id])
-        redirect_path = request.referer.include?('admin/layoutpages') ? admin_layoutpages_path : admin_pages_path
-        if request.xhr?
-          @redirect_url = redirect_path
-          render :action => :redirect
-        else
-          redirect_to redirect_path
-        end
+        set_alchemy_language(params[:language_id])
+        do_redirect_to redirect_path_for_switch_language
       end
 
       def flush
-        Page.with_language(session[:language_id]).flushables.each do |page|
-          expire_action(page.cache_key)
+        Language.current.pages.flushables.each do |page|
+          page.publish!
         end
         respond_to do |format|
           format.js
@@ -242,83 +204,18 @@ module Alchemy
 
       private
 
-      # Returns the current left index and the aggregated hash of tree nodes indexed by page id visited so far
-      #
-      # Visits a batch of children nodes, assigns them the correct ordering indexes and spuns recursively the same
-      # procedure on their children, if any
-      #
-      # @param [Array]
-      #   An array of children nodes to be visited
-      # @param [Integer]
-      #   The lft attribute that should be given to the first node in the array
-      # @param [Integer]
-      #   The page id of the parent of this batch of children nodes
-      # @param [Integer]
-      #   The depth at which these children reside
-      # @param [Hash]
-      #   A Hash of TreeNode's indexed by their page ids
-      # @param [String]
-      #   The url for the parent node of these children
-      # @param [Boolean]
-      #   Whether these children reside in a restricted branch according to their ancestors
-      #
-      def visit_nodes(nodes, my_left, parent, depth, tree, url, restricted)
-        nodes.each do |item|
-          my_right = my_left + 1
-          my_restricted = item['restricted'] || restricted
-          urls = process_url(url, item)
-
-          if item['children']
-            my_right, tree = visit_nodes(item['children'], my_left + 1, item['id'], depth + 1, tree, urls[:children_path], my_restricted)
-          end
-
-          tree[item['id']] = TreeNode.new(my_left, my_right, parent, depth, urls[:my_urlname], my_restricted)
-          my_left = my_right + 1
-        end
-
-        [my_left, tree]
-      end
-
-      # Returns a Hash of TreeNode's indexed by their page ids
-      #
-      # Grabs the array representing a tree structure of pages passed as a parameter,
-      # visits it and creates a map of TreeNodes indexed by page id featuring Nested Set
-      # ordering information consisting of the left, right, depth and parent_id indexes as
-      # well as a node's url and restricted status
-      #
-      # @param [Array]
-      #   An Array representing a tree of Alchemy::Page's
-      # @param [Alchemy::Page]
-      #   The root page for the language being ordered
-      #
-      def create_tree(items, rootpage)
-        _, tree = visit_nodes(items, rootpage.lft + 1, rootpage.id, rootpage.depth + 1, {}, "", rootpage.restricted)
-        tree
+      def copy_of_language_root
+        page_copy = Page.copy(
+          language_root_to_copy_from,
+          language_id: params[:languages][:new_lang_id],
+          language_code: Language.current.code
+        )
+        page_copy.move_to_child_of Page.root
+        page_copy
       end
 
-      # Returns a pair, the path that a given tree node should take, and the path its children should take
-      #
-      # This function will add a node's own slug into their ancestor's path
-      # in order to create the full URL of a node
-      #
-      # NOTE: external and invisible pages are not part of the full path of their children
-      #
-      # @param [String]
-      #   The node's ancestors path
-      # @param [Hash]
-      #   A children node
-      #
-      def process_url(ancestors_path, item)
-        default_urlname = (ancestors_path.blank? ? "" : "#{ancestors_path}/") + item['slug'].to_s
-
-        pair = {my_urlname: default_urlname, children_path: default_urlname}
-
-        if item['external'] == true || item['visible'] == false
-          # children ignore an ancestor in their path if external or invisible
-          pair[:children_path] = ancestors_path
-        end
-
-        pair
+      def language_root_to_copy_from
+        Page.language_root_for(params[:languages][:old_lang_id])
       end
 
       def load_page
@@ -329,7 +226,26 @@ module Alchemy
         request.raw_post.split('&').map { |i| i = {i.split('=')[0].gsub(/[^0-9]/, '') => i.split('=')[1]} }
       end
 
-      def redirect_path_after_page_create
+      # Taken from https://github.com/matenia/jQuery-Awesome-Nested-Set-Drag-and-Drop
+      def sort_children(element, dbitem)
+        prevchild = nil
+        element['children'].each do |child|
+          childitem = Page.find(child['id'])
+          prevchild.nil? ? childitem.move_to_child_of(dbitem) : childitem.move_to_right_of(prevchild)
+          sort_children(child, childitem) unless child['children'].nil?
+          prevchild = childitem
+        end
+      end
+
+      def redirect_path_for_switch_language
+        if request.referer && request.referer.include?('admin/layoutpages')
+          admin_layoutpages_path
+        else
+          admin_pages_path
+        end
+      end
+
+      def redirect_path_after_create_page
         if @page.redirects_to_external?
           admin_pages_path
         else
@@ -337,11 +253,35 @@ module Alchemy
         end
       end
 
+      def page_params
+        params.require(:page).permit(*secure_attributes)
+      end
+
+      def secure_attributes
+        if can?(:create, Alchemy::Page)
+          Page::PERMITTED_ATTRIBUTES + [:language_root, :parent_id, :language_id, :language_code]
+        else
+          Page::PERMITTED_ATTRIBUTES
+        end
+      end
+
       def page_is_locked?
         return if !@page.locker.try(:logged_in?)
         @page.locked? && @page.locker != current_alchemy_user
       end
 
+      def paste_from_clipboard
+        if params[:paste_from_clipboard]
+          source = Page.find(params[:paste_from_clipboard])
+          parent = Page.find_by(id: params[:page][:parent_id]) || Page.root
+          Page.copy_and_paste(source, parent, params[:page][:name])
+        end
+      end
+
+      def set_root_page
+        @page_root = Language.current_root_page
+      end
+
     end
   end
 end