lc_alchemy_cms 3.2.0

data/app/helpers/alchemy/url_helper.rb

@@ -0,0 +1,76 @@
+# Alchemy url helpers
+#
+# This helper is included within alchemy/pages_helper
+#
+module Alchemy
+  module UrlHelper
+
+    # Returns the path for rendering an alchemy page
+    def show_alchemy_page_path(page, optional_params={})
+      alchemy.show_page_path(show_page_path_params(page, optional_params))
+    end
+
+    # Returns the url for rendering an alchemy page
+    def show_alchemy_page_url(page, optional_params={})
+      alchemy.show_page_url(show_page_path_params(page, optional_params))
+    end
+
+    # This helper returns a path to picture for use inside a image_tag helper.
+    #
+    # Any additional options are passed to the url_helper, so you can add arguments to your url.
+    #
+    # Example:
+    #
+    #   <%= image_tag show_alchemy_picture_path(picture, :size => '320x200', :format => :png) %>
+    #
+    def show_alchemy_picture_path(picture, optional_params={})
+      alchemy.show_picture_path(show_picture_path_params(picture, optional_params))
+    end
+
+    # This helper returns an url to picture for use inside a image_tag helper.
+    #
+    # Any additional options are passed to the url_helper, so you can add arguments to your url.
+    #
+    # Example:
+    #
+    #   <%= image_tag show_alchemy_picture_url(picture, :size => '320x200', :format => :png) %>
+    #
+    def show_alchemy_picture_url(picture, optional_params={})
+      alchemy.show_picture_url(show_picture_path_params(picture, optional_params))
+    end
+
+    # Returns the correct params hash for passing to show_picture_path
+    def show_picture_path_params(picture, optional_params={})
+      url_params = {
+        :id => picture.id,
+        :name => picture.urlname,
+        :format => configuration(:image_output_format),
+        :sh => picture.security_token(optional_params)
+      }
+      url_params.update(optional_params.update({:crop => optional_params[:crop] ? 'crop' : nil}))
+    end
+
+    # Returns the correct params-hash for passing to show_page_path
+    def show_page_path_params(page, optional_params={})
+      raise ArgumentError, 'Page is nil' if page.nil?
+      url_params = {urlname: page.urlname}.update(optional_params)
+      multi_language? ? url_params.update(locale: page.language_code) : url_params
+    end
+
+    # Returns the path for downloading an alchemy attachment
+    def download_alchemy_attachment_path(attachment)
+      alchemy.download_attachment_path(attachment, attachment.urlname)
+    end
+
+    # Returns the url for downloading an alchemy attachment
+    def download_alchemy_attachment_url(attachment)
+      alchemy.download_attachment_url(attachment, attachment.urlname)
+    end
+
+    # Returns the full url containing host, page and anchor for the given element
+    def full_url_for_element(element)
+      "#{current_server}/#{element.page.urlname}##{element_dom_id(element)}"
+    end
+
+  end
+end

data/app/mailers/alchemy/messages.rb

@@ -0,0 +1,15 @@
+module Alchemy
+  class Messages < ActionMailer::Base
+
+    def contact_form_mail(message, mail_to, mail_from, subject)
+      @message = message
+      mail(
+        from: mail_from,
+        to: mail_to,
+        reply_to: message.try(:email),
+        subject: subject
+      )
+    end
+
+  end
+end

data/app/models/alchemy.rb

@@ -0,0 +1,7 @@
+module Alchemy
+
+  def self.table_name_prefix
+    'alchemy_'
+  end
+
+end

data/app/models/alchemy/attachment.rb

@@ -0,0 +1,129 @@
+# == Schema Information
+#
+# Table name: alchemy_attachments
+#
+#  id              :integer          not null, primary key
+#  name            :string(255)
+#  file_name       :string(255)
+#  file_mime_type  :string(255)
+#  file_size       :integer
+#  creator_id      :integer
+#  updater_id      :integer
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  cached_tag_list :text
+#  file_uid        :string(255)
+#
+
+module Alchemy
+  class Attachment < ActiveRecord::Base
+    include Alchemy::Filetypes
+    include Alchemy::NameConversions
+    include Alchemy::Touching
+
+    acts_as_taggable
+
+    dragonfly_accessor :file, app: :alchemy_attachments do
+      after_assign { |f| write_attribute(:file_mime_type, f.mime_type) }
+    end
+
+    stampable stamper_class_name: Alchemy.user_class_name
+
+    has_many :essence_files, :class_name => 'Alchemy::EssenceFile', :foreign_key => 'attachment_id'
+    has_many :contents, :through => :essence_files
+    has_many :elements, :through => :contents
+    has_many :pages, :through => :elements
+
+    validates_presence_of :file
+    validates_format_of :file_name, with: /\A[A-Za-z0-9\.\-_]+\z/, on: :update
+    validates_size_of :file, maximum: Config.get(:uploader)['file_size_limit'].megabytes
+    validates_property :ext, of: :file,
+      in: Config.get(:uploader)['allowed_filetypes']['attachments'],
+      case_sensitive: false,
+      message: I18n.t("not a valid file"),
+      unless: -> { Config.get(:uploader)['allowed_filetypes']['attachments'].include?('*') }
+
+    before_create do
+      write_attribute(:name, convert_to_humanized_name(self.file_name, self.file.ext))
+      write_attribute(:file_name, sanitized_filename)
+    end
+
+    after_update :touch_contents
+
+    # Class methods
+
+    class << self
+
+      def find_paginated(params, per_page, order)
+        attachments = Attachment.arel_table
+        cond = attachments[:name].matches("%#{params[:query]}%").or(attachments[:file_name].matches("%#{params[:query]}%"))
+        self.where(cond).page(params[:page] || 1).per(per_page).order(order)
+      end
+
+    end
+
+    # Instance methods
+
+    def to_jq_upload
+      {
+        "name" => read_attribute(:file_name),
+        "size" => read_attribute(:file_size),
+        'error' => errors[:file].join
+      }
+    end
+
+    def urlname
+      read_attribute :file_name
+    end
+
+    # Checks if the attachment is restricted, because it is attached on restricted pages only
+    def restricted?
+      pages.any? && pages.not_restricted.blank?
+    end
+
+    def extension
+      file_name.split(".").last
+    end
+    alias_method :suffix, :extension
+
+    # Returns a css class name for kind of file
+    #
+    def icon_css_class
+      case file_mime_type
+        when *ARCHIVE_FILE_TYPES
+          then "archive"
+        when *AUDIO_FILE_TYPES
+          then "audio"
+        when *IMAGE_FILE_TYPES
+          then "image"
+        when *VIDEO_FILE_TYPES
+          then "video"
+        when "application/x-shockwave-flash"
+          then "flash"
+        when "image/x-psd"
+          then "psd"
+        when "text/plain"
+          then "text"
+        when "application/rtf"
+          then "rtf"
+        when "application/pdf"
+          then "pdf"
+        when "application/msword"
+          then "word"
+        when "application/vnd.ms-excel"
+          then "excel"
+        when *VCARD_FILE_TYPES
+          then "vcard"
+        else "file"
+      end
+    end
+
+    def sanitized_filename
+      parts = self.file_name.split('.')
+      sfx = parts.pop
+      name = convert_to_urlname(parts.join('-'))
+      "#{name}.#{sfx}"
+    end
+
+  end
+end

data/app/models/alchemy/cell.rb

@@ -0,0 +1,94 @@
+# == Schema Information
+#
+# Table name: alchemy_cells
+#
+#  id         :integer          not null, primary key
+#  page_id    :integer
+#  name       :string(255)
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+# A cell is a group of elements that are rendered inside a specific area on your page_layout.
+# Think of it like a column, or section in your layout. I.e. a header or right column.
+#
+# Elements are displayed in tabs inside the elements window in page edit view.
+# Every cell is a list of elements with the position scoped to +cell_id+ and +page_id+.
+#
+# Define cells inside a +cells.yml+ file located in the +config/alchermy+ folder of your project.
+#
+# Render cells with the +render_cell+ helper
+#
+# Views for cells are inside the +app/views/cells+ folder in your project.
+#
+module Alchemy
+  class Cell < ActiveRecord::Base
+    include Alchemy::Logger
+
+    belongs_to :page
+    validates_uniqueness_of :name, scope: 'page_id'
+    validates_format_of :name, with: /\A[a-z0-9_-]+\z/
+    has_many :elements, -> { order(:position) }, dependent: :destroy
+
+    class << self
+      def definitions
+        @definitions ||= read_yml_file
+      end
+
+      def definition_for(cellname)
+        return nil if cellname.blank?
+        definitions.detect { |c| c['name'] == cellname }
+      end
+
+      def all_definitions_for(cellnames)
+        definitions.select { |c| cellnames.include? c['name'] }
+      end
+
+      def definitions_for_element(element_name)
+        return [] if definitions.blank?
+        definitions.select { |d| d['elements'].include?(element_name) }
+      end
+
+      def translated_label_for(cell_name)
+        I18n.t(cell_name, scope: 'cell_names', default: cell_name.to_s.humanize)
+      end
+
+    private
+
+      def read_yml_file
+        ::YAML.load(ERB.new(File.read(yml_file_path)).result) || []
+      end
+
+      def yml_file_path
+        Rails.root.join('config', 'alchemy', 'cells.yml')
+      end
+    end
+
+    def to_partial_path
+      "alchemy/cells/#{name}"
+    end
+
+    # Returns the cell definition defined in +config/alchemy/cells.yml+
+    #
+    def definition
+      definition = self.class.definition_for(self.name)
+      if definition.blank?
+        log_warning "Could not find cell definition for #{self.name}. Please check your cells.yml!"
+        return {}
+      else
+        definition
+      end
+    end
+    alias_method :description, :definition
+
+    # Returns all elements that can be placed in this cell
+    def available_elements
+      definition['elements'] || []
+    end
+
+    def name_for_label
+      self.class.translated_label_for(self.name)
+    end
+
+  end
+end

data/app/models/alchemy/content.rb

@@ -0,0 +1,255 @@
+# == Schema Information
+#
+# Table name: alchemy_contents
+#
+#  id           :integer          not null, primary key
+#  name         :string(255)
+#  essence_type :string(255)
+#  essence_id   :integer
+#  element_id   :integer
+#  position     :integer
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  creator_id   :integer
+#  updater_id   :integer
+#
+
+module Alchemy
+  class Content < ActiveRecord::Base
+    include Alchemy::Logger
+    include Alchemy::Touching
+    include Alchemy::Hints
+
+    # Concerns
+    include Alchemy::Content::Factory
+
+    belongs_to :essence, :polymorphic => true, :dependent => :destroy
+    belongs_to :element, touch: true
+    has_one :page, through: :element
+
+    stampable stamper_class_name: Alchemy.user_class_name
+
+    acts_as_list
+
+    # ActsAsList scope
+    def scope_condition
+      # Fixes a bug with postgresql having a wrong element_id value, if element_id is nil.
+      "element_id = #{element_id || 'null'} AND essence_type = '#{essence_type}'"
+    end
+
+    # Essence scopes
+    scope :essence_booleans,  -> { where(essence_type: "Alchemy::EssenceBoolean") }
+    scope :essence_dates,     -> { where(essence_type: "Alchemy::EssenceDate") }
+    scope :essence_files,     -> { where(essence_type: "Alchemy::EssenceFile") }
+    scope :essence_htmls,     -> { where(essence_type: "Alchemy::EssenceHtml") }
+    scope :essence_links,     -> { where(essence_type: "Alchemy::EssenceLink") }
+    scope :essence_pictures,  -> { where(essence_type: "Alchemy::EssencePicture") }
+    scope :gallery_pictures,  -> { essence_pictures.where("#{self.table_name}.name LIKE 'essence_picture_%'") }
+    scope :essence_richtexts, -> { where(essence_type: "Alchemy::EssenceRichtext") }
+    scope :essence_selects,   -> { where(essence_type: "Alchemy::EssenceSelect") }
+    scope :essence_texts,     -> { where(essence_type: "Alchemy::EssenceText") }
+    scope :named,             ->(name) { where(name: name) }
+    scope :available,         -> { published.not_trashed }
+    scope :published,         -> { joins(:element).merge(Element.published) }
+    scope :not_trashed,       -> { joins(:element).merge(Element.not_trashed) }
+    scope :not_restricted,    -> { joins(:element).merge(Element.not_restricted) }
+
+    delegate :restricted?, to: :page,    allow_nil: true
+    delegate :trashed?,    to: :element, allow_nil: true
+    delegate :public?,     to: :element, allow_nil: true
+
+    class << self
+      # Returns the translated label for a content name.
+      #
+      # Translate it in your locale yml file:
+      #
+      #   alchemy:
+      #     content_names:
+      #       foo: Bar
+      #
+      # Optionally you can scope your content name to an element:
+      #
+      #   alchemy:
+      #     content_names:
+      #       article:
+      #         foo: Baz
+      #
+      def translated_label_for(content_name, element_name = nil)
+        I18n.t(
+          content_name,
+          scope: "content_names.#{element_name}",
+          default: I18n.t("content_names.#{content_name}", default: content_name.humanize)
+        )
+      end
+    end
+
+    # The content's view partial is dependent from its name
+    #
+    # == Define contents
+    #
+    # Contents are defined in the +config/alchemy/elements.yml+ file
+    #
+    #     - name: article
+    #       contents:
+    #       - name: headline
+    #         type: EssenceText
+    #
+    # == Override the view
+    #
+    # Content partials live in +app/views/alchemy/essences+
+    #
+    def to_partial_path
+      "alchemy/essences/#{essence_partial_name}_view"
+    end
+
+    # Settings from the elements.yml definition
+    def settings
+      return {} if description.blank?
+      @settings ||= description.fetch('settings', {}).symbolize_keys
+    end
+
+    def siblings
+      return [] if !element
+      self.element.contents
+    end
+
+    # Gets the ingredient from essence
+    def ingredient
+      return nil if essence.nil?
+      essence.ingredient
+    end
+
+    # Serialized object representation for json api
+    #
+    def serialize
+      {
+        name: name,
+        value: serialized_ingredient,
+        link: essence.try(:link)
+      }.delete_if { |_k, v| v.blank? }
+    end
+
+    # Ingredient value from essence for json api
+    #
+    # If the essence responds to +serialized_ingredient+ method it takes this
+    # otherwise it uses the ingredient column.
+    #
+    def serialized_ingredient
+      essence.try(:serialized_ingredient) || ingredient
+    end
+
+    # Sets the ingredient from essence
+    def ingredient=(value)
+      raise EssenceMissingError if essence.nil?
+      essence.ingredient = value
+    end
+
+    # Updates the essence.
+    #
+    # Called from +Alchemy::Element#update_contents+
+    #
+    # Adds errors to self.base if essence validation fails.
+    #
+    def update_essence(params = {})
+      raise EssenceMissingError if essence.nil?
+      if essence.update(params)
+        return true
+      else
+        errors.add(:essence, :validation_failed)
+        return false
+      end
+    end
+
+    def essence_validation_failed?
+      essence.errors.any?
+    end
+
+    def has_validations?
+      description['validate'].present?
+    end
+
+    # Returns a string to be passed to Rails form field tags to ensure we have same params layout everywhere.
+    #
+    # === Example:
+    #
+    #   <%= text_field_tag content.form_field_name, content.ingredient %>
+    #
+    # === Options:
+    #
+    # You can pass an Essence column_name. Default is 'ingredient'
+    #
+    # ==== Example:
+    #
+    #   <%= text_field_tag content.form_field_name(:link), content.ingredient %>
+    #
+    def form_field_name(essence_column = 'ingredient')
+      "contents[#{self.id}][#{essence_column}]"
+    end
+
+    def form_field_id(essence_column = 'ingredient')
+      "contents_#{self.id}_#{essence_column}"
+    end
+
+    # Returns a string used as dom id on html elements.
+    def dom_id
+      return '' if essence.nil?
+      "#{essence_partial_name}_#{id}"
+    end
+
+    # Returns the translated name for displaying in labels, etc.
+    def name_for_label
+      self.class.translated_label_for(self.name, self.element.name)
+    end
+
+    def linked?
+      essence && !essence.link.blank?
+    end
+
+    # Returns true if this content should be taken for element preview.
+    def preview_content?
+      if description['take_me_for_preview']
+        ActiveSupport::Deprecation.warn("Content definition's `take_me_for_preview` key is deprecated. Please use `as_element_title` instead.")
+      end
+      !!description['take_me_for_preview'] || !!description['as_element_title']
+    end
+
+    # Proxy method that returns the preview text from essence.
+    #
+    def preview_text(maxlength = 30)
+      essence.preview_text(maxlength)
+    end
+
+    def essence_partial_name
+      return '' if essence.nil?
+      essence.partial_name
+    end
+
+    def normalized_essence_type
+      self.class.normalize_essence_type(self.essence_type)
+    end
+
+    def has_custom_tinymce_config?
+      settings[:tinymce].present?
+    end
+
+    def tinymce_class_name
+      if has_custom_tinymce_config?
+        "custom_tinymce #{element.name}_#{name}"
+      else
+        "default_tinymce"
+      end
+    end
+
+    # Returns the default value from content description
+    # If the value is a symbol it gets passed through i18n inside the +alchemy.default_content_texts+ scope
+    def default_text(default)
+      case default
+      when Symbol
+        I18n.t(default, scope: :default_content_texts)
+      else
+        default
+      end
+    end
+
+  end
+end