alchemy_cms 2.6.3 → 2.7.0

data/app/helpers/alchemy/admin/contents_helper.rb

@@ -1,7 +1,6 @@
 module Alchemy
   module Admin
     module ContentsHelper
-
       include Alchemy::Admin::BaseHelper
 
       # Returns a string for the id attribute of a html element for the given content
@@ -16,6 +15,11 @@ module Alchemy
         "#{c.essence_type.demodulize.underscore}_#{c.id}"
       end
 
+      # Returns a jquery selector string of form field ids from given contents
+      def contents_form_field_ids_string(contents)
+        contents.collect { |c| "##{c.form_field_id}" }.join(', ')
+      end
+
       # Renders the name of elements content or the default name defined in elements.yml
       def render_content_name(content)
         if content.blank?

data/app/helpers/alchemy/admin/elements_helper.rb

@@ -8,31 +8,6 @@ module Alchemy
       include Alchemy::Admin::ContentsHelper
       include Alchemy::Admin::EssencesHelper
 
-      # Returns an Array for essence_text_editor select options_for_select.
-      def elements_by_name_for_select(name, options={})
-        defaults = {
-          :grouped_by_page => true,
-          :from_page => :all
-        }
-        options = defaults.merge(options)
-        elements = all_elements_by_name(
-          name,
-          :from_page => options[:from_page]
-        )
-        if options[:grouped_by_page] && options[:from_page] == :all
-          elements_for_options = {}
-          pages = elements.collect(&:page).compact.uniq
-          pages.sort { |x, y| x.name <=> y.name }.each do |page|
-            page_elements = page.elements.select { |e| e.name == name }
-            elements_for_options[page.name] = page_elements.map { |pe| [pe.preview_text, pe.id.to_s] }
-          end
-        else
-          elements_for_options = elements.map { |e| [e.preview_text, e.id.to_s] }
-          elements_for_options = [''] + elements_for_options
-        end
-        return elements_for_options
-      end
-
       # Renders the element editor partial
       def render_editor(element)
         render_element(element, :editor)
@@ -73,7 +48,7 @@ module Alchemy
         return [] if elements.nil?
         options = elements.collect do |e|
           [
-            _t(e['name'], scope: 'element_names', default: e['name'].to_s.humanize),
+            Element.display_name_for(e['name']),
             e['name']
           ]
         end
@@ -114,32 +89,29 @@ module Alchemy
           ]
         else
           [
-            _t(e['name'], scope: :element_names, default: e['name'].to_s.humanize),
+            Element.display_name_for(e['name']),
             e[object_method] + (cell ? "##{cell['name']}" : "")
           ]
         end
       end
 
-      def update_elements_with_essence_selects(page, element)
-        elements = page.contents.essence_selects.collect(&:element).uniq.delete_if { |e| e == element }
-        if elements.any?
-          js = "var $ess_sel_el;"
-          elements.each do |element|
-            rtfs = element.contents.essence_richtexts
-            js += "\n$ess_sel_el = $('#element_#{element.id}');"
-            rtfs.each do |content|
-              js += "\ntinymce.get('contents_content_#{content.id}_body').remove();"
-            end
-            js += "\n$('div.element_content', $ess_sel_el).html('#{escape_javascript render_editor(element)}');"
-            js += "\nAlchemy.GUI.initElement($ess_sel_el);"
-            rtfs.each do |content|
-              js += "\nAlchemy.Tinymce.addEditor('#{content.form_field_id}');"
-            end
-          end
-          js
-        else
-          nil
-        end
+      # This helper loads all elements from page that have EssenceSelects in them.
+      #
+      # It returns a javascript function that replaces all editor partials of this elements.
+      #
+      # We need this while updating, creating or trashing an element,
+      # because another element on the same page could have a element selector in it.
+      #
+      # In cases like this one wants Ember.js databinding!
+      #
+      def update_essence_select_elements(page, element)
+        elements = page.elements.not_trashed.joins(:contents)
+          .where("alchemy_contents.element_id != #{element.id}")
+          .where("alchemy_contents.essence_type" => "Alchemy::EssenceSelect")
+        return if elements.blank?
+        elements.collect do |element|
+          render 'alchemy/admin/elements/refresh_editor', element: element
+        end.join.html_safe
       end
 
     end

data/app/helpers/alchemy/admin/essences_helper.rb

@@ -43,22 +43,6 @@ module Alchemy
         return_string
       end
 
-      # Renders the Content editor partial from the given Element by position (e.g. 1).
-      # For options see -> render_essence
-      def render_essence_editor_by_position(element, position, options = {})
-        ActiveSupport::Deprecation.warn 'Alchemy CMS: render_essence_editor_by_position is not supported anymore and will be removed.'
-        if element.blank?
-          warning('Element is nil')
-          return ""
-        end
-        content = element.contents.find_by_position(position)
-        if content.nil?
-          render_missing_content(element, position, options)
-        else
-          render_essence_editor(content, options)
-        end
-      end
-
       # Renders the Content editor partial found in views/contents/ for the content with name inside the passed Element.
       # For options see -> render_essence
       #
@@ -121,8 +105,31 @@ module Alchemy
         end
       end
 
+      # Returns all public pages from current language as an option tags string suitable or the Rails +select_tag+ helper.
+      #
+      # @param [Array]
+      #   A collection of pages so it only returns these pages and does not query the database.
+      # @param [String]
+      #   Pass a +Page#name+ or +Page#id+ as selected item to the +options_for_select+ helper.
+      # @param [String]
+      #   Used as prompt message in the select tag
+      # @param [Symbol]
+      #   Method that is called on the page object to get the value that is passed with the params of the form.
+      #
+      def pages_for_select(pages = nil, selected = nil, prompt = "Choose page", page_attribute = :id)
+        values = [[_t(prompt), ""]]
+        pages ||= begin
+          nested = true
+          Page.with_language(session[:language_id]).published.order(:lft)
+        end
+        values += pages_attributes_for_select(pages, page_attribute, nested)
+        options_for_select(values, selected.to_s)
+      end
+
+      # Renders the missing content partial
+      #
       def render_missing_content(element, name, options)
-        render :partial => 'alchemy/admin/contents/missing', :locals => {:element => element, :name => name, :options => options}
+        render 'alchemy/admin/contents/missing', {element: element, name: name, options: options}
       end
 
       def essence_picture_thumbnail(content, options)
@@ -145,6 +152,41 @@ module Alchemy
         )
       end
 
+    private
+
+      # Returns an Array with page attributes for select options
+      #
+      # @param [Array]
+      #   The pages
+      # @param [String || Symbol]
+      #   The attribute that is used as value
+      # @param [Boolean] (false)
+      #   Should the name be indented or not
+      #
+      def pages_attributes_for_select(pages, page_attribute, indent = false)
+        pages.map do |page|
+          [
+            page_name_attribute_for_select(page, indent),
+            page.send(page_attribute).to_s
+          ]
+        end
+      end
+
+      # Returns the page name for pages_for_select helper
+      #
+      # @param [Alchemy::Page]
+      #   The page
+      # @param [Boolean] (false)
+      #   Should the page be indented or not
+      #
+      def page_name_attribute_for_select(page, indent = false)
+        if indent
+          ("  " * (page.level - 1) + page.name).html_safe
+        else
+          page.name
+        end
+      end
+
     end
   end
 end

data/app/helpers/alchemy/admin/navigation_helper.rb

@@ -0,0 +1,204 @@
+module Alchemy
+  module Admin
+
+    # This module contains helper methods for rendering the admin navigation.
+    #
+    module NavigationHelper
+
+      # Renders one admin main navigation entry
+      #
+      # @param [Hash] alchemy_module
+      #   The Hash representing a Alchemy module
+      #
+      def alchemy_main_navigation_entry(alchemy_module)
+        render(
+          'alchemy/admin/partials/main_navigation_entry',
+          alchemy_module: alchemy_module.stringify_keys,
+          navigation: module_main_navigation(alchemy_module)
+        )
+      end
+
+      # Renders the subnavigation from current module
+      #
+      # We find the module from current controller and index action.
+      #
+      def admin_subnavigation
+        if current_alchemy_module.present?
+          render(
+            'alchemy/admin/partials/sub_navigation',
+            entries: current_sub_navigation
+          )
+        end
+      end
+
+      # Used for checking the main navi permissions
+      #
+      def navigate_module(navigation)
+        [
+          navigation['action'].to_sym,
+          navigation['controller'].gsub(/^\//, '').gsub(/\//, '_').to_sym
+        ]
+      end
+
+      # CSS classes for main navigation entry.
+      #
+      def main_navigation_css_classes(navigation)
+        [
+          'main_navi_entry',
+          admin_mainnavi_active?(navigation) ? 'active' : nil
+        ].compact.join(' ')
+      end
+
+      # Returns true if given navi entry is in params controller and action
+      #
+      # == Example
+      #   <%= entry_active?({controller: 'admin/users', action: 'index'}) %>
+      #
+      # @param [Hash]
+      #   A Alchemy module definition navigation entry
+      #
+      def entry_active?(entry)
+        is_entry_controller_active?(entry) && is_entry_action_active?(entry)
+      end
+
+      # Returns url for given Alchemy module.
+      #
+      # If the module is inside an engine it calls the +url_for+ helper on the engines routing proxy.
+      #
+      # If the module is inside the host rails app it calls the +url_for+ helper on the main_app routing proxy.
+      #
+      # @param [Hash]
+      #   A Alchemy module definition
+      #
+      def url_for_module(alchemy_module)
+        route_from_engine_or_main_app(
+          alchemy_module['engine_name'],
+          url_options_for_module(alchemy_module)
+        )
+      end
+
+      # Returns url for given Alchemy module sub navigation entry.
+      #
+      # If the module is inside an engine it calls the +url_for+ helper on the engines routing proxy.
+      #
+      # If the module is inside the host rails app it calls the +url_for+ helper on the main_app routing proxy.
+      #
+      # @param [Hash]
+      #   A Alchemy module sub navigation definition
+      #
+      def url_for_module_sub_navigation(navigation)
+        alchemy_module = module_definition_for(navigation)
+        route_from_engine_or_main_app(
+          alchemy_module['engine_name'],
+          url_options_for_navigation_entry(navigation)
+        )
+      end
+
+    private
+
+      # Calls +url_for+ helper on engine if present or on host app.
+      #
+      # @param [String]
+      #   A name of an engine
+      # @param [Hash]
+      #   url options hash passed to +url_for+ helper
+      #
+      def route_from_engine_or_main_app(engine_name, url_options)
+        if engine_name.present?
+          eval(engine_name).url_for(url_options)
+        else
+          main_app.url_for(url_options)
+        end
+      end
+
+      # Returns a url options hash for given Alchemy module.
+      #
+      # @param [Hash]
+      #   A Alchemy module definition
+      #
+      def url_options_for_module(alchemy_module)
+        url_options_for_navigation_entry(module_main_navigation(alchemy_module))
+      end
+
+      # Returns a url options hash for given navigation entry.
+      #
+      # @param [Hash]
+      #   A Alchemy module navigation entry
+      #
+      def url_options_for_navigation_entry(entry)
+        entry.stringify_keys!
+        {
+          controller: entry['controller'],
+          action: entry['action'],
+          only_path: true
+        }
+      end
+
+      # Retrieves the current Alchemy module from controller and index action.
+      #
+      def current_alchemy_module
+        module_definition_for(controller: params[:controller], action: 'index')
+      end
+
+      # Returns the sub navigation for current Alchemy module.
+      #
+      def current_sub_navigation
+        module_sub_navigation(module_main_navigation(current_alchemy_module))
+      end
+
+      # Returns navigation entries from given module.
+      #
+      def module_main_navigation(alchemy_module)
+        alchemy_module.fetch('navigation', {}).stringify_keys
+      end
+
+      # Returns sub navigation entries from given module.
+      #
+      def module_sub_navigation(alchemy_module)
+        alchemy_module.fetch('sub_navigation', []).map(&:stringify_keys)
+      end
+
+      # Returns nested navigation entries for given module.
+      #
+      def module_nested_navigation(alchemy_module)
+        alchemy_module.fetch('nested', []).map(&:stringify_keys)
+      end
+
+      # Returns true if the current controller and action is in a modules navigation definition.
+      #
+      def admin_mainnavi_active?(main_navigation)
+        main_navigation.stringify_keys!
+        # Has the given navigation entry a active sub navigation?
+        has_active_entry?(module_sub_navigation(main_navigation)) or
+          # Has the given navigation entry a active nested navigation?
+          has_active_entry?(module_nested_navigation(main_navigation)) or
+            # Is the navigation entry active?
+            entry_active?(main_navigation)
+      end
+
+      # Returns true if the given entry's controller is current controller
+      #
+      def is_entry_controller_active?(entry)
+        entry['controller'].gsub(/^\//, '') == params[:controller]
+      end
+
+      # Returns true if the given entry's action is current controllers action
+      #
+      # Also checks if given entry has a +nested_actions+ key, if so it checks if one of them is current controller's action
+      #
+      def is_entry_action_active?(entry)
+        entry['action'] == params[:action] || entry['nested_actions'].to_a.include?(params[:action])
+      end
+
+      # Returns true if an entry of given entries is active.
+      #
+      # @param [Array]
+      #   Alchemy module navigation entries.
+      #
+      def has_active_entry?(entries)
+        !entries.detect { |entry| entry_active?(entry) }.nil?
+      end
+
+    end
+  end
+end

data/app/helpers/alchemy/admin/pages_helper.rb

@@ -3,88 +3,29 @@ module Alchemy
     module PagesHelper
       include Alchemy::BaseHelper
 
-      def tinymce_javascript_tags
-        init = Alchemy::Tinymce.init
-        if init.is_a?(Hash)
-          init = HashWithIndifferentAccess.new(init)
-          init = init.keys.sort.collect(&:to_s).sort.collect do |key|
-            [key, init[key]]
-          end
-        end
-        init = init.collect { |key, value| "#{key} : #{value.to_json}" }.join(', ')
-        setup = "init.setup = #{Alchemy::Tinymce.setup};" if Alchemy::Tinymce.setup
-        tinymce_javascript_string = "
-        <script type='text/javascript'>
-          jQuery(function($) {
-            if (typeof(Alchemy) !== 'object') { Alchemy = {}; };
-            Alchemy.Tinymce = {
-              init : function(callback) {
-                var init = { #{init} };
-                var spinner = Alchemy.Spinner.small();
-                $('.tinymce_container').prepend(spinner.spin().el);
-                init.mode = 'specific_textareas';
-                init.editor_selector = 'default_tinymce';
-                init.plugins = '#{Alchemy::Tinymce.plugins.join(',')}';
-                init.language = '#{::I18n.locale.to_s.split('-')[0].downcase }';
-                init.init_instance_callback = function(inst) {
-                  $('#' + inst.editorId).prev('.spinner').remove();
-                }
-                if (callback)
-                  init.oninit = callback;
-                #{setup}
-                tinymce.init(init);
-              },
-              addEditor : function(dom_id) {
-                tinymce.execCommand('mceAddControl', true, dom_id);
-              }
-            };
-          });
-        </script>"
-        if Alchemy::Tinymce.custom_config_contents.any?
-          (tinymce_javascript_string + custom_tinymce_javascript_tags).html_safe
+      # Used for rendering the folder link in +Admin::Pages#index+ sitemap.
+      #
+      def sitemap_folder_link(page)
+        if page.folded?(current_user.id)
+          css_class = 'folded'
+          title = _t('Show childpages')
         else
-          tinymce_javascript_string.html_safe
+          css_class = 'collapsed'
+          title = _t('Hide childpages')
         end
+        link_to(
+          '',
+          alchemy.fold_admin_page_path(page),
+          remote: true,
+          method: :post,
+          class: "page_folder #{css_class} spinner",
+          title: title,
+          id: "fold_button_#{page.id}"
+        )
       end
 
-      def custom_tinymce_javascript_tags
-        custom_config_string = "
-          <script type='text/javascript'>
-            jQuery(function($) {
-              Alchemy.Tinymce.customInits = [];"
-        custom_config_contents = Alchemy::Tinymce.custom_config_contents
-        content_names = custom_config_contents.collect{ |c| c['name'] }
-        if content_names.uniq.length != content_names.length
-          raise TinymceError, "Duplicated content names with tinymce setting in elements.yml found. Please rename these contents."
-        end
-        custom_config_contents.each do |content|
-          next unless content['settings']['tinymce']
-          config = Alchemy::Tinymce.init.merge(content['settings']['tinymce'].symbolize_keys)
-          config = config.collect { |key, value| "#{key} : #{value.to_json}" }.join(', ')
-          custom_config_string += "
-              Alchemy.Tinymce.customInits.push(function(callback) {
-                var init = { #{config} };
-                init.mode = 'specific_textareas';
-                init.editor_selector = /custom_tinymce #{Regexp.escape(content['name'])}/;
-                init.plugins = '#{Alchemy::Tinymce.plugins.join(',')}';
-                init.language = '#{::I18n.locale.to_s.split('-')[0].downcase }';
-                init.init_instance_callback = function(inst) {
-                  var $this = $('#' + inst.editorId);
-                  var parent = $this.parents('.element_editor');
-                  parent.find('.spinner').remove();
-                  inst.onChange.add(function (ed, l) {
-                    Alchemy.setElementDirty(parent);
-                  });
-                }
-                tinymce.init(init);
-              });"
-        end
-        custom_config_string += "
-            });
-          </script>"
-        custom_config_string.html_safe
-      end
-
+      # Returns options tags for the screen sizes select in page edit view.
+      #
       def preview_sizes_for_select
         options_for_select([
           'auto',
@@ -101,7 +42,9 @@ module Alchemy
       #
       def combined_page_status(page)
         page.status.map do |state, value|
-          page.status_title(state)
+          next if state == :locked
+          val = content_tag(:span, '', class: page.send(state) ? "page_status #{state}" : "page_status not_#{state}")
+          val += page.status_title(state)
         end.delete_if(&:blank?).join("<br>").html_safe
       end