alchemy_cms 2.0.pre2

data/app/models/element.rb

@@ -0,0 +1,423 @@
+require 'yaml'
+require 'acts_as_list'
+
+class Element < ActiveRecord::Base
+  
+  # All Elements inside a cell are a list. All Elements not in cell are in the cell_id.nil list.
+  acts_as_list :scope => [:page_id, :cell_id]
+  stampable :stamper_class_name => :user
+  
+  has_many :contents, :order => :position, :dependent => :destroy
+  belongs_to :cell
+  belongs_to :page
+  has_and_belongs_to_many :to_be_sweeped_pages, :class_name => 'Page', :uniq => true
+  
+  validates_uniqueness_of :position, :scope => [:page_id, :cell_id]
+  validates_presence_of :name, :on => :create, :message => N_("Please choose an element.")
+  
+  attr_accessor :create_contents_after_create
+  after_create :create_contents, :unless => Proc.new { |m| m.create_contents_after_create == false }
+  
+  # TODO: add a trashed column to elements table
+  scope :trashed, where(:page_id => nil).order('updated_at DESC')
+  
+  # Returns next Element on self.page or nil. Pass a Element.name to get next of this kind.
+  def next(name = nil)
+    if name.nil?
+      find_conditions = ["public = 1 AND page_id = ? AND position > ?", self.page.id, self.position]
+    else
+      find_conditions = ["public = 1 AND page_id = ? AND name = ? AND position > ?", self.page.id, name, self.position]
+    end
+    self.class.where(find_conditions).order("position ASC").limit(1)
+  end
+  
+  # Returns previous Element on self.page or nil. Pass a Element.name to get previous of this kind.
+  def prev(name = nil)
+    if name.nil?
+      find_conditions = ["public = 1 AND page_id = ? AND position < ?", self.page.id, self.position]
+    else
+      find_conditions = ["public = 1 AND page_id = ? AND name = ? AND position < ?", self.page.id, name, self.position]
+    end
+    self.class.where(find_conditions).order("position DESC").limit(1)
+  end
+
+  def store_page page
+    unless self.to_be_sweeped_pages.include? page
+      self.to_be_sweeped_pages << page
+      self.save
+    end
+  end
+  
+  # nullifies the page_id aka. trashs it.
+  def trash
+    self.page_id = nil
+    self.folded = true
+    self.save(false)
+  end
+  
+  def trashed?
+    page_id.nil?
+  end
+  
+  def content_by_name(name)
+    self.contents.find_by_name(name)
+  end
+
+  def content_by_type(essence_type)
+    self.contents.find_by_essence_type(essence_type)
+  end
+
+  def all_contents_by_name(name)
+    self.contents.find_all_by_name(name)
+  end
+
+  def all_contents_by_type(essence_type)
+    self.contents.find_all_by_essence_type(essence_type)
+  end
+
+  # Inits a new element for page as described in /config/alchemy/elements.yml from element_name
+  def self.new_from_scratch(attributes)
+    attributes.stringify_keys!    
+    return Element.new if attributes['name'].blank?
+    element_descriptions = Element.descriptions
+    return if element_descriptions.blank?
+    element_scratch = element_descriptions.select{ |m| m["name"] == attributes['name'].split('#').first }.first
+    element = Element.new(
+      element_scratch.except('contents', 'available_contents', 'display_name').merge({
+        :page_id => attributes['page_id']
+      })
+    )
+    element
+  end
+
+  # Inits a new element for page as described in /config/alchemy/elements.yml from element_name and saves it
+  def self.create_from_scratch(attributes)
+    element = Element.new_from_scratch(attributes)
+    element.save if element
+    return element
+  end
+
+  # pastes a element from the clipboard in the session to page
+  def self.paste_from_clipboard(page_id, element, method, position)
+    copy = self.copy(element, :page_id => page_id)
+    copy.insert_at(position)
+    if method == "move" && copy.valid?
+      element.destroy
+    end
+    copy
+  end
+
+  def self.descriptions
+    if File.exists? "#{Rails.root}/config/alchemy/elements.yml"
+      @elements = YAML.load_file( "#{Rails.root}/config/alchemy/elements.yml" )
+    elsif File.exists? "#{Rails.root}/vendor/plugins/alchemy/config/alchemy/elements.yml"
+      @elements = YAML.load_file( "#{Rails.root}/vendor/plugins/alchemy/config/alchemy/elements.yml" )
+    else
+      raise "Could not read config/alchemy/elements.yml"
+    end
+  end
+  
+  def self.definitions
+    self.descriptions
+  end
+  
+  # Returns the array with the hashes for all element contents in the elements.yml file
+  def content_descriptions
+    return nil if description.blank?
+    description['contents']
+  end
+
+  # Returns the array with the hashes for all element available_contents in the elements.yml file
+  def available_content_descriptions
+    return nil if description.blank?
+    description['available_contents']
+  end
+
+  # Returns the description for given content_name
+  def content_description_for(content_name)
+    if content_descriptions.blank?
+      logger.warn("\n+++++++++++ Warning: Element #{self.name} is missing the content description for #{content_name}\n")
+      return nil
+    else
+      content_descriptions.detect { |d| d['name'] == content_name }
+    end
+  end
+
+  # Returns the description for given content_name inside the available_contents
+  def available_content_description_for(content_name)
+    return nil if available_content_descriptions.blank?
+    available_content_descriptions.detect { |d| d['name'] == content_name }
+  end
+
+  # returns the description of the element with my name in element.yml
+  def description
+    return nil if Element.descriptions.blank?
+    Element.descriptions.detect{ |d| d['name'] == self.name }
+  end
+
+  # Human name for displaying in selectboxes and element editor views.
+  # The name is beeing translated from elements name value as described in config/alchemy/elements.yml
+  # 
+  # Translate the name in your config/locales language file. Example:
+  # 
+  #   de:
+  #     element_names:
+  #       contactform: 'Kontakt Formular'
+  # 
+  # If no translation is found the capitalized name is used!
+  # 
+  def display_name
+    return name.capitalize if description.blank?
+    I18n.t("alchemy.element_names.#{description['name']}", :default => name.capitalize)
+  end
+
+  # Gets the preview text from the first Content found in the +elements.yml+ Element description file.
+  # You can flag a Content as +take_me_for_preview+ to take this as preview.
+  def preview_text(maxlength = 30)
+    return "" if description.blank?
+    my_contents = description["contents"]
+    return "" if my_contents.blank?
+    content_flagged_as_preview = my_contents.select{ |a| a["take_me_for_preview"] }.first
+    if content_flagged_as_preview.blank?
+      content_to_take_as_preview = my_contents.first
+    else
+      content_to_take_as_preview = content_flagged_as_preview
+    end
+    preview_content = self.contents.select{ |content| content.name == content_to_take_as_preview["name"] }.first
+    return "" if preview_content.blank? || preview_content.essence.blank?
+    text = preview_content.essence.preview_text(maxlength)
+    text.size > maxlength ? "#{text[0..maxlength]}..." : text
+  end
+
+  # Generates a preview text containing Element#display_name and Element#preview_text.
+  # It is displayed inside the head of the Element in the Elements.list overlay window from the Alchemy Admin::Page#edit view.
+  # 
+  # === Example
+  # 
+  # A Element described as:
+  #  
+  #     - name: funky_element
+  #       display_name: Funky Element
+  #       contents:
+  #       - name: headline
+  #         type: EssenceText
+  #       - name: text
+  #         type EssenceRichtext
+  #         take_me_for_preview: true
+  # 
+  # With "I want to tell you a funky story" as stripped_body for the EssenceRichtext Content produces:
+  # 
+  #     Funky Element: I want to tell ...
+  #
+  # Options:
+  # 
+  #     maxlength(integer). [Default 30] : Length of characters after the text will be cut off.
+  #
+  def display_name_with_preview_text(maxlength = 30)
+    "#{display_name}: #{preview_text(maxlength)}"
+  end
+
+  def dom_id
+    "#{name}_#{id}"
+  end
+
+  # List all elements by from page_layout
+  def self.elements_for_layout(layout)
+    element_descriptions = Element.descriptions
+    elements = []
+    page_layout = Alchemy::PageLayout.get(layout)
+    layout_elements = page_layout["elements"]
+    return element_descriptions if layout_elements == "all"
+    element_descriptions.each do |element|
+      if layout_elements.include?(element["name"])
+        elements << element
+      end
+    end
+    return elements
+  end
+
+  def self.get_from_clipboard(clipboard)
+    return nil if clipboard.blank?
+    self.find_by_id(clipboard[:element_id])
+  end
+
+  def self.all_from_clipboard(clipboard)
+    return [] if clipboard.nil?
+    self.find_all_by_id(clipboard)
+  end
+
+  def self.all_from_clipboard_for_page(clipboard, page)
+    return [] if clipboard.nil? || page.nil?
+    allowed_elements = self.all_for_page(page)
+    clipboard_elements = self.all_from_clipboard(clipboard)
+    allowed_element_names = allowed_elements.collect { |e| e['name'] }
+    clipboard_elements.select { |ce| allowed_element_names.include?(ce.name) }
+  end
+
+  # returns the collection of available essence_types that can be created for this element depending on its description in elements.yml
+  def available_contents
+    description['available_contents']
+  end
+
+  # Returns the contents ingredient for passed content name.
+  def ingredient(name)
+    content = content_by_name(name)
+    return nil if content.blank?
+    content.ingredient
+  end
+  
+  def save_contents(params)
+    contents.each do |content|
+      unless content.save_essence(params[:contents]["content_#{content.id}"], :public => !params["public"].nil?)
+        errors.add(:base, :essence_validation_failed)
+      end
+    end
+    return errors.blank?
+  end
+  
+  def essences
+    return [] if contents.blank?
+    contents.collect(&:essence)
+  end
+  
+  # Returns all essence_errors in the format:
+  # 
+  #   {
+  #     essence.content.name => [error_message_for_validation_1, error_message_for_validation_2]
+  #   }
+  # 
+  # Get translated error messages with Element#essence_error_messages
+  #
+  def essence_errors
+    essence_errors = {}
+    essences.each do |essence|
+      unless essence.essence_errors.blank?
+        essence_errors[essence.content.name] = essence.essence_errors
+      end
+    end
+    essence_errors
+  end
+  
+  # Essence validation errors messages are translated via I18n.
+  # Inside your translation file add translations like:
+  # 
+  #   alchemy:
+  #     content_validations:
+  #       name_of_the_element:
+  #         name_of_the_content:
+  #           validation_error_type: Error Message
+  # 
+  # validation_error_type has to be one of:
+  # 
+  # * blank
+  # * taken
+  # * wrong_format
+  # 
+  # Example:
+  # 
+  #   de:
+  #     alchemy:
+  #       content_validations:
+  #         contact:
+  #           email:
+  #             wrong_format: 'Die Email hat nicht das richtige Format'
+  # 
+  def essence_error_messages
+    messages = []
+    essence_errors.each do |content_name, errors|
+      errors.each do |error|
+        messages << I18n.t(
+          "alchemy.content_validations.#{self.name}.#{content_name}.#{error}",
+          :default => [
+            "alchemy.content_validations.fields.#{content_name}.#{error}".to_sym,
+            "alchemy.content_validations.errors.#{error}".to_sym
+          ]
+        ) % {:field => Content.translated_label_for(content_name)}
+      end
+    end
+    messages
+  end
+  
+  def contents_with_errors
+    contents.select(&:essence_validation_failed?)
+  end
+  
+  def has_validations?
+    !contents.detect(&:has_validations?).blank?
+  end
+  
+  def rtf_contents
+    contents.select { |content| content.essence_type == 'EssenceRichtext' }
+  end
+  alias_method :richtext_contents, :rtf_contents
+  
+  # The name of the cell the element could be placed in.
+  def belonging_cellname
+    cellname = Cell.name_for_element(name)
+    if cellname.blank?
+      return 'for_other_elements' 
+    else
+      return cellname
+    end
+  end
+  
+private
+  
+  # List all elements for page_layout
+  def self.all_for_page(page)
+    # if page_layout has cells, collect elements from cells and group them by cellname
+    page_layout = Alchemy::PageLayout.get(page.page_layout)
+    if page_layout.blank?
+      logger.warn "\n++++++\nWARNING! Could not find page_layout description for page: #{page.name}\n++++++++\n"
+      return []
+    end
+    elements_for_layout = []
+    elements_for_layout += all_definitions_for(page_layout['elements'])
+    return [] if elements_for_layout.blank?
+    # all unique elements from this layout
+    unique_elements = elements_for_layout.select{ |m| m["unique"] == true }
+    elements_already_on_the_page = page.elements
+    # delete all elements from the elements that could be placed that are unique and already and the page
+    unique_elements.each do |unique_element|
+      elements_already_on_the_page.each do |already_placed_element|
+        if already_placed_element.name == unique_element["name"]
+          elements_for_layout.delete(unique_element)
+        end
+      end
+    end
+    return elements_for_layout
+  end
+  
+  def self.all_definitions_for(element_names)
+    if element_names.to_s == "all"
+      return element_descriptions
+    else
+      return definitions.select { |e| element_names.include? e['name'] }
+    end
+  end
+  
+  # makes a copy of source and makes copies of the contents from source
+  def self.copy(source, differences = {})
+    attributes = source.attributes.except("id").merge(differences)
+    element = self.create!(attributes.merge(:create_contents_after_create => false, :id => nil, :position => nil))
+    source.contents.each do |content|
+      new_content = Content.copy(content, :element_id => element.id)
+      new_content.move_to_bottom
+    end
+    element
+  end
+
+  # creates the contents for this element as described in the elements.yml
+  def create_contents
+    element_scratch = description
+    contents = []
+    if element_scratch["contents"].blank?
+      logger.warn "\n++++++\nWARNING! Could not find any content descriptions for element: #{self.name}\n++++++++\n"
+    else
+      element_scratch["contents"].each do |content_hash|
+        contents << Content.create_from_scratch(self, content_hash.symbolize_keys)
+      end
+    end
+  end
+
+end

data/app/models/essence_audio.rb

@@ -0,0 +1,17 @@
+class EssenceAudio < ActiveRecord::Base
+
+  acts_as_essence(
+    :ingredient_column => :attachment,
+    :preview_text_method => :name
+  )
+
+  belongs_to :attachment
+
+  # Saves the ingredient
+  def save_ingredient(params, options = {})
+    return true if params.blank?
+    self.attachment_id = params["attachment_id"].to_s
+    self.save
+  end
+
+end

data/app/models/essence_date.rb

@@ -0,0 +1,20 @@
+class EssenceDate < ActiveRecord::Base
+
+  acts_as_essence(
+    :ingredient_column => :date
+  )
+  
+  # Returns self.date for the Element#preview_text method.
+  def preview_text(foo=nil)
+    return "" if date.blank?
+    I18n.l(date)
+  end
+
+  # Saves the ingredient
+  def save_ingredient(params, options = {})
+    return true if params.blank?
+    self.date = DateTime.parse(params['date'].values.join('-'))
+    self.save
+  end
+
+end