lc_alchemy_cms 3.2.0

data/app/models/alchemy/essence_select.rb

@@ -0,0 +1,18 @@
+# == Schema Information
+#
+# Table name: alchemy_essence_selects
+#
+#  id         :integer          not null, primary key
+#  value      :string(255)
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#  creator_id :integer
+#  updater_id :integer
+#
+
+# Provides a select box that stores string values.
+module Alchemy
+  class EssenceSelect < ActiveRecord::Base
+    acts_as_essence ingredient_column: 'value'
+  end
+end

data/app/models/alchemy/essence_text.rb

@@ -0,0 +1,22 @@
+# == Schema Information
+#
+# Table name: alchemy_essence_texts
+#
+#  id              :integer          not null, primary key
+#  body            :text
+#  link            :string(255)
+#  link_title      :string(255)
+#  link_class_name :string(255)
+#  public          :boolean          default(FALSE)
+#  link_target     :string(255)
+#  creator_id      :integer
+#  updater_id      :integer
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#
+
+module Alchemy
+  class EssenceText < ActiveRecord::Base
+    acts_as_essence
+  end
+end

data/app/models/alchemy/folded_page.rb

@@ -0,0 +1,16 @@
+# == Schema Information
+#
+# Table name: alchemy_folded_pages
+#
+#  id      :integer          not null, primary key
+#  page_id :integer
+#  user_id :integer
+#  folded  :boolean          default(FALSE)
+#
+
+module Alchemy
+  class FoldedPage < ActiveRecord::Base
+    belongs_to :page
+    belongs_to :user, class_name: Alchemy.user_class_name
+  end
+end

data/app/models/alchemy/language.rb

@@ -0,0 +1,144 @@
+# == Schema Information
+#
+# Table name: alchemy_languages
+#
+#  id             :integer          not null, primary key
+#  name           :string(255)
+#  language_code  :string(255)
+#  frontpage_name :string(255)
+#  page_layout    :string(255)      default("intro")
+#  public         :boolean          default(FALSE)
+#  created_at     :datetime         not null
+#  updated_at     :datetime         not null
+#  creator_id     :integer
+#  updater_id     :integer
+#  default        :boolean          default(FALSE)
+#  country_code   :string(255)      default(""), not null
+#  site_id        :integer
+#
+
+module Alchemy
+  class Language < ActiveRecord::Base
+    belongs_to :site
+    has_many :pages
+
+    validates_presence_of :name
+    validates_presence_of :language_code
+    validates_presence_of :page_layout
+    validates_presence_of :frontpage_name
+    validates_uniqueness_of :language_code, scope: [:site_id, :country_code]
+    validate :presence_of_default_language
+    validate :publicity_of_default_language
+
+    validates_format_of :language_code, with: /\A[a-z]{2}\z/,
+      if: -> { language_code.present? }
+
+    validates_format_of :country_code, with: /\A[a-z]{2}\z/,
+      if: -> { country_code.present? }
+
+    before_save :remove_old_default,
+      if: -> { default_changed? && self != Language.default }
+
+    after_update :set_pages_language,
+      if: -> { language_code_changed? || country_code_changed? }
+
+    after_update :unpublish_pages,
+      if: -> { changes[:public] == [true, false] }
+
+    before_destroy :check_for_default
+    after_destroy :delete_language_root_page
+
+    default_scope { on_site(Site.current) }
+
+    scope :published,      -> { where(public: true) }
+    scope :with_root_page, -> { joins(:pages).where(Page.table_name => {language_root: true}) }
+    scope :on_site,        ->(s) { s.present? ? where(site_id: s) : all }
+
+    class << self
+
+      # Store the current language in the current thread.
+      def current=(v)
+        RequestStore.store[:alchemy_current_language] = v
+      end
+
+      # Current language from current thread or default.
+      def current
+        RequestStore.store[:alchemy_current_language] || default
+      end
+
+      # The root page of the current language.
+      def current_root_page
+        current.pages.language_roots.first
+      end
+
+      # Default language
+      def default
+        find_by(default: true)
+      end
+      alias_method :get_default, :default
+    end
+
+    def label(attrib)
+      if attrib.to_sym == :code
+        self.code
+      else
+        I18n.t(self.code, default: self.name)
+      end
+    end
+
+    include Alchemy::Language::Code
+
+    # Root page
+    def root_page
+      @root_page ||= pages.language_roots.first
+    end
+
+    # Layout root page
+    def layout_root_page
+      @layout_root_page ||= Page.layout_root_for(id)
+    end
+
+    private
+
+    def publicity_of_default_language
+      if self.default? && !self.public?
+        errors.add(:public, I18n.t("Default language has to be public"))
+        return false
+      else
+        return true
+      end
+    end
+
+    def presence_of_default_language
+      if Language.default == self && self.default_changed?
+        errors.add(:default, I18n.t("We need at least one default."))
+        return false
+      else
+        return true
+      end
+    end
+
+    def remove_old_default
+      lang = Language.on_site(site).default
+      return true if lang.nil?
+      lang.default = false
+      lang.save(validate: false)
+    end
+
+    def set_pages_language
+      pages.update_all language_code: self.code
+    end
+
+    def check_for_default
+      raise DefaultLanguageNotDeletable if default?
+    end
+
+    def delete_language_root_page
+      root_page.try(:destroy) && layout_root_page.try(:destroy)
+    end
+
+    def unpublish_pages
+      self.pages.update_all(public: false)
+    end
+  end
+end

data/app/models/alchemy/language/code.rb

@@ -0,0 +1,22 @@
+module Alchemy::Language::Code
+  extend ActiveSupport::Concern
+
+  def code
+    [language_code, country_code].select(&:present?).join('-')
+  end
+
+  def code=(code)
+    self.language_code = code
+  end
+
+  module ClassMethods
+
+    def find_by_code(code)
+      codes = code.split('-')
+      codes << '' if codes.length == 1
+      find_by_language_code_and_country_code *codes
+    end
+
+  end
+
+end

data/app/models/alchemy/legacy_page_url.rb

@@ -0,0 +1,20 @@
+# == Schema Information
+#
+# Table name: alchemy_legacy_page_urls
+#
+#  id         :integer          not null, primary key
+#  urlname    :string(255)      not null
+#  page_id    :integer          not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+class Alchemy::LegacyPageUrl < ActiveRecord::Base
+  belongs_to :page, class_name: 'Alchemy::Page'
+
+  validates :page_id,
+    presence: true
+  validates :urlname,
+    presence: true,
+    format: {with: /\A[:\.\w\-+_\/\?&%;=]*\z/}
+end

data/app/models/alchemy/message.rb

@@ -0,0 +1,40 @@
+# This is a tableless model used for contact forms.
+#
+# You can specify the fields for your contact form in
+# +config/alchemy/config.yml+ file as +:mailer+ +fields+.
+#
+# === Example Configuration:
+#
+#   mailer:
+#     form_layout_name: contact
+#     fields: [subject, name, email, message, info]
+#     validate_fields: [name, email]
+#
+module Alchemy
+  class Message
+    include ActiveModel::Model
+
+    def self.config
+      Alchemy::Config.get(:mailer)
+    end
+
+    attr_accessor :contact_form_id, :ip
+
+    config['fields'].each do |field|
+      attr_accessor field.to_sym
+    end
+
+    config['validate_fields'].each do |field|
+      validates_presence_of field
+
+      case field.to_sym
+      when /email/
+        validates_format_of field,
+          with: Alchemy::Config.get('format_matchers')['email'],
+          if: -> { send(field).present? }
+      when :email_confirmation
+        validates_confirmation_of :email
+      end
+    end
+  end
+end

data/app/models/alchemy/page.rb

@@ -0,0 +1,409 @@
+# == Schema Information
+#
+# Table name: alchemy_pages
+#
+#  id               :integer          not null, primary key
+#  name             :string(255)
+#  urlname          :string(255)
+#  title            :string(255)
+#  language_code    :string(255)
+#  language_root    :boolean
+#  page_layout      :string(255)
+#  meta_keywords    :text
+#  meta_description :text
+#  lft              :integer
+#  rgt              :integer
+#  parent_id        :integer
+#  depth            :integer
+#  visible          :boolean          default(FALSE)
+#  public           :boolean          default(FALSE)
+#  locked           :boolean          default(FALSE)
+#  locked_by        :integer
+#  restricted       :boolean          default(FALSE)
+#  robot_index      :boolean          default(TRUE)
+#  robot_follow     :boolean          default(TRUE)
+#  sitemap          :boolean          default(TRUE)
+#  layoutpage       :boolean          default(FALSE)
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  creator_id       :integer
+#  updater_id       :integer
+#  language_id      :integer
+#  cached_tag_list  :text
+#  published_at     :datetime
+#
+
+module Alchemy
+  class Page < ActiveRecord::Base
+    include Alchemy::Hints
+    include Alchemy::Logger
+    include Alchemy::Touching
+
+    DEFAULT_ATTRIBUTES_FOR_COPY = {
+      :do_not_autogenerate => true,
+      :do_not_sweep => true,
+      :visible => false,
+      :public => false,
+      :locked => false,
+      :locked_by => nil
+    }
+    SKIPPED_ATTRIBUTES_ON_COPY = %w(id updated_at created_at creator_id updater_id lft rgt depth urlname cached_tag_list)
+    PERMITTED_ATTRIBUTES = [
+      :meta_description,
+      :meta_keywords,
+      :name,
+      :page_layout,
+      :public,
+      :restricted,
+      :robot_index,
+      :robot_follow,
+      :sitemap,
+      :tag_list,
+      :title,
+      :urlname,
+      :visible,
+      :layoutpage
+    ]
+
+    acts_as_taggable
+    acts_as_nested_set(:dependent => :destroy)
+
+    stampable stamper_class_name: Alchemy.user_class_name
+
+    has_many :folded_pages
+    has_many :legacy_urls, :class_name => 'Alchemy::LegacyPageUrl'
+    belongs_to :language
+
+    validates_presence_of :language, :on => :create, :unless => :root
+    validates_presence_of :page_layout, :unless => :systempage?
+    validates_format_of :page_layout, with: /\A[a-z0-9_-]+\z/, unless: -> { systempage? || page_layout.blank? }
+    validates_presence_of :parent_id, :if => proc { Page.count > 1 }
+
+    attr_accessor :do_not_sweep
+    attr_accessor :do_not_validate_language
+
+    before_save :set_language_code, if: -> { language.present? }, unless: :systempage?
+    before_save :set_restrictions_to_child_pages, if: :restricted_changed?, unless: :systempage?
+    before_save :inherit_restricted_status, if: -> { parent && parent.restricted? }, unless: :systempage?
+    before_save :update_published_at, if: -> { public && read_attribute(:published_at).nil? }, unless: :systempage?
+    before_create :set_language_from_parent_or_default, if: -> { language_id.blank? }, unless: :systempage?
+    after_update :create_legacy_url, if: :urlname_changed?, unless: :redirects_to_external?
+
+    # Concerns
+    include Alchemy::Page::PageScopes
+    include Alchemy::Page::PageNatures
+    include Alchemy::Page::PageNaming
+    include Alchemy::Page::PageUsers
+    include Alchemy::Page::PageCells
+    include Alchemy::Page::PageElements
+
+    # Class methods
+    #
+    class << self
+
+      alias_method :rootpage, :root
+
+      # Used to store the current page previewed in the edit page template.
+      #
+      def current_preview=(page)
+        RequestStore.store[:alchemy_current_preview] = page
+      end
+
+      # Returns the current page previewed in the edit page template.
+      #
+      def current_preview
+        RequestStore.store[:alchemy_current_preview]
+      end
+
+      # @return the language root page for given language id.
+      # @param language_id [Fixnum]
+      #
+      def language_root_for(language_id)
+        self.language_roots.find_by_language_id(language_id)
+      end
+
+      # Creates a copy of given source.
+      #
+      # Also copies all elements included in source.
+      #
+      # === Note:
+      #
+      # It prevents the element auto generator from running.
+      #
+      # @param source [Alchemy::Page]
+      #   The source page the copy is taken from
+      # @param differences [Hash]
+      #   A optional hash with attributes that take precedence over the source attributes
+      #
+      # @return [Alchemy::Page]
+      #
+      def copy(source, differences = {})
+        page = Alchemy::Page.new(attributes_from_source_for_copy(source, differences))
+        page.tag_list = source.tag_list
+        if page.save!
+          copy_cells(source, page)
+          copy_elements(source, page)
+          page
+        end
+      end
+
+      def layout_root_for(language_id)
+        where({:parent_id => Page.root.id, :layoutpage => true, :language_id => language_id}).limit(1).first
+      end
+
+      def find_or_create_layout_root_for(language_id)
+        layoutroot = layout_root_for(language_id)
+        return layoutroot if layoutroot
+        language = Language.find(language_id)
+        Page.create!(
+          name: "Layoutroot for #{language.name}",
+          layoutpage: true,
+          language: language,
+          do_not_autogenerate: true,
+          parent_id: Page.root.id
+        )
+      end
+
+      def copy_and_paste(source, new_parent, new_name)
+        page = copy(source, {
+          parent_id: new_parent.id,
+          language: new_parent.language,
+          name: new_name,
+          title: new_name
+        })
+        if source.children.any?
+          source.copy_children_to(page)
+        end
+        return page
+      end
+
+      def all_from_clipboard(clipboard)
+        return [] if clipboard.blank?
+        where(id: clipboard.collect { |p| p['id'] })
+      end
+
+      def all_from_clipboard_for_select(clipboard, language_id, layoutpage = false)
+        return [] if clipboard.blank?
+        clipboard_pages = self.all_from_clipboard(clipboard)
+        allowed_page_layouts = Alchemy::PageLayout.selectable_layouts(language_id, layoutpage)
+        allowed_page_layout_names = allowed_page_layouts.collect { |p| p['name'] }
+        clipboard_pages.select { |cp| allowed_page_layout_names.include?(cp.page_layout) }
+      end
+
+      def link_target_options
+        options = [[I18n.t(:default, scope: 'link_target_options'), '']]
+        link_target_options = Config.get(:link_target_options)
+        link_target_options.each do |option|
+          options << [I18n.t(option, scope: 'link_target_options', default: option.to_s.humanize), option]
+        end
+        options
+      end
+
+      # Returns an array of all pages in the same branch from current.
+      # I.e. used to find the active page in navigation.
+      def ancestors_for(current)
+        return [] if current.nil?
+        current.self_and_ancestors.contentpages
+      end
+
+      private
+
+      # Aggregates the attributes from given source for copy of page.
+      #
+      # @param [Alchemy::Page]
+      #   The source page
+      # @param [Hash]
+      #   A optional hash with attributes that take precedence over the source attributes
+      #
+      def attributes_from_source_for_copy(source, differences = {})
+        source.attributes.stringify_keys!
+        differences.stringify_keys!
+        attributes = source.attributes.merge(differences)
+        attributes.merge!(DEFAULT_ATTRIBUTES_FOR_COPY)
+        attributes.merge!('name' => new_name_for_copy(differences['name'], source.name))
+        attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY)
+      end
+
+      # Returns a new name for copy of page.
+      #
+      # If the differences hash includes a new name this is taken.
+      # Otherwise +source.name+
+      #
+      # @param [String]
+      #   The differences hash that contains a new name
+      # @param [String]
+      #   The name of the source
+      #
+      def new_name_for_copy(custom_name, source_name)
+        return custom_name if custom_name.present?
+        "#{source_name} (#{I18n.t('Copy')})"
+      end
+
+    end
+
+    # Instance methods
+    #
+
+    # The page's view partial is dependent from its page layout
+    #
+    # == Define page layouts
+    #
+    # Page layouts are defined in the +config/alchemy/page_layouts.yml+ file
+    #
+    #     - name: contact
+    #       elements: [contactform]
+    #       ...
+    #
+    # == Override the view
+    #
+    # Page layout partials live in +app/views/alchemy/page_layouts+
+    #
+    def to_partial_path
+      "alchemy/page_layouts/#{layout_partial_name}"
+    end
+
+    # Returns the previous page on the same level or nil.
+    #
+    # For options @see #next_or_previous
+    #
+    def previous(options = {})
+      next_or_previous('<', options)
+    end
+    alias_method :previous_page, :previous
+
+    # Returns the next page on the same level or nil.
+    #
+    # For options @see #next_or_previous
+    #
+    def next(options = {})
+      next_or_previous('>', options)
+    end
+    alias_method :next_page, :next
+
+    # Locks the page to given user without updating the timestamps
+    #
+    def lock_to!(user)
+      self.update_columns(locked: true, locked_by: user.id)
+    end
+
+    # Unlocks the page without updating the timestamps
+    #
+    def unlock!
+      if self.update_columns(locked: false, locked_by: nil)
+        Page.current_preview = nil
+      end
+    end
+
+    def fold!(user_id, status)
+      folded_page = folded_pages.find_or_create_by(user_id: user_id)
+      folded_page.folded = status
+      folded_page.save
+    end
+
+    def set_restrictions_to_child_pages
+      descendants.each do |child|
+        child.update_attributes(:restricted => self.restricted?)
+      end
+    end
+
+    def inherit_restricted_status
+      self.restricted = parent.restricted?
+    end
+
+    # Returns the first published child
+    def first_public_child
+      children.published.first
+    end
+
+    # Gets the language_root page for page
+    def get_language_root
+      self_and_ancestors.find_by(language_root: true)
+    end
+
+    def copy_children_to(new_parent)
+      self.children.each do |child|
+        next if child == new_parent
+        new_child = Page.copy(child, {
+          :language_id => new_parent.language_id,
+          :language_code => new_parent.language_code
+        })
+        new_child.move_to_child_of(new_parent)
+        child.copy_children_to(new_child) unless child.children.blank?
+      end
+    end
+
+    # Publishes the page.
+    #
+    # Sets +public+ to true and the +published_at+ value to current time.
+    #
+    # The +published_at+ attribute is used as +cache_key+.
+    #
+    def publish!
+      update_columns(published_at: Time.now, public: true)
+    end
+
+    # Updates an Alchemy::Page based on a new ordering to be applied to it
+    #
+    # Note: Page's urls should not be updated (and a legacy URL created) if nesting is OFF
+    # or if a page is external or if the URL is the same
+    #
+    # @param [TreeNode]
+    #   A tree node with new lft, rgt, depth, url, parent_id and restricted indexes to be updated
+    #
+    def update_node!(node)
+      hash = {lft: node.left, rgt: node.right, parent_id: node.parent, depth: node.depth, restricted: node.restricted}
+
+      if Config.get(:url_nesting) && !self.redirects_to_external? && self.urlname != node.url
+        LegacyPageUrl.create(page_id: self.id, urlname: self.urlname)
+        hash.merge!(urlname: node.url)
+      end
+
+      update_columns(hash)
+    end
+
+    private
+
+    # Returns the next or previous page on the same level or nil.
+    #
+    # @param [String]
+    #   Pass '>' for next and '<' for previous page.
+    #
+    # @option options [Boolean] :restricted (nil)
+    #   only restricted pages (true), skip restricted pages (false)
+    # @option options [Boolean] :public (true)
+    #   only public pages (true), skip public pages (false)
+    #
+    def next_or_previous(dir = '>', options = {})
+      options = {
+        restricted: false,
+        public: true
+      }.update(options)
+
+      self_and_siblings
+        .where(["#{self.class.table_name}.lft #{dir} ?", lft])
+        .where(public: options[:public])
+        .where(restricted: options[:restricted])
+        .reorder(dir == '>' ? 'lft' : 'lft DESC')
+        .limit(1).first
+    end
+
+    def set_language_from_parent_or_default
+      self.language = self.parent.language || Language.default
+      set_language_code
+    end
+
+    def set_language_code
+      self.language_code = self.language.code
+    end
+
+    # Stores the old urlname in a LegacyPageUrl
+    def create_legacy_url
+      legacy_urls.find_or_create_by(urlname: urlname_was)
+    end
+
+    def update_published_at
+      self.published_at = Time.now
+    end
+
+  end
+end