lc_alchemy_cms 3.2.0

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

@@ -0,0 +1,190 @@
+module Alchemy
+  module Admin
+    class ElementsController < Alchemy::Admin::BaseController
+      before_action :load_element, only: [:update, :trash, :fold]
+      authorize_resource class: Alchemy::Element
+
+      def index
+        @page = Page.find(params[:page_id])
+        @cells = @page.cells
+        if @cells.blank?
+          @elements = @page.elements.not_trashed
+        else
+          @elements = @page.elements_grouped_by_cells
+        end
+      end
+
+      def list
+        @page_id = params[:page_id]
+        if @page_id.blank? && !params[:page_urlname].blank?
+          @page_id = Language.current.pages.find_by(urlname: params[:page_urlname]).id
+        end
+        @elements = Element.published.where(page_id: @page_id)
+      end
+
+      def new
+        @page = Page.find_by_id(params[:page_id])
+        @element = @page.elements.build
+        @elements = @page.available_element_definitions
+        @clipboard = get_clipboard('elements')
+        @clipboard_items = Element.all_from_clipboard_for_page(@clipboard, @page)
+      end
+
+      # Creates a element as discribed in config/alchemy/elements.yml on page via AJAX.
+      def create
+        @page = Page.find(params[:element][:page_id])
+        Element.transaction do
+          if @paste_from_clipboard = params[:paste_from_clipboard].present?
+            @element = paste_element_from_clipboard
+            @cell = @element.cell
+          else
+            @element = Element.new_from_scratch(params[:element])
+            if @page.can_have_cells?
+              @cell = find_or_create_cell
+              @element.cell = @cell
+            end
+            @element.save
+          end
+          if @page.definition['insert_elements_at'] == 'top'
+            @insert_at_top = true
+            @element.move_to_top
+          end
+        end
+        @cell_name = @cell.nil? ? "for_other_elements" : @cell.name
+        if @element.valid?
+          render :create
+        else
+          @element.page = @page
+          @elements = @page.available_element_definitions
+          @clipboard = get_clipboard('elements')
+          @clipboard_items = Element.all_from_clipboard_for_page(@clipboard, @page)
+          render :new
+        end
+      end
+
+      # Updates the element.
+      #
+      # And update all contents in the elements by calling update_contents.
+      #
+      def update
+        if @element.update_contents(contents_params)
+          @page = @element.page
+          @element_validated = @element.update_attributes!(element_params)
+
+          Rails.logger.info "[ALCHEMY_LOCALE] updating contents for element in elements_controller#update: #{@element}"
+          update_translations(@element) if @element.page.language.language_code == 'en'
+        else
+          @element_validated = false
+          @notice = _t('Validation failed')
+          @error_message = "<h2>#{@notice}</h2><p>#{_t(:content_validations_headline)}</p>".html_safe
+        end
+      end
+
+      # Trashes the Element instead of deleting it.
+      def trash
+        @page = @element.page
+        @element.trash!
+      end
+
+      def order
+        @trashed_element_ids = Element.trashed.where(id: params[:element_ids]).pluck(:id)
+        Element.transaction do
+          params[:element_ids].each_with_index do |element_id, idx|
+            # Ensure to set page_id and cell_id to the current page and
+            # cell because of trashed elements could still have old values
+            Element.where(id: element_id).update_all(
+              page_id: params[:page_id],
+              cell_id: params[:cell_id],
+              position: idx + 1
+            )
+          end
+        end
+      end
+
+      def fold
+        @page = @element.page
+        @element.folded = !@element.folded
+        @element.save
+      end
+
+      private
+      def update_translations(element)
+        locale = element.page.language.language_code
+
+        # do _not_ update foreign languages from alchemy
+        return unless locale == 'en'
+
+        element.essences.each do |essence|
+          next unless [Alchemy::EssenceText,Alchemy::EssenceRichtext,Alchemy::EssenceHtml].include? essence.class
+          key = essence.content.name
+          description = essence.body
+
+          Rails.logger.info "[ALCHEMY_LOCALE] locale/key/value added to localeapp queue: #{locale}/#{key}/#{description}"
+
+          Localeapp.missing_translations.add(locale, "#{Alchemy::Translations::TRANSLATION_PREFIX}#{key}", description)
+        end
+
+        Rails.logger.info "[ALCHEMY_LOCALE] posting missing translations to locale"
+
+        Localeapp.sender.post_missing_translations
+      end
+
+      def load_element
+        @element = Element.find(params[:id])
+      end
+
+      # Returns the cell for element name in params.
+      # Creates the cell if necessary.
+      def find_or_create_cell
+        if @paste_from_clipboard
+          element_with_cell_name = params[:paste_from_clipboard]
+        else
+          element_with_cell_name = params[:element][:name]
+        end
+        return nil if element_with_cell_name.blank?
+        return nil unless element_with_cell_name.include?('#')
+        cell_name = element_with_cell_name.split('#').last
+        cell_definition = Cell.definition_for(cell_name)
+        if cell_definition.blank?
+          raise CellDefinitionError, "Cell definition not found for #{cell_name}"
+        end
+        @page.cells.find_or_create_by(name: cell_definition['name'])
+      end
+
+      def element_from_clipboard
+        @element_from_clipboard ||= begin
+          @clipboard = get_clipboard('elements')
+          @clipboard.detect { |item| item['id'].to_i == params[:paste_from_clipboard].to_i }
+        end
+      end
+
+      def paste_element_from_clipboard
+        @source_element = Element.find(element_from_clipboard['id'])
+        new_attributes = {:page_id => @page.id}
+        if @page.can_have_cells?
+          new_attributes = new_attributes.merge({:cell_id => find_or_create_cell.try(:id)})
+        end
+        element = Element.copy(@source_element, new_attributes)
+        if element_from_clipboard['action'] == 'cut'
+          cut_element
+        end
+        element
+      end
+
+      def cut_element
+        @cutted_element_id = @source_element.id
+        @clipboard.delete_if { |item| item['id'] == @source_element.id.to_s }
+        @source_element.destroy
+      end
+
+      def contents_params
+        params.fetch(:contents, {}).permit!
+      end
+
+      def element_params
+        params.require(:element).permit(:public, :tag_list)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Alchemy
+  module Admin
+    class EssenceFilesController < Alchemy::Admin::BaseController
+      authorize_resource class: Alchemy::EssenceFile
+
+      before_filter :load_essence_file, only: [:edit, :update]
+
+      helper "Alchemy::Admin::Contents"
+
+      def edit
+        @content = @essence_file.content
+        @options = options_from_params
+      end
+
+      def update
+        @essence_file.update(essence_file_params)
+      end
+
+      # Assigns file, but does not saves it.
+      #
+      # When the user saves the element the content gets updated as well.
+      #
+      def assign
+        @content = Content.find_by(id: params[:content_id])
+        @attachment = Attachment.find_by(id: params[:attachment_id])
+        @content.essence.attachment = @attachment
+        @options = options_from_params
+
+        # We need to update timestamp here because we don't save yet,
+        # but the cache needs to be get invalid.
+        # And we don't user @content.touch here, because that updates
+        # also the element and page timestamps what we don't want yet.
+        @content.update_column(:updated_at, Time.now)
+      end
+
+      private
+
+      def essence_file_params
+        params.require(:essence_file).permit(:title, :css_class)
+      end
+
+      def load_essence_file
+        @essence_file = EssenceFile.find(params[:id])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+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'
+
+      def edit
+      end
+
+      def crop
+        if @picture = @essence_picture.picture
+          @content = @essence_picture.content
+          @options[:format] ||= (configuration(:image_store_format) or 'png')
+
+          @min_size = sizes_from_essence_or_params
+          @ratio = ratio_from_size_or_params
+          infer_width_or_height_from_ratio
+
+          @default_box = @essence_picture.default_mask(@min_size)
+          @initial_box = @essence_picture.cropping_mask || @default_box
+        else
+          @no_image_notice = _t(:no_image_for_cropper_found)
+        end
+      end
+
+      def update
+        @essence_picture.update(essence_picture_params)
+      end
+
+      # Assigns picture, but does not saves it.
+      #
+      # When the user saves the element the content gets updated as well.
+      #
+      def assign
+        @picture = Picture.find_by(id: params[:picture_id])
+        @content.essence.picture = @picture
+        @element = @content.element
+        @dragable = @options[:grouped]
+        @options = @options.merge(dragable: @dragable)
+
+        # We need to update timestamp here because we don't save yet,
+        # but the cache needs to be get invalid.
+        # And we don't user @content.touch here, because that updates
+        # also the element and page timestamps what we don't want yet.
+        @content.update_column(:updated_at, Time.now)
+      end
+
+      def destroy
+        @content = Content.find_by(id: params[:id])
+        @element = @content.element
+        @content_id = @content.id
+        @content.destroy
+        @essence_pictures = @element.contents.essence_pictures
+      end
+
+      private
+
+      def load_options
+        @options = options_from_params
+      end
+
+      def load_essence_picture
+        @essence_picture = EssencePicture.find(params[:id])
+      end
+
+      def load_content
+        @content = Content.find(params[:content_id])
+      end
+
+      # Gets the minimum size of the image to be rendered. the database render_size
+      # has preference over the image_size parameter.
+      #
+      def sizes_from_essence_or_params
+        if @essence_picture.render_size? && !@essence_picture.render_size.blank?
+          @essence_picture.sizes_from_string(@essence_picture.render_size)
+        elsif @options[:image_size]
+          @essence_picture.sizes_from_string(@options[:image_size])
+        else
+          { width: 0, height: 0 }
+        end
+      end
+
+      # Infers the aspect ratio from size or parameters. If you don't want a fixed
+      # aspect ratio, don't specify a size or only width or height.
+      #
+      def ratio_from_size_or_params
+        if @min_size.has_value?(0) && @options[:fixed_ratio]
+          @options[:fixed_ratio].to_f
+        elsif !@min_size[:width].zero? && !@min_size[:height].zero?
+          @min_size[:width].to_f / @min_size[:height].to_f
+        else
+          false
+        end
+      end
+
+      # Infers the minimum width or height if the aspect ratio and one dimension
+      # is specified.
+      #
+      def infer_width_or_height_from_ratio
+        if @min_size[:height].zero?
+          @min_size[:height] = (@min_size[:width] / @ratio).to_i if @ratio
+        else
+          @min_size[:width] = (@min_size[:height] * @ratio).to_i if @ratio
+        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

@@ -0,0 +1,17 @@
+module Alchemy
+  module Admin
+    class LanguagesController < ResourcesController
+
+      def new
+        @language = Language.new
+        @language.page_layout = configured_page_layout || @language.page_layout
+      end
+
+      private
+
+      def configured_page_layout
+        Config.get(:default_language).try('[]', 'page_layout')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+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(Language.current.id)
+        @languages = Language.all
+      end
+
+      def edit
+        @page = Page.find(params[:id])
+        @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, Language.current.id, true)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Alchemy
+  class Admin::LegacyPageUrlsController < Alchemy::Admin::ResourcesController
+    before_action :load_page
+
+    def new
+      @legacy_page_url = @page.legacy_urls.build
+    end
+
+    def create
+      @legacy_page_url = @page.legacy_urls.build(legacy_page_url_params)
+      @legacy_page_url.save
+    end
+
+    def update
+      @legacy_page_url = LegacyPageUrl.find(params[:id])
+      if @legacy_page_url.update(legacy_page_url_params)
+        render :update
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @legacy_page_url = LegacyPageUrl.find(params[:id])
+      @legacy_page_url.destroy
+    end
+
+    private
+
+    def load_page
+      @page = Page.find(params[:page_id])
+    end
+
+    def legacy_page_url_params
+      params.require(:legacy_page_url).permit(:urlname)
+    end
+
+  end
+end

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

@@ -0,0 +1,359 @@
+module Alchemy
+  module Admin
+    class PagesController < Alchemy::Admin::BaseController
+      helper 'alchemy/pages'
+
+      before_action :set_translation,
+        except: [:show]
+
+      before_action :load_page,
+        only: [:show, :info, :unlock, :visit, :publish, :configure, :edit, :update, :destroy, :fold]
+
+      before_action :set_root_page,
+        only: [:index, :show, :sort, :order]
+
+      authorize_resource class: Alchemy::Page, except: :index
+
+      def index
+        authorize! :index, :alchemy_admin_pages
+
+        @locked_pages = Page.from_current_site.all_locked_by(current_alchemy_user)
+        @languages = Language.all
+        if !@page_root
+          @language = Language.current
+          @languages_with_page_tree = Language.with_root_page
+        end
+      end
+
+      # Used by page preview iframe in Page#edit view.
+      #
+      def show
+        @preview_mode = true
+        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: 'application'
+      end
+
+      def info
+        render layout: !request.xhr?
+      end
+
+      def new
+        @page = Page.new(layoutpage: params[:layoutpage] == 'true', parent_id: params[:parent_id])
+        @page_layouts = PageLayout.layouts_for_select(Language.current.id, @page.layoutpage?)
+        @clipboard = get_clipboard('pages')
+        @clipboard_items = Page.all_from_clipboard_for_select(@clipboard, Language.current.id, @page.layoutpage?)
+      end
+
+      def create
+        @page = paste_from_clipboard || Page.new(page_params)
+        if @page.save
+          flash[:notice] = _t("Page created", name: @page.name)
+          do_redirect_to(redirect_path_after_create_page)
+        else
+          @page_layouts = PageLayout.layouts_for_select(Language.current.id, @page.layoutpage?)
+          @clipboard = get_clipboard('pages')
+          @clipboard_items = Page.all_from_clipboard_for_select(@clipboard, Language.current.id, @page.layoutpage?)
+          render :new
+        end
+      end
+
+      # Edit the content of the page and all its elements and contents.
+      def edit
+        # fetching page via before filter
+        if page_is_locked?
+          flash[:notice] = _t('This page is locked', name: @page.locker_name)
+          redirect_to admin_pages_path
+        else
+          @page.lock_to!(current_alchemy_user)
+          @locked_pages = Page.from_current_site.all_locked_by(current_alchemy_user)
+        end
+        @layoutpage = @page.layoutpage?
+      end
+
+      # Set page configuration like page names, meta tags and states.
+      def configure
+        @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
+        # stores old page_layout value, because unfurtunally rails @page.changes does not work here.
+        @old_page_layout = @page.page_layout
+        if @page.update_attributes(page_params)
+          @notice = _t("Page saved", :name => @page.name)
+          @while_page_edit = request.referer.include?('edit')
+        else
+          configure
+        end
+      end
+
+      def destroy
+        # fetching page via before filter
+        name = @page.name
+        @page_id = @page.id
+        @layoutpage = @page.layoutpage?
+        if @page.destroy
+          set_root_page
+          @message = _t("Page deleted", :name => name)
+          flash[:notice] = @message
+          respond_to do |format|
+            format.js
+          end
+          # remove from clipboard
+          @clipboard = get_clipboard('pages')
+          @clipboard.delete_if { |item| item['id'] == @page_id.to_s }
+        end
+      end
+
+      def link
+        @url_prefix = ""
+        if configuration(:show_real_root)
+          @page_root = Page.root
+        else
+          set_root_page
+        end
+        @area_name = params[:area_name]
+        @content_id = params[:content_id]
+        @attachments = Attachment.all.collect { |f| [f.name, download_attachment_path(:id => f.id, :name => f.urlname)] }
+        if params[:link_urls_for] == "newsletter"
+          @url_prefix = current_server
+        end
+        if multi_language?
+          @url_prefix = "#{Language.current.code}/"
+        end
+      end
+
+      def fold
+        # @page is fetched via before filter
+        @page.fold!(current_alchemy_user.id, !@page.folded?(current_alchemy_user.id))
+        respond_to do |format|
+          format.js
+        end
+      end
+
+      # Leaves the page editing mode and unlocks the page for other users
+      def unlock
+        # fetching page via before filter
+        @page.unlock!
+        flash[:notice] = _t(:unlocked_page, :name => @page.name)
+        @pages_locked_by_user = Page.from_current_site.all_locked_by(current_alchemy_user)
+        respond_to do |format|
+          format.js
+          format.html {
+            redirect_to params[:redirect_to].blank? ? admin_pages_path : params[:redirect_to]
+          }
+        end
+      end
+
+      def visit
+        @page.unlock!
+        redirect_to show_page_path(urlname: @page.urlname, locale: multi_language? ? @page.language_code : nil)
+      end
+
+      # 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!
+        flash[:notice] = _t(:page_published, :name => @page.name)
+        redirect_back_or_to_default(admin_pages_path)
+      end
+
+      def copy_language_tree
+        language_root_to_copy_from.copy_children_to(copy_of_language_root)
+        flash[:notice] = _t(:language_pages_copied)
+        redirect_to admin_pages_path
+      end
+
+      def sort
+        @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
+        neworder = JSON.parse(params[:set])
+        tree = create_tree(neworder, @page_root)
+
+        Alchemy::Page.transaction do
+          tree.each do |key, node|
+            dbitem = Page.find(key)
+            dbitem.update_node!(node)
+          end
+        end
+
+        flash[:notice] = _t("Pages order saved")
+        do_redirect_to admin_pages_path
+      end
+
+      def switch_language
+        set_alchemy_language(params[:language_id])
+        do_redirect_to redirect_path_for_switch_language
+      end
+
+      def flush
+        Language.current.pages.flushables.each do |page|
+          page.publish!
+        end
+        respond_to do |format|
+          format.js
+        end
+      end
+
+      private
+
+      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
+
+      def language_root_to_copy_from
+        Page.language_root_for(params[:languages][:old_lang_id])
+      end
+
+      # 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
+      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
+      end
+
+      def load_page
+        @page = Page.find(params[:id])
+      end
+
+      def pages_from_raw_request
+        request.raw_post.split('&').map { |i| i = {i.split('=')[0].gsub(/[^0-9]/, '') => i.split('=')[1]} }
+      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
+          params[:redirect_to] || edit_admin_page_path(@page)
+        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