alchemy_cms 2.1.beta1 → 2.1.beta5

data/app/controllers/elements_controller.rb

@@ -1,16 +0,0 @@
-class ElementsController < AlchemyController
-  
-  filter_access_to [:show], :attribute_check => true
-  layout false
-  
-  # Returns the element partial as HTML or as JavaScript that tries to replace a given +container_id+ with the partial content via jQuery.
-  def show
-    @element = Element.find(params[:id])
-    @page = @element.page
-    respond_to do |format|
-      format.html
-      format.js
-    end
-  end
-
-end

data/app/controllers/messages_controller.rb

@@ -1,113 +0,0 @@
-# == Sending Messages:
-# To send Messages via contact forms you can create your form fields in the config.yml
-# === Example:
-# Make an Element with this options inside your @elements.yml file:
-#
-#   - name: contact
-#     display_name: Kontaktformular
-#     contents:
-#     - name: mail_to
-#       type: EssenceText
-#     - name: subject
-#       type: EssenceText
-#     - name: mail_from
-#       type: EssenceText
-#     - name: success_page
-#       type: EssenceText
-#
-# The fields mail_to, mail_from, subject and success_page are recommended.
-# The MessagesController uses them to send your mails. So your customer has full controll of these values inside his contactform @element.
-# 
-# Then make a page layout for your contact page in the page_layouts.yml file:
-# 
-#   - name: contact
-#     display_name: Kontakt
-#     unique: true
-#     cache: false
-#     @elements: [pageheading, heading, contact, bild, absatz, file_download]
-#     autogenerate: [contact]
-#
-# Disabling the page caching is stronlgy recommended!
-#
-# The editor view for your @element should have this layout:
-# 
-#   <%= render_essence_editor_by_name(@element, 'mail_from') %>
-#   <%= render_essence_editor_by_name(@element, 'mail_to') %>
-#   <%= render_essence_editor_by_name(@element, 'subject') %>
-#   <p>
-#     Folgeseite: <%= page_selector(@element, 'success_page') %>
-#   </p>
-# 
-# Please have a look at the alchemy/config/config.yml file for further Message settings.
-
-class MessagesController < AlchemyController
-  
-  before_filter :get_page, :except => :create
-  
-  helper :pages
-
-  def index#:nodoc:
-    redirect_to show_page_path(:urlname => @page.urlname, :lang => multi_language? ? @page.language_code : nil)
-  end
-
-  def new#:nodoc:
-    @message = Message.new
-    render :template => '/pages/show', :layout => 'pages'
-  end
-
-  def create#:nodoc:
-    @message = Message.new(params[:message].merge(:ip => request.remote_ip))
-    @element = Element.find_by_id(@message.contact_form_id)
-    @page = @element.page
-    @root_page = @page.get_language_root
-    if @message.valid?
-      Messages.contact_form_mail(@message, mail_to, mail_from, subject).deliver
-      redirect_to_success_page
-    else
-      render :template => '/pages/show', :layout => 'pages'
-    end
-  end
-
-private
-
-  def mailer_config
-    Alchemy::Config.get(:mailer)
-  end
-
-  def mail_to
-    @element.ingredient("mail_to")
-  rescue
-    mailer_config[:mail_to]
-  end
-
-  def mail_from
-    @element.ingredient("mail_from")
-  rescue
-    mailer_config[:mail_from]
-  end
-
-  def subject
-    @element.ingredient("subject")
-  rescue
-    mailer_config[:subject]
-  end
-
-  def redirect_to_success_page
-    if @element.ingredient("success_page")
-      urlname = @element.ingredient("success_page")
-    elsif mailer_config[:forward_to_page] && mailer_config[:mail_success_page]
-      urlname = Page.find_by_urlname(mailer_config[:mail_success_page]).urlname
-    else
-      flash[:notice] = I18n.t('alchemy.contactform.messages.success')
-      urlname = Page.language_root_for(session[:language_id]).urlname
-    end
-    redirect_to show_page_path(:urlname => urlname, :lang => multi_language? ? session[:language_code] : nil)
-  end
-
-  def get_page
-    @page = Page.find_by_page_layout(mailer_config[:form_layout_name])
-    @root_page = @page.get_language_root
-    raise "Page for page_layout #{mailer_config[:page_layout_name]} not found" if @page.blank?
-  end
-
-end

data/app/controllers/pages_controller.rb

@@ -1,150 +0,0 @@
-class PagesController < AlchemyController
-  
-  before_filter :set_language_from_client, :only => [:show, :sitemap]
-  before_filter :get_page_from_urlname, :only => [:show, :sitemap]
-
-  filter_access_to :show, :attribute_check => true
-
-  caches_action(
-    :show,
-    :cache_path => proc { url_for(:action => :show, :urlname => params[:urlname], :lang => multi_language? ? params[:lang] : nil) },
-    :if => proc do
-      if Alchemy::Config.get(:cache_pages)
-        page = Page.find_by_urlname_and_language_id_and_public(
-          params[:urlname],
-          session[:language_id],
-          true,
-          :select => 'page_layout, language_id, urlname'
-        )
-        if page
-          pagelayout = Alchemy::PageLayout.get(page.page_layout)
-          pagelayout['cache'].nil? || pagelayout['cache']
-        end
-      else
-        false
-      end
-    end
-  )
-
-	# Showing page from params[:urlname]
-	# @page is fetched via before filter
-	# @root_page is fetched via before filter
-	# @language fetched via before_filter in alchemy_controller
-	# rendering page and querying for search results if any query is present
-	def show
-		if configuration(:ferret) && !params[:query].blank?
-			perform_search
-		end
-		respond_to do |format|
-			format.html {
-				render :layout => params[:layout].blank? ? 'pages' : params[:layout] == 'none' ? false : params[:layout]
-			}
-			format.rss {
-				if @page.contains_feed?
-					render :action => "show.rss.builder", :layout => false
-				else
-					render :xml => { :error => 'Not found' }, :status => 404
-				end
-			}
-		end
-	end
-
-  # Renders a Google conform sitemap in xml
-  def sitemap
-    @pages = Page.find_all_by_sitemap_and_public(true, true)
-    respond_to do |format|
-      format.xml { render :layout => "sitemap" }
-    end
-  end
-
-private
-
-  def get_page_from_urlname
-    if params[:urlname].blank?
-      @page = Page.language_root_for(Language.get_default.id)
-    else
-      @page = Page.find_by_urlname_and_language_id(params[:urlname], session[:language_id])
-      # try to find the page in another language
-      if @page.nil?
-        @page = Page.find_by_urlname(params[:urlname])
-      end
-    end
-    if User.admins.count == 0 && @page.nil?
-      redirect_to signup_path
-    elsif @page.blank?
-      render(:file => "#{Rails.root}/public/404.html", :status => 404, :layout => false)
-    elsif multi_language? && params[:lang].blank?
-      redirect_page(:lang => session[:language_code])
-    elsif multi_language? && params[:urlname].blank? && !params[:lang].blank? && configuration(:redirect_index)
-      redirect_page(:lang => params[:lang])
-    elsif configuration(:redirect_to_public_child) && !@page.public?
-      redirect_to_public_child
-    elsif params[:urlname].blank? && configuration(:redirect_index)
-      redirect_page
-    elsif !multi_language? && !params[:lang].blank?
-      redirect_page
-    elsif @page.has_controller?
-      redirect_to(@page.controller_and_action)
-    else
-      # setting the language to page.language to be sure it's correct
-      set_language_to(@page.language_id)
-      if params[:urlname].blank?
-        @root_page = @page
-      else
-        @root_page = Page.language_root_for(session[:language_id])
-      end
-    end
-  end
-
-  def perform_search
-    @rtf_search_results = EssenceRichtext.find_with_ferret(
-      "*#{params[:query]}*",
-      {:limit => :all},
-      {:conditions => ["public = ?", true]}
-    )
-    @text_search_results = EssenceText.find_with_ferret(
-      "*#{params[:query]}*",
-      {:limit => :all},
-      {:conditions => ["public = ?", true]}
-    )
-    @search_results = (@text_search_results + @rtf_search_results).sort{ |y, x| x.ferret_score <=> y.ferret_score }
-  end
-
-  def find_first_public(page)
-    if(page.public == true)
-      return page
-    end
-    page.children.each do |child|
-      result = find_first_public(child)
-      if(result!=nil)
-        return result
-      end
-    end
-    return nil
-  end
-
-  def redirect_to_public_child
-    @page = find_first_public(@page)
-    if @page.blank?
-      render :file => "#{Rails.root}/public/404.html", :status => 404, :layout => false
-    else
-      redirect_page
-    end
-  end
-
-  def redirect_page(options={})
-    defaults = {
-      :lang => (multi_language? ? @page.language_code : nil),
-      :urlname => @page.urlname
-    }
-    options = defaults.merge(options)
-    redirect_to show_page_path(options.merge(additional_params)), :status => 301
-  end
-
-  def additional_params
-    params.clone.delete_if do |key, value|
-      ["action", "controller", "urlname", "lang"].include?(key)
-    end
-  end
-
-end

data/app/controllers/pictures_controller.rb

@@ -1,63 +0,0 @@
-class PicturesController < AlchemyController
-  
-  caches_page :show, :thumbnail, :zoom
-  
-  filter_access_to :thumbnail
-  
-  def show
-    @picture = Picture.find(params[:id])
-    @size = params[:size]
-    @crop = !params[:crop].nil?
-    @crop_from = normalized_size(params[:crop_from])
-    @crop_size = params[:crop_size]
-    @padding = params[:padding]
-    @upsample = !params[:upsample].nil? ? true : false
-    @effects = params[:effects]
-    respond_to do |format|
-      format.jpg
-      format.png
-      format.gif
-    end
-  end
-
-  def thumbnail
-    @picture = Picture.find(params[:id])
-    case params[:size]
-    when "small"
-      then
-      @size = "80x60"
-    when "medium"
-      then
-      @size = "160x120"
-    when "large"
-      then
-      @size = "240x180"
-    when nil
-      @size = "111x93"
-    else
-      @size = params[:size]
-    end
-    if !params[:crop_size].blank? && !params[:crop_from].blank?
-      @crop = true
-    elsif params[:crop] == 'crop'
-      @default_crop = true
-    end
-  end
-
-  def zoom
-    @picture = Picture.find(params[:id])
-    respond_to do |format|
-      format.png
-    end
-  end
-
-private
-
-  def normalized_size(size)
-    return "" if size.blank?
-    size.split("x").map do |s| 
-      s.to_i < 0 ? 0 : s.to_i
-    end.join('x')
-  end
-
-end

data/app/helpers/admin/attachments_helper.rb

@@ -1,7 +0,0 @@
-module Admin::AttachmentsHelper
-
-  def mime_to_human mime
-    I18n.t("alchemy.mime_types.#{mime}", :default => _('document'))
-  end
-
-end

data/app/helpers/admin/elements_helper.rb

@@ -1,112 +0,0 @@
-module Admin::ElementsHelper
-
-  include ::ElementsHelper
-
-  # Returns an Array for essence_text_editor select options_for_select.
-  def elements_by_name_for_select(name, options={})
-    defaults = {
-      :grouped_by_page => true,
-      :from_page => :all
-    }
-    options = defaults.merge(options)
-    elements = all_elements_by_name(
-      name,
-      :from_page => options[:from_page]
-    )
-    if options[:grouped_by_page] && options[:from_page] == :all
-      elements_for_options = {}
-      pages = elements.collect(&:page).compact.uniq
-      pages.sort{ |x,y| x.name <=> y.name }.each do |page|
-        page_elements = page.elements.select { |e| e.name == name }
-        elements_for_options[page.name] = page_elements.map { |pe| [pe.preview_text, pe.id.to_s] }
-      end
-    else
-      elements_for_options = elements.map { |e| [e.preview_text, e.id.to_s] }
-      elements_for_options = [''] + elements_for_options
-    end
-    return elements_for_options
-  end
-
-  # Renders the element editor partial
-  def render_editor(element)
-    render_element(element, :editor)
-  end
-
-  # This helper renderes the picture editor for the elements on the Alchemy Desktop.
-  # It brings full functionality for adding images to the element, deleting images from it 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), default nil. This option let you handle the amount of images your customer can add to this element.
-  def render_picture_editor(element, options={})
-    default_options = {
-      :last_image_deletable => true,
-      :maximum_amount_of_images => nil,
-      :refresh_sortable => true
-    }
-    options = default_options.merge(options)
-    picture_contents = element.all_contents_by_type("EssencePicture")
-    render(
-      :partial => "admin/elements/picture_editor",
-      :locals => {
-        :picture_contents => picture_contents,
-        :element => element,
-        :options => options
-      }
-    )
-  end
-
-  # Returns all elements that could be placed on that page because of the pages layout.
-  # The elements are returned as an array to be used in alchemy_selectbox form builder.
-  def elements_for_select(elements)
-    return [] if elements.nil?
-    options = elements.collect{ |e| [I18n.t("alchemy.element_names.#{e['name']}", :default => e['name'].capitalize), e["name"]] }
-    return options_for_select(options)
-  end
-  
-  # Returns all elements that could be placed on that page because of the pages layout.
-  # The elements will be grouped by cell.
-  def grouped_elements_for_select(elements, object_method = 'name')
-    return [] if elements.nil?
-    cells_definition = Cell.definitions
-    return [] if cells_definition.blank?
-    options = {}
-    celled_elements = []
-    cells_definition.each do |cell|
-      cell_elements = elements.select { |e| cell['elements'].include?(e.class.name == 'Element' ? e.name : e['name']) }
-      celled_elements += cell_elements
-      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
-    other_elements = elements - celled_elements
-    unless other_elements.blank?
-      optgroup_label = _('other Elements')
-      options[optgroup_label] = other_elements.map do |e|
-				element_array_for_options(e, object_method)
-			end
-    end
-    return grouped_options_for_select(options)
-  end
-
-	def element_array_for_options(e, object_method, cell = nil)
-		if e.class.name == 'Element'
-			[
-				e.display_name_with_preview_text,
-				e.send(object_method).to_s + (cell ? "##{cell['name']}" : "")
-			]
-		else
-			[
-				I18n.t("alchemy.element_names.#{e['name']}", :default => e['name'].capitalize),
-				e[object_method] + (cell ? "##{cell['name']}" : "")
-			]
-		end
-	end
-
-	def tinymce_tag(name, content = '', options = {})
-		append_class_name(options, 'tinymce')
-		text_area_tag(name, content, options)
-	end
-
-end