alchemy_cms 2.1.beta1 → 2.1.beta5

data/app/controllers/admin/trash_controller.rb

@@ -1,28 +0,0 @@
-class Admin::TrashController < AlchemyController
-  
-  filter_access_to [:index, :clear]
-  
-  before_filter :set_translation
-  
-  helper Admin::ElementsHelper
-  
-  def index
-    @elements = Element.trashed
-    @page = Page.find_by_id(params[:page_id])
-    @allowed_elements = Element.all_for_page(@page)
-		@draggable_trash_items = {}
-		@elements.each { |e| @draggable_trash_items["element_#{e.id}"] = e.belonging_cellnames(@page) }
-    render :layout => false
-  rescue Exception => e
-    exception_handler(e)
-  end
-  
-  def clear
-    @page = Page.find_by_id(params[:page_id])
-    @elements = Element.trashed
-    @elements.map(&:destroy)
-  rescue Exception => e
-    exception_handler(e)
-  end
-  
-end

data/app/controllers/admin/users_controller.rb

@@ -1,73 +0,0 @@
-class Admin::UsersController < AlchemyController
-
-  filter_access_to [:edit, :update, :destroy], :attribute_check => true
-  filter_access_to [:index, :new, :create], :attribute_check => false
-
-  before_filter :set_translation
-
-  def index
-    if !params[:query].blank?
-      @users = User.where([
-        "users.login LIKE ? OR users.email LIKE ? OR users.firstname LIKE ? OR users.lastname LIKE ?",
-        "%#{params[:query]}%",
-        "%#{params[:query]}%",
-        "%#{params[:query]}%",
-        "%#{params[:query]}%"
-      ]).order('login')
-    else
-      @users = User.all
-    end
-  end
-
-  def new
-    @user = User.new
-    render :layout => false
-  end
-
-  def create
-    @user = User.new(params[:user])
-    if @user.save
-      if @user.role == "registered" && params[:send_credentials]
-        Notifications.registered_user_created(@user).deliver
-      elsif params[:send_credentials]
-        Notifications.admin_user_created(@user).deliver
-      end
-    end
-    render_errors_or_redirect(
-      @user,
-      admin_users_path,
-      ( _("User: '%{name}' created") % {:name => @user.name} ),
-      "form#new_user button.button"
-    )
-  rescue
-    exception_handler($!)
-  end
-
-  def edit
-    # User is fetched via before filter from authentication plugin
-    render :layout => false
-  end
-
-  def update
-    # User is fetched via before filter from authentication plugin
-    @user.update_attributes(params[:user])
-    Notifications.admin_user_created(@user).deliver if params[:send_credentials]
-    render_errors_or_redirect(
-      @user,
-      admin_users_path,
-      ( _("User: '%{name}' updated") % {:name => @user.name} ),
-      "form#edit_user_#{@user.id} button.button"
-    )
-  end
-
-  def destroy
-    # User is fetched via before filter from authentication plugin
-    name = @user.name
-    if @user.destroy
-      flash[:notice] = ( _("User: '%{name}' deleted") % {:name => name} )
-    end
-		@redirect_url = admin_users_path
-		render :action => :redirect
-  end
-
-end

data/app/controllers/admin_controller.rb

@@ -1,76 +0,0 @@
-class AdminController < AlchemyController
-  
-  filter_access_to :index
-  before_filter :set_translation
-  before_filter :check_user_count, :only => :login
-
-  layout 'alchemy'
-
-  def index
-    @alchemy_version = Alchemy::VERSION
-    @clipboard_items = session[:clipboard]
-    @last_edited_pages = Page.all_last_edited_from(current_user)
-    @locked_pages = Page.all_locked
-    @online_users = User.all_online
-  end
-
-  # Signup only works if no user is present in database.
-  def signup
-    if request.get?
-      redirect_to admin_path if User.count != 0
-      @user = User.new({:role => 'admin'})
-    else
-      @user = User.new(params[:user])
-      if @user.save
-        if params[:send_credentials]
-          Notifications.admin_user_created(@user).deliver
-        end
-        redirect_to :action => :index
-      end
-    end
-  end
-
-  def login
-    if request.get?
-      @user_session = UserSession.new()
-      flash.now[:info] = params[:message] || _("welcome_please_identify_notice")
-      render :layout => 'login'
-    else
-      @user_session = UserSession.new(params[:user_session])
-      if @user_session.save
-        if session[:redirect_url].blank?
-          redirect_to :action => :index
-        else
-          redirect_to session[:redirect_url]
-        end
-      else
-        render :layout => 'login'
-      end
-    end
-  end
-
-  def leave
-    render :layout => false
-  end
-
-  def logout
-    message = params[:message] || _("logged_out")
-    @user_session = UserSession.find
-    if @user_session
-      @user_session.destroy
-    end
-    flash[:info] = message
-    redirect_to root_url
-  end
-
-private
-
-  def check_user_count
-    if User.count == 0
-      redirect_to :action => 'signup'
-    else
-      return true
-    end
-  end
-
-end

data/app/controllers/alchemy_controller.rb

@@ -1,245 +0,0 @@
-# This is the main Alchemy controller all other controllers inheret from.
-class AlchemyController < ApplicationController
-  
-  include FastGettext::Translation
-  include Alchemy
-  include Userstamp
-  
-  protect_from_forgery
-  
-  before_filter :init_gettext
-  before_filter :set_translation
-  before_filter :set_language
-  before_filter :mailer_set_url_options
-  
-  helper_method :current_server, :configuration, :multi_language?, :current_user, :clipboard_empty?, :trash_empty?, :get_clipboard, :is_admin?
-  helper :layout
-
-  # Returns true if the current_user (The logged-in Alchemy User) has the admin role.
-  def is_admin?
-    return false if !current_user
-    current_user.admin?
-  end
-
-	def render_errors_or_redirect(object, redirect_url, flash_notice, button = nil)
-		if object.errors.empty?
-			@redirect_url = redirect_url
-			flash[:notice] = _(flash_notice)
-			render :action => :redirect
-		else
-			render_remote_errors(object, button)
-		end
-	end
-
-	def render_remote_errors(object, button = nil)
-		@button = button
-		@errors = ("<ul>" + object.errors.sum { |a, b| "<li>" + _(b) + "</li>" } + "</ul>").html_safe
-		render :action => :remote_errors
-	end
-
-  # Returns a host string with the domain the app is running on.
-  def current_server
-    # For local development server
-    if request.port != 80
-      "http://#{request.host}:#{request.port}"
-    # For remote production server
-    else
-      "http://#{request.host}"
-    end
-  end
-
-  def configuration(name)
-    return Alchemy::Config.get(name)
-  end
-
-  def set_language_to(language_id)
-    @language = Language.find(language_id)
-    if @language
-      session[:language_id] = @language.id
-      session[:language_code] = @language.code
-      I18n.locale = @language.code
-    else
-      logger.error "+++++++ Language not found for language_id: #{language_id}"
-    end
-  end
-
-  def multi_language?
-    Language.published.count > 1
-  end
-
-  def current_user
-    return @current_user if defined?(@current_user)
-    @current_user = current_user_session && current_user_session.record
-  end
-
-  def current_user_session
-    return @current_user_session if defined?(@current_user_session)
-    @current_user_session = UserSession.find
-  end
-
-  def logged_in?
-    !current_user.blank?
-  end
-
-private
-
-  def last_request_update_allowed?
-    true #action_name =! "update_session_time_left"
-  end
-
-  # Handles exceptions
-  def exception_handler(e)
-    exception_logger(e)
-    show_error_notice(e)
-    # TODO: Exception Mailer!
-  end
-
-  # Logs the current exception to the error log.
-  def exception_logger(e)
-    message = "\n+++++++++ Error: #{e} +++++++++++++\n\n"
-    e.backtrace.each do |line|
-      message += "#{line}\n"
-    end
-    logger.error(message)
-  end
-
-  # Displays an error notice in the Alchemy backend.
-  def show_error_notice(e)
-    @notice = "Error: #{e}"
-    if request.xhr?
-      render :action => "error_notice"
-    else
-      flash[:error] = notice
-    end
-  end
-
-  def set_language_from_client
-    if params[:lang].blank?
-      lang = request.env['HTTP_ACCEPT_LANGUAGE'][0..1] unless request.env['HTTP_ACCEPT_LANGUAGE'].blank?
-      language_code = lang
-    else
-      language_code = params[:lang]
-    end
-    @language = Language.find_by_code(language_code) || Language.get_default
-    if @language.blank?
-      logger.warn "+++++++ Language not found for code: #{language_code}"
-      render :file => Rails.root + 'public/404.html', :code => 404
-    else
-      session[:language_id] = @language.id
-      session[:language_code] = @language.code
-      I18n.locale = @language.code      
-    end
-  end
-
-  def store_location
-    session[:redirect_url] = request.url
-  end
-
-  def set_stamper
-    User.stamper = self.current_user
-  end
-
-  def reset_stamper
-    User.reset_stamper
-  end
-
-  def mailer_set_url_options
-    ActionMailer::Base.default_url_options[:host] = request.host_with_port
-  end
-
-  def hashified_options
-    return nil if params[:options].blank?
-    if params[:options].is_a?(String)
-      Rack::Utils.parse_query(params[:options])
-    else
-      params[:options]
-    end
-  end
-
-protected
-
-  def init_gettext#:nodoc:
-    FastGettext.available_locales = configuration(:translations).collect { |l| l[:language_code] }
-  end
-
-  # Setting the Alchemy GUI translation to users preffered language, or to the default translation.
-  # You can set the default_translation in your config/alchemy/config.yml file
-  def set_translation
-    if current_user.blank? || current_user.language.blank?
-      FastGettext.locale = configuration(:default_translation) || I18n.locale
-    else
-      FastGettext.locale = current_user.language || I18n.locale
-    end
-  end
-
-  def set_language
-    if session[:language_id].blank?
-      set_language_to_default
-    else
-      set_language_to(session[:language_id])
-    end
-  end
-
-  def permission_denied
-    if current_user
-      if current_user.role == 'registered'
-        redirect_to root_path
-      else
-        if request.referer == login_url
-          render :file => File.join(Rails.root.to_s, 'public', '422.html'), :status => 422, :layout => false
-        elsif request.xhr?
-          render :partial => 'admin/partials/flash', :locals => {:message => _('You are not authorized'), :flash_type => 'warning'}
-        else
-          flash[:error] = _('You are not authorized')
-          redirect_to admin_path
-        end
-      end
-    else
-      flash[:info] = _('Please log in')
-      if request.xhr?
-        render :action => :permission_denied
-      else
-        store_location
-        redirect_to login_path
-      end
-    end
-  end
-
-  def redirect_back_or_to_default(default_path = admin_path)
-    if request.env["HTTP_REFERER"].blank?
-      redirect_to default_path
-    else
-      redirect_to :back
-    end
-  end
-
-  # Setting language relevant stuff to defaults.
-  def set_language_to_default
-    @language = Language.get_default
-    session[:language_id] = @language.id
-    session[:language_code] = @language.code
-    I18n.locale = @language.code
-  rescue
-    exception_logger($!)
-    flash[:error] = _('no_default_language_found')
-  end
-
-  def get_clipboard(category = nil)
-    clipboard = (session[:clipboard] ||= {})
-    clipboard[category.to_sym] ||= [] if category
-  end
-
-  def clipboard_empty?(category = nil)
-    return true if session[:clipboard].blank?
-    if category
-      session[:clipboard][category.to_sym].blank?
-    else
-      false
-    end
-  end
-  
-  def trash_empty?(category)
-    category.singularize.classify.constantize.trashed.blank?
-  end
-  
-end

data/app/controllers/attachments_controller.rb

@@ -1,28 +0,0 @@
-class AttachmentsController < AlchemyController
-  
-  # sends file inline. i.e. for viewing pdfs/movies in browser
-  def show
-    @attachment = Attachment.find(params[:id])
-    send_file(
-      @attachment.public_filename,
-      {
-        :name => @attachment.filename,
-        :type => @attachment.content_type,
-        :disposition => 'inline'
-      }
-    )
-  end
-
-  # sends file as attachment. aka download
-  def download
-    @attachment = Attachment.find(params[:id])
-    send_file(
-      @attachment.full_filename, {
-        :name => @attachment.filename,
-        :type => @attachment.content_type,
-        :disposition => 'attachment'
-      }
-    )
-  end
-
-end