lc_alchemy_cms 3.2.0

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

@@ -0,0 +1,113 @@
+module Alchemy
+  module Admin
+    module ContentsHelper
+      include Alchemy::Admin::BaseHelper
+
+      # Renders the name of elements content.
+      #
+      # Displays a warning icon if content is missing its description.
+      #
+      # Displays a mandatory field indicator, if the content has validations.
+      #
+      def render_content_name(content)
+        if content.blank?
+          warning('Content is nil')
+          return
+        else
+          content_name = content.name_for_label
+        end
+        if content.description.blank?
+          warning("Content #{content.name} is missing its description")
+          title = _t(:content_description_missing)
+          content_name = %(<span class="warning icon" title="#{title}"></span>&nbsp;#{content_name}).html_safe
+        end
+        if content.has_validations?
+          "#{content_name}<span class='validation_indicator'>*</span>".html_safe
+        else
+          content_name
+        end
+      end
+
+      # Renders a link to show the new content overlay that lets you add additional contents.
+      #
+      # See +render_create_content_link+ helper for examples on how to define additional contents.
+      #
+      def render_new_content_link(element)
+        link_to_dialog(
+          "#{render_icon(:create)} #{_t('add new content')}".html_safe,
+          alchemy.new_admin_element_content_path(element),
+          {
+            size: '310x115',
+            title: _t('Select an content'),
+            overflow: true
+          },
+          {
+            id: "add_content_for_element_#{element.id}",
+            class: 'button with_icon new_content_link'
+          }
+        )
+      end
+
+      # Renders a link that dynamically adds an additional content into your element editor view.
+      #
+      # NOTE: You have to define additional contents in your elements.yml file first.
+      #
+      # ==== Example:
+      #
+      #   # config/alchemy/elements.yml
+      #   - name: downloads:
+      #     contents:
+      #     - name: file
+      #       type: EssenceFile
+      #     additional_contents:
+      #     - name: file
+      #       type: EssenceFile
+      #
+      # Then add this helper into the elements editor view partial:
+      #
+      #   <%= render_create_content_link(element, 'file') %>
+      #
+      # Optionally you can pass a label:
+      #
+      #   <%= render_create_content_link(element, 'file', label: 'Add a file') %>
+      #
+      def render_create_content_link(element, content_name, options = {}, options_for_content = {})
+        defaults = {
+          label: _t('Add %{name}', name: _t(content_name, scope: :content_names))
+        }
+        options = defaults.merge(options)
+        link_to(render_icon(:create) + options[:label], alchemy.admin_contents_path(
+            content: {
+              name: content_name,
+              element_id: element.id
+            },
+            options: options_for_content.to_json
+          ),
+          method: :post,
+          remote: true,
+          id: "add_content_for_element_#{element.id}",
+          class: 'button with_icon new_content_link'
+        )
+      end
+
+      # Renders a link for removing that content
+      def delete_content_link(content)
+        link_to_confirm_dialog(
+          render_icon('delete-small'),
+          _t('Do you really want to delete this content?'),
+          alchemy.admin_content_path(content),
+          class: 'icon_button small',
+          title: _t('Remove this content')
+        ) if content.settings[:deletable]
+      end
+
+      # Renders the label and a remove link for a content.
+      def label_and_remove_link(content)
+        content_tag :label do
+          [render_hint_for(content), render_content_name(content), delete_content_link(content)].compact.join('&nbsp;').html_safe
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+module Alchemy
+  module Admin
+    module ElementsHelper
+
+      include Alchemy::ElementsHelper
+      include Alchemy::ElementsBlockHelper
+      include Alchemy::Admin::BaseHelper
+      include Alchemy::Admin::ContentsHelper
+      include Alchemy::Admin::EssencesHelper
+
+      # Renders the element editor partial
+      def render_editor(element)
+        render_element(element, :editor)
+      end
+
+      # Renders a drag'n'drop picture gallery editor for all EssencePictures.
+      #
+      # It brings full functionality for adding images, deleting images and sorting them via drag'n'drop.
+      # Just place this helper inside your element editor view, pass the element as parameter and that's it.
+      #
+      # === Options:
+      #
+      #   :maximum_amount_of_images    [Integer]   # This option let you handle the amount of images your customer can add to this element.
+      #
+      def render_picture_gallery_editor(element, options={})
+        default_options = {
+          :maximum_amount_of_images => nil,
+          :grouped => true
+        }
+        options = default_options.merge(options)
+        render(
+          :partial => "alchemy/admin/elements/picture_gallery_editor",
+          :locals => {
+            :pictures => element.contents.gallery_pictures,
+            :element => element,
+            :options => options
+          }
+        )
+      end
+      alias_method :render_picture_editor, :render_picture_gallery_editor
+
+      # Returns an elements array for select helper.
+      #
+      # @param [Array] elements descriptions
+      # @return [Array]
+      #
+      def elements_for_select(elements)
+        return [] if elements.nil?
+        elements.collect do |e|
+          [
+            Element.display_name_for(e['name']),
+            e['name']
+          ]
+        end
+      end
+
+      # Returns all elements that can be placed on the current page.
+      # The elements will be grouped by cell.
+      #
+      # @param [Array] elements
+      #   collection of element objects
+      # @param [String] object_method
+      #   method that is called on the element objects used for the select option value
+      #
+      def grouped_elements_for_select(elements, object_method = 'name')
+        return [] if elements.blank?
+        cells_definition = @page.cell_definitions
+        return [] if cells_definition.blank?
+        options = {}
+        cells_definition.each do |cell|
+          cell_elements = elements_for_cell(elements, cell)
+          optgroup_label = Cell.translated_label_for(cell['name'])
+          options[optgroup_label] = cell_elements.map do |e|
+            element_array_for_options(e, object_method, cell)
+          end
+        end
+        options[_t(:main_content)] = elements_for_main_content(elements).map do |e|
+          element_array_for_options(e, object_method)
+        end
+        options.delete_if { |_cell, elements| elements.blank? } # Throw out empty cells
+      end
+
+      def element_array_for_options(e, object_method, cell = nil)
+        if e.class.name == 'Alchemy::Element'
+          [
+            e.display_name_with_preview_text,
+            e.send(object_method).to_s + (cell ? "##{cell['name']}" : "")
+          ]
+        else
+          [
+            Element.display_name_for(e['name']),
+            e[object_method] + (cell ? "##{cell['name']}" : "")
+          ]
+        end
+      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(["#{Content.table_name}.element_id != ?", element.id])
+          .where(Content.table_name => {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
+
+      private
+
+      def elements_for_main_content(elements)
+        page_definition = @page.definition['elements']
+        elements.select do |e|
+          page_definition.include?(e.class.name == 'Element' ? e.name : e['name'])
+        end
+      end
+
+      def elements_for_cell(elements, cell)
+        cell_elements = cell['elements']
+        elements.select do |e|
+          cell_elements.include?(e.class.name == 'Element' ? e.name : e['name'])
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module Alchemy
+  module Admin
+    module EssencesHelper
+
+      include Alchemy::EssencesHelper
+      include Alchemy::Admin::ContentsHelper
+
+      # Renders the Content editor partial from the given Content.
+      # For options see -> render_essence
+      def render_essence_editor(content, options = {}, html_options = {})
+        render_essence(content, :editor, {for_editor: options}, html_options)
+      end
+
+      # Renders the Content editor partial found in views/contents/ for the content with name inside the passed Element.
+      # For options see -> render_essence
+      #
+      # Content creation on the fly:
+      #
+      # If you update the elements.yml file after creating an element this helper displays a error message with an option to create the content.
+      #
+      def render_essence_editor_by_name(element, name, options = {}, html_options = {})
+        if element.blank?
+          return warning('Element is nil', _t(:no_element_given))
+        end
+        content = element.content_by_name(name)
+        if content.nil?
+          render_missing_content(element, name, options)
+        else
+          render_essence_editor(content, options, html_options)
+        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
+          Language.current.pages.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 'alchemy/admin/contents/missing', {element: element, name: name, options: options}
+      end
+
+      def essence_picture_thumbnail(content, options)
+        return if content.ingredient.blank?
+        crop = !(content.essence.crop_size.blank? && content.essence.crop_from.blank?) ||
+          (content_settings_value(content, :crop, options) == true || content_settings_value(content, :crop, options) == "true")
+        image_options = {
+          size: content.essence.thumbnail_size(content.essence.render_size.blank? ? content_settings_value(content, :size, options) : content.essence.render_size, crop),
+          crop_from: content.essence.crop_from.blank? ? nil : content.essence.crop_from,
+          crop_size: content.essence.crop_size.blank? ? nil : content.essence.crop_size,
+          crop: crop ? 'crop' : nil,
+          upsample: content_settings_value(content, :upsample, options)
+        }
+        image_tag(
+          alchemy.thumbnail_path({
+            id: content.ingredient.id,
+            name: content.ingredient.urlname,
+            sh: content.ingredient.security_token(image_options)
+          }.merge(image_options)),
+          alt: content.ingredient.name,
+          class: 'img_paddingtop',
+          title: _t(:image_name) + ": #{content.ingredient.name}"
+        )
+      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/form_helper.rb

@@ -0,0 +1,30 @@
+module Alchemy
+  module Admin
+    module FormHelper
+
+      # Use this form helper to render any form in Alchemy admin interface.
+      #
+      # This is simply a wrapper for `simple_form_for`
+      #
+      # == Defaults
+      #
+      # * It uses Alchemy::Forms::Builder as builder
+      # * It makes a remote request, if the request was XHR request.
+      # * It adds the alchemy class to form
+      #
+      def alchemy_form_for(object, *args, &block)
+        options = args.extract_options!
+        options.merge!({
+          builder: Alchemy::Forms::Builder,
+          remote: request.xhr?,
+          html: {
+            id: options.delete(:id),
+            class: ["alchemy", options.delete(:class)].compact.join(' ')
+          }
+        })
+        simple_form_for(object, *(args << options), &block)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,238 @@
+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
+      #
+      # To let your module be navigatable by the user you have to provide an Ability for it.
+      #
+      # === Example:
+      #
+      #   # module.yml
+      #   name: 'my_module'
+      #   navigation: {
+      #     controller: 'my/admin/posts'
+      #     action: 'index'
+      #   }
+      #
+      #   # ability.rb
+      #   can :index, :my_admin_posts
+      #
+      def navigate_module(navigation)
+        navigation.stringify_keys!
+        [
+          navigation['action'].to_sym,
+          navigation['controller'].to_s.gsub(/\A\//, '').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)
+        return if alchemy_module.nil?
+        route_from_engine_or_main_app(
+          alchemy_module['engine_name'],
+          url_options_for_navigation_entry(navigation)
+        )
+      end
+
+      # Alchemy modules for main navigation.
+      #
+      # Sorted by position attribute, if given.
+      #
+      def sorted_alchemy_modules
+        sorted = []
+        not_sorted = []
+        alchemy_modules.map do |m|
+          if m['position'].blank?
+            not_sorted << m
+          else
+            sorted << m
+          end
+        end
+        sorted.sort_by { |m| m['position'] } + not_sorted
+      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,
+          params: entry['params']
+        }.delete_if { |_k, v| v.nil? }
+      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(/\A\//, '') == 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