alchemy_cms 2.6.3 → 2.7.0

data/app/models/alchemy/page/elements.rb

@@ -44,54 +44,115 @@ module Alchemy
 
     end
 
-    # Finds selected elements from page.
+    # All available element definitions that can actually be placed on current page.
     #
-    # Returns only public elements by default.
-    # Pass true as second argument to get all elements.
+    # It extracts all definitions that are unique or limited and already on page.
     #
-    # === Options are:
+    # == Example of unique element:
     #
-    #     :only => Array of element names    # Returns only elements with given names
-    #     :except => Array of element names  # Returns all elements except the ones with given names
-    #     :count => Integer                  # Limit the count of returned elements
-    #     :offset => Integer                 # Starts with an offset while returning elements
-    #     :random => Boolean                 # Return elements randomly shuffled
-    #     :from_cell => Cell or String       # Return elements from given cell
+    #   - name: headline
+    #     unique: true
+    #     contents:
+    #     - name: headline
+    #       type: EssenceText
     #
-    def find_selected_elements(options = {}, show_non_public = false)
-      if options[:from_cell].class.name == 'Alchemy::Cell'
-        elements = options[:from_cell].elements
-      elsif !options[:from_cell].blank? && options[:from_cell].class.name == 'String'
-        cell = cells.find_by_name(options[:from_cell])
-        if cell
-          elements = cell.elements
-        else
-          warn("Cell with name `#{options[:from_cell]}` could not be found!")
-          # Returns an empty relation. Can be removed with the release of Rails 4
-          elements = self.elements.where('1 = 0')
-        end
+    # == Example of limited element:
+    #
+    #   - name: article
+    #     amount: 2
+    #     contents:
+    #     - name: text
+    #       type: EssenceRichtext
+    #
+    def available_element_definitions
+      @elements_for_layout ||= element_definitions
+      return [] if @elements_for_layout.blank?
+      @page_element_names = elements.not_trashed.pluck(:name)
+      delete_unique_element_definitions!
+      delete_outnumbered_element_definitions!
+      @elements_for_layout
+    end
+
+    # All names of elements that can actually be placed on current page.
+    #
+    def available_element_names
+      available_element_definitions.collect { |e| e['name'] }
+    end
+
+    # All element definitions defined for page's page layout
+    #
+    def element_definitions
+      element_definitions_by_name(element_definition_names)
+    end
+
+    # All names of elements that are defined in the page's page_layout definition.
+    #
+    # Define elements in +config/alchemy/page_layout.yml+ file
+    #
+    # == Example:
+    #
+    #   - name: contact
+    #     elements: [headline, contactform]
+    #
+    def element_definition_names
+      definition['elements'] || []
+    end
+
+    # Returns Element definitions with given name(s)
+    #
+    # @param [Array || String]
+    #   one or many Alchemy::Element names. Pass +'all'+ to get all Element definitions
+    # @return [Array]
+    #   An Array of element definitions
+    #
+    def element_definitions_by_name(names)
+      return [] if names.blank?
+      if names.to_s == "all"
+        Element.definitions
       else
-        elements = self.elements.not_in_cell
+        Element.definitions.select { |e| names.include? e['name'] }
       end
-      if !options[:only].blank?
+    end
+
+    # Finds elements of page.
+    #
+    # @param [Hash]
+    #   options hash
+    # @param [Boolean] (false)
+    #   Pass true, if you want to also have not published elements.
+    #
+    # @option options [Array] only
+    #   Returns only elements with given names
+    # @option options [Array] except
+    #   Returns all elements except the ones with given names
+    # @option options [Fixnum] count
+    #   Limit the count of returned elements
+    # @option options [Fixnum] offset
+    #   Starts with an offset while returning elements
+    # @option options [Boolean] random (false)
+    #   Return elements randomly shuffled
+    # @option options [Alchemy::Cell || String] from_cell
+    #   Return elements from given cell
+    #
+    # @return [ActiveRecord::Relation]
+    #
+    def find_elements(options = {}, show_non_public = false)
+      elements = elements_from_cell_or_self(options[:from_cell])
+      if options[:only].present?
         elements = elements.named(options[:only])
-      elsif !options[:except].blank?
+      elsif options[:except].present?
         elements = elements.excluded(options[:except])
       end
-      elements = elements.reverse_order if options[:reverse_sort] || options[:reverse]
+      if options[:reverse_sort] || options[:reverse]
+        elements = elements.reverse_order
+      end
       elements = elements.offset(options[:offset]).limit(options[:count])
-      elements = elements.order("RAND()") if options[:random]
-      show_non_public ? elements : elements.published
-    end
-
-    # What is this? A Kind of proxy method? Why not rendering the elements directly if you already have them????
-    def find_elements(options = {}, show_non_public = false)
-      if !options[:collection].blank? && options[:collection].is_a?(Array)
-        return options[:collection]
-      else
-        find_selected_elements(options, show_non_public)
+      if options[:random]
+        elements = elements.order("RAND()")
       end
+      show_non_public ? elements : elements.published
     end
+    alias_method :find_selected_elements, :find_elements
 
     # Returns all elements that should be feeded via rss.
     #
@@ -105,6 +166,13 @@ module Alchemy
       elements.named(definition['feed_elements'])
     end
 
+    # Returns an array of selectors for all contents with custom tinymce config.
+    def custom_tinymce_contents_selectors
+      Tinymce.page_custom_config_contents(self).collect do |c|
+        "#{c['element']}_#{c['name']}"
+      end
+    end
+
   private
 
     # Looks in the page_layout descripion, if there are elements to autogenerate.
@@ -143,5 +211,46 @@ module Alchemy
       elements.select { |e| !definition['elements'].include?(e.name) }.map(&:trash)
     end
 
+    # Deletes unique and already present definitions from @elements_for_layout.
+    #
+    def delete_unique_element_definitions!
+      @elements_for_layout.delete_if { |element|
+        element['unique'] && @page_element_names.include?(element['name'])
+      }
+    end
+
+    # Deletes limited and outnumbered definitions from @elements_for_layout.
+    #
+    def delete_outnumbered_element_definitions!
+      @elements_for_layout.delete_if { |element|
+        element['amount'] && @page_element_names.select { |i| i == element['name'] }.count >= element['amount'].to_i
+      }
+    end
+
+    # Returns elements either from given cell or self
+    #
+    def elements_from_cell_or_self(cell)
+      case cell.class.name
+      when 'Alchemy::Cell'
+        cell.elements
+      when 'String'
+        cell_elements_by_name(cell)
+      else
+        self.elements.not_in_cell
+      end
+    end
+
+    # Returns all elements from given cell name
+    #
+    def cell_elements_by_name(name)
+      if cell = cells.find_by_name(name)
+        cell.elements
+      else
+        Alchemy::Logger.warn("Cell with name `#{name}` could not be found!", caller.first)
+        # Returns an empty relation. Can be removed with the release of Rails 4
+        self.elements.where('1 = 0')
+      end
+    end
+
   end
 end

data/app/models/alchemy/page/natures.rb

@@ -0,0 +1,90 @@
+module Alchemy
+  module Page::Natures
+
+    extend ActiveSupport::Concern
+
+    def taggable?
+      definition['taggable'] == true
+    end
+
+    def rootpage?
+      !self.new_record? && self.parent_id.blank?
+    end
+
+    def systempage?
+      return true if Page.root.nil?
+      rootpage? || (self.parent_id == Page.root.id && !self.language_root?)
+    end
+
+    def folded?(user_id)
+      folded_page = folded_pages.find_by_user_id(user_id)
+      folded_page.try(:folded) || false
+    end
+
+    def contains_feed?
+      definition["feed"]
+    end
+
+    # Returns true or false if the pages layout_description for config/alchemy/page_layouts.yml contains redirects_to_external: true
+    def redirects_to_external?
+      definition["redirects_to_external"]
+    end
+
+    def has_controller?
+      !PageLayout.get(self.page_layout).nil? && !PageLayout.get(self.page_layout)["controller"].blank?
+    end
+
+    def controller_and_action
+      if self.has_controller?
+        {
+          controller: self.layout_description["controller"].gsub(/(^\b)/, "/#{$1}"),
+          action: self.layout_description["action"]
+        }
+      end
+    end
+
+    # Returns a Hash describing the status of the Page.
+    #
+    def status
+      {
+        public: public?,
+        visible: visible?,
+        locked: locked?,
+        restricted: restricted?
+      }
+    end
+
+    # Returns the translated status for given status type.
+    #
+    # @param [Symbol] status_type
+    #
+    def status_title(status_type)
+      I18n.t(self.status[status_type].to_s, scope: "page_states.#{status_type}")
+    end
+
+    # Returns the self#page_layout description from config/alchemy/page_layouts.yml file.
+    def layout_description
+      return {} if self.systempage?
+      description = PageLayout.get(self.page_layout)
+      if description.nil?
+        raise PageLayoutDefinitionError, "Description could not be found for page layout named #{self.page_layout}. Please check page_layouts.yml file."
+      else
+        description
+      end
+    end
+    alias_method :definition, :layout_description
+
+    # Returns translated name of the pages page_layout value.
+    # Page layout names are defined inside the config/alchemy/page_layouts.yml file.
+    # Translate the name in your config/locales language yml file.
+    def layout_display_name
+      I18n.t(self.page_layout, :scope => :page_layout_names)
+    end
+
+    # Overwrites the cache_key method.
+    def cache_key(request = nil)
+      "alchemy/pages/#{id}"
+    end
+
+  end
+end

data/app/models/alchemy/page/scopes.rb

@@ -0,0 +1,93 @@
+module Alchemy
+
+  # ActiveRecord scopes for Alchemy::Page
+  #
+  module Page::Scopes
+    extend ActiveSupport::Concern
+
+    included do
+      # All language root pages
+      #
+      scope :language_roots, where(language_root: true)
+
+      # All layout pages
+      #
+      scope :layoutpages, where(layoutpage: true)
+
+      # All locked pages
+      #
+      scope :all_locked, where(locked: true)
+
+      # All pages locked by given +Alchemy::User+
+      #
+      scope :all_locked_by, ->(user) {
+        all_locked.where(locked_by: user.id)
+      }
+
+      # All not locked pages
+      #
+      scope :not_locked, where(locked: false)
+
+      # All visible pages
+      #
+      scope :visible, where(visible: true)
+
+      # All public pages
+      #
+      scope :published, where(public: true)
+
+      # All not restricted pages
+      #
+      scope :not_restricted, where(restricted: false)
+
+      # All restricted pages
+      #
+      scope :restricted, where(restricted: true)
+
+      # All pages that are a published language root
+      #
+      scope :public_language_roots, -> {
+        published.language_roots.where(
+          language_code: Language.all_codes_for_published
+        )
+      }
+
+      # Last 5 pages that where recently edited by given +Alchemy::User+
+      #
+      scope :all_last_edited_from, ->(user) {
+        where(updater_id: user.id).order('updated_at DESC').limit(5)
+      }
+
+      # Returns all pages that have the given +language_id+
+      #
+      scope :with_language, ->(language_id) {
+        where(language_id: language_id)
+      }
+
+      # Returns all content pages.
+      #
+      scope :contentpages, where(layoutpage: [false, nil]).where(Page.arel_table[:parent_id].not_eq(nil))
+
+      # Returns all public contentpages that are not locked.
+      #
+      # Used for flushing all pages caches at once.
+      #
+      scope :flushables, not_locked.published.contentpages
+
+      # All searchable pages
+      #
+      scope :searchables, not_restricted.published.contentpages
+
+      # All pages from +Alchemy::Site.current+
+      #
+      scope :from_current_site, -> {
+        where(alchemy_languages: {site_id: Site.current || Site.default}).joins(:language)
+      }
+
+      # All pages for xml sitemap
+      #
+      scope :sitemap, published.contentpages.where(sitemap: true)
+    end
+
+  end
+end

data/app/models/alchemy/page/users.rb

@@ -0,0 +1,25 @@
+module Alchemy
+  module Page::Users
+
+    extend ActiveSupport::Concern
+
+    # Returns the name of the creator of this page.
+    def creator_name
+      return I18n.t('unknown') if creator.nil?
+      creator.name
+    end
+
+    # Returns the name of the last updater of this page.
+    def updater_name
+      return I18n.t('unknown') if updater.nil?
+      updater.name
+    end
+
+    # Returns the name of the user currently editing this page.
+    def locker_name
+      return I18n.t('unknown') if locker.nil?
+      locker.name
+    end
+
+  end
+end

data/app/models/alchemy/picture.rb

@@ -1,3 +1,7 @@
+require 'acts-as-taggable-on'
+require 'dragonfly'
+require 'userstamp'
+
 module Alchemy
   class Picture < ActiveRecord::Base
     include NameConversions
@@ -39,6 +43,7 @@ module Alchemy
 
     scope :recent, where("#{self.table_name}.created_at > ?", Time.now-24.hours).order(:created_at)
     scope :deletable, where("alchemy_pictures.id NOT IN (SELECT picture_id FROM alchemy_essence_pictures)")
+    scope :without_tag, where("cached_tag_list IS NULL OR cached_tag_list = ''")
 
     # Class methods
 
@@ -54,6 +59,16 @@ module Alchemy
         Picture.where(:upload_hash => last_picture.upload_hash)
       end
 
+      def filtered_by(filter = '')
+        case filter
+          when 'recent'      then recent
+          when 'last_upload' then last_upload
+          when 'without_tag' then without_tag
+        else
+          scoped
+        end
+      end
+
     end
 
     # Instance methods