browsercmsi 3.1.0

data/app/controllers/cms/content_block_controller.rb

@@ -0,0 +1,289 @@
+# This is not called directly
+# This is the base class for other content blocks
+class Cms::ContentBlockController < Cms::BaseController
+  
+  layout :determine_layout
+  
+  before_filter :set_toolbar_tab
+  
+  helper_method :block_form, :new_block_path, :block_path, :blocks_path, :content_type
+  helper Cms::RenderingHelper
+  # Basic REST Crud Action
+  
+  def index
+    load_blocks
+    render "#{template_directory}/index"
+  end
+  
+  def show
+    load_block_draft
+    render "#{template_directory}/show"
+  end
+  
+  def new
+    build_block
+    set_default_category
+    render "#{template_directory}/new"
+  end
+  
+  def create
+    if create_block
+      after_create_on_success
+    else
+      after_create_on_failure
+    end
+  rescue Exception => @exception
+    raise @exception if @exception.is_a?(Cms::Errors::AccessDenied)
+    after_create_on_error
+  end
+  
+  def edit
+    load_block_draft
+    render "#{template_directory}/edit"
+  end
+  
+  def update
+    if update_block
+      after_update_on_success
+    else
+      after_update_on_failure
+    end
+  rescue ActiveRecord::StaleObjectError => @exception
+    after_update_on_edit_conflict
+  rescue Exception => @exception
+    raise @exception if @exception.is_a?(Cms::Errors::AccessDenied)
+    after_update_on_error
+  end
+  
+  def destroy
+    do_command(I18n.t("controllers.content_block.commands.deleted")) { @block.destroy }
+    redirect_to_first params[:_redirect_to], blocks_path
+  end
+  
+  # Additional CMS Action
+  
+  def publish
+    do_command(I18n.t("controllers.content_block.commands.published")) { @block.publish! }
+    redirect_to_first params[:_redirect_to], block_path
+  end
+  
+  def revert_to
+    do_command(I18n.t("controllers.content_block.commands.reverted", :version => params[:version])) do
+      revert_block(params[:version])
+    end
+    redirect_to_first params[:_redirect_to], block_path
+  end
+  
+  def version
+    load_block
+    if params[:version]
+      @block = @block.as_of_version(params[:version])
+    end
+    render "#{template_directory}/show"
+  end
+  
+  def versions
+    if model_class.versioned?
+      load_block
+      render "#{template_directory}/versions"
+    else
+      render :text => "Not Implemented", :status => :not_implemented
+    end    
+  end
+    
+  def usages
+    load_block_draft
+    @pages = @block.connected_pages.all(:order => 'name')
+    render "#{template_directory}/usages"
+  end
+  
+  protected
+    # methods that are used to detemine what content block type we are dealing with
+
+    def content_type_name
+      self.class.name.sub(/Controller/,'').demodulize.singularize
+    end
+
+    def content_type
+      @content_type ||= ContentType.find_by_key(content_type_name)
+    end  
+
+    def model_class
+      content_type.model_class
+    end
+  
+    def model_name
+      model_class.name.underscore.to_sym
+    end
+  
+    # methods for loading one or a collection of blocks
+  
+    def load_blocks
+      options = {}
+      if params[:section_id] && params[:section_id] != 'all'
+        options[:include] = { :attachment => { :section_node => :section }} 
+        options[:conditions] = ["sections.id = ?", params[:section_id]]
+      end
+      options[:page] = params[:page]    
+      options[:order] = model_class.default_order if model_class.respond_to?(:default_order)
+      options[:order] = params[:order] unless params[:order].blank?
+      scope = model_class.respond_to?(:list) ? model_class.list : model_class
+      @blocks = scope.searchable? ? scope.search(params[:search]).paginate(options) : scope.paginate(options)
+      check_permissions
+    end
+  
+    def load_block
+      @block = model_class.find(params[:id])
+      check_permissions
+    end
+  
+    def load_block_draft
+      @block = model_class.find(params[:id])
+      @block = @block.as_of_draft_version if model_class.versioned?
+      check_permissions
+    end
+  
+    # path related methods - available in the view as helpers
+  
+    def new_block_path(options={})
+      cms_new_url_for(@block, options)
+    end
+  
+    def block_path(action=nil)
+      path = [:cms, @block]
+      action ? path.unshift(action) : path
+    end
+  
+    def blocks_path(options={})
+      cms_index_url_for(@block, options)
+    end
+
+    # This is the partial that will be used in the form
+    def block_form
+      @content_type.form
+    end
+  
+    # new related methods
+  
+    def build_block
+      @block = model_class.new(params[model_name])
+      check_permissions
+    end
+
+    def set_default_category
+      if @last_block = model_class.last
+        @block.category = @last_block.category if @block.respond_to?(:category=)
+      end      
+    end
+    
+    # create related methods
+    
+    def create_block
+      build_block
+      @block.save
+    end
+
+    def after_create_on_success
+      block = @block.class.versioned? ? @block.draft : @block
+      flash[:notice] = I18n.t("controllers.content_block.created", :content_type => content_type.display_name, :block_name => block.name)
+      if @block.class.connectable? && @block.connected_page
+        redirect_to @block.connected_page.path
+      else
+        redirect_to_first params[:_redirect_to], block_path
+      end
+    end
+
+    def after_create_on_failure
+      render "#{template_directory}/new"
+    end
+
+    def after_create_on_error
+      logger.error "#{@exception.message}\n#{@exception.backtrace.join('\n')}"      
+      after_create_on_failure
+    end
+
+    # update related methods
+    def update_block
+      load_block
+      @block.update_attributes(params[model_name])
+    end
+
+    def after_update_on_success
+      flash[:notice] = I18n.t("controllers.content_block.updated", :content_type => content_type_name.titleize, :block_name => @block.name)
+      redirect_to_first params[:_redirect_to], block_path
+    end
+
+    def after_update_on_failure
+      render "#{template_directory}/edit"
+    end
+
+    def after_update_on_edit_conflict
+      @other_version = @block.class.find(@block.id)
+      after_update_on_failure
+    end
+
+    def after_update_on_error
+      logger.error "#{@exception.message}\n#{@exception.backtrace.join('\n')}"
+      after_update_on_failure
+    end
+
+    # methods for other actions
+
+    # A "command" is when you want to perform an action on a content block
+    # You pass a ruby block to this method, this calls it
+    # and then sets a flash message based on success or failure
+    def do_command(result)
+      load_block
+      if yield
+        flash[:notice] = I18n.t("controllers.content_block.commands.command_success", :content_type_name => content_type_name.titleize, 
+                                                                                      :block_name => @block.name, 
+                                                                                      :result => result)
+      else
+        flash[:error] = I18n.t("controllers.content_block.commands.command_failure", :content_type_name => content_type_name.titleize, 
+                                                                                      :block_name => @block.name, 
+                                                                                      :result => result)
+      end
+    end
+
+    def revert_block(to_version)
+      begin
+        @block.revert_to(to_version)
+      rescue Exception => @exception
+        logger.warn "Could not revert #{@block.inspect} to version #{to_version}"
+        logger.warn "#{@exception.message}\n:#{@exception.backtrace.join("\n")}"
+        false
+      end
+    end
+    
+    # Use a "whitelist" approach to access to avoid mistakes
+    # By default everyone can create new block and view them and their properties,
+    # but blocks can only be modified based on the permissions of the pages they
+    # are connected to.
+    def check_permissions
+      case action_name
+        when "index", "show", "new", "create", "version", "versions", "usages"
+          # Allow
+        when "edit", "update"
+          raise Cms::Errors::AccessDenied unless current_user.able_to_edit?(@block)
+        when "destroy", "publish", "revert_to"
+          raise Cms::Errors::AccessDenied unless current_user.able_to_publish?(@block)
+        else
+          raise Cms::Errors::AccessDenied
+      end
+    end
+
+    # methods to setup the view
+
+    def set_toolbar_tab
+      @toolbar_tab = :content_library
+    end
+
+    def determine_layout
+      'cms/content_library'
+    end
+
+    def template_directory
+      "cms/blocks"
+    end
+
+end

data/app/controllers/cms/content_controller.rb

@@ -0,0 +1,176 @@
+class Cms::ContentController < Cms::ApplicationController
+  include Cms::ContentRenderingSupport
+
+  skip_before_filter :redirect_to_cms_site
+  before_filter :redirect_non_cms_users_to_public_site, :only => [:show, :show_page_route]
+  before_filter :construct_path,                        :only => [:show]
+  before_filter :construct_path_from_route,             :only => [:show_page_route]
+  before_filter :try_to_redirect,                       :only => [:show]
+  before_filter :try_to_stream_file,                    :only => [:show]
+  before_filter :check_access_to_page,                  :only => [:show, :show_page_route]
+
+
+  
+  # ----- Actions --------------------------------------------------------------
+  def show
+    render_page_with_caching
+  end
+
+  def show_page_route
+    render_page_with_caching
+  end
+
+
+  # Used by the rendering behavior
+  def instance_variables_for_rendering
+    instance_variables - (@initial_ivars || []) - ["@initial_ivars"]
+  end
+
+  protected
+
+  # This will assign the value to an instance variable
+  def assign(key, value)
+    instance_variable_set("@#{key}", value)
+  end
+
+  private
+  
+  # This is the method all actions delegate to
+  # check_access_to_page will also call this directly
+  # if caching is not enabled
+  def render_page
+    @_page_route.execute(self) if @_page_route
+    prepare_connectables_for_render 
+    render :layout => @page.layout, :action => 'show'
+  end
+  
+  def render_page_with_caching
+    render_page
+    cache_page if perform_caching
+  end
+  
+  # ----- Before Filters -------------------------------------------------------
+  def construct_path
+    @paths = params[:page_path] || params[:path] || []
+    @path = "/#{@paths.join("/")}"
+  end
+  
+  def construct_path_from_route
+    @_page_route = PageRoute.find(params[:_page_route_id])
+    @path = @_page_route.page.path
+    @initial_ivars = instance_variables
+    eval @_page_route.code
+  end
+  
+  def redirect_non_cms_users_to_public_site
+    @show_toolbar = false
+    if perform_caching
+      logger.info "Caching is enabled"
+      if cms_site?
+        logger.info "This is the cms site"
+        if current_user.able_to?(:edit_content, :publish_content, :administrate)
+          logger.info "User has access to cms"
+          @show_toolbar = true
+        else
+          logger.info "User does not have access to cms"
+          redirect_to url_without_cms_domain_prefix
+        end
+      else
+        logger.info "Not the cms site"
+      end
+    else
+      logger.info "Caching is disabled"
+      if current_user.able_to?(:edit_content, :publish_content, :administrate)
+        @show_toolbar = true
+      end
+    end
+    @show_page_toolbar = @show_toolbar
+    true
+  end
+  
+  def try_to_redirect
+    if redirect = Redirect.find_by_from_path(@path)
+      redirect_to redirect.to_path
+    end    
+  end
+
+  def try_to_stream_file
+    split = @paths.last.to_s.split('.')
+    ext = split.size > 1 ? split.last.to_s.downcase : nil
+    
+    #Only try to stream cache file if it has an extension
+    unless ext.blank?
+      
+      #Check access to file
+      @attachment = Attachment.find_live_by_file_path(@path)
+      if @attachment
+        raise Cms::Errors::AccessDenied unless current_user.able_to_view?(@attachment)
+
+        #Construct a path to where this file would be if it were cached
+        @file = @attachment.full_file_location
+
+        #Stream the file if it exists
+        if @path != "/" && File.exists?(@file)
+          send_file(@file, 
+            :filename => @attachment.file_name,
+            :type => @attachment.file_type,
+            :disposition => "inline"
+          ) 
+        end    
+      end
+    end
+    
+  end
+
+  def check_access_to_page
+    set_page_mode
+    if current_user.able_to?(:edit_content, :publish_content, :administrate)
+      logger.info "..... Displaying draft version of page"
+      if page = Page.first(:conditions => {:path => @path})
+        @page = page.as_of_draft_version
+      else
+        return render(:layout => 'cms/application', 
+          :template => 'cms/content/no_page', 
+          :status => :not_found)
+      end
+    else
+      logger.info "..... Displaying live version of page"
+      @page = Page.find_live_by_path(@path)
+      page_not_found unless (@page && !@page.archived?)
+    end
+
+    unless current_user.able_to_view?(@page)
+      store_location
+      raise Cms::Errors::AccessDenied
+    end
+
+    # Doing this so if you are logged in, you never see the cached page
+    # We are calling render_page just like the show action does
+    # But since we do it from a before filter, the page doesn't get cached
+    if logged_in?
+      logger.info "Not Caching, user is logged in"
+      render_page
+    elsif !@page.cacheable?
+      logger.info "Not Caching, page cachable is false"
+      render_page
+    elsif params[:cms_cache] == "false"
+      logger.info "Not Caching, cms_cache is false"
+      render_page
+    end
+
+  end
+    
+  # ----- Other Methods --------------------------------------------------------
+  
+  def page_not_found
+    raise ActiveRecord::RecordNotFound.new("No page at '#{@path}'")
+  end
+
+  def set_page_mode
+    @mode = @show_toolbar && current_user.able_to?(:edit_content) ? (params[:mode] || session[:page_mode] || "edit") : "view"
+    session[:page_mode] = @mode      
+  end
+  
+  
+  
+end

data/app/controllers/cms/content_types_controller.rb

@@ -0,0 +1,7 @@
+class Cms::ContentTypesController < Cms::BaseController
+
+  def index
+    @content_types = ContentType.find(:all, :order => 'name')
+  end
+  
+end

data/app/controllers/cms/dashboard_controller.rb

@@ -0,0 +1,10 @@
+class Cms::DashboardController < Cms::BaseController
+      
+  def index
+    @unpublished_pages = Page.unpublished.all(:order => "pages.updated_at desc")
+    @unpublished_pages = @unpublished_pages.select { |page| current_user.able_to_publish?(page) }
+    @incomplete_tasks = current_user.tasks.incomplete.all(
+      :include => :page, 
+      :order => "tasks.due_date desc, pages.name")
+  end
+end

data/app/controllers/cms/dynamic_views_controller.rb

@@ -0,0 +1,65 @@
+class Cms::DynamicViewsController < Cms::BaseController
+  
+  layout 'cms/administration'
+  check_permissions :administrate  
+  
+  before_filter :set_menu_section
+  before_filter :load_view, :only => [:show, :edit, :update, :destroy]
+    
+  helper_method :dynamic_view_type
+  
+  def index
+    @views = dynamic_view_type.paginate(:page => params[:page], :order => "name")
+  end
+  
+  def new
+    @view = dynamic_view_type.new_with_defaults
+  end
+  
+  def create
+    @view = dynamic_view_type.new(params[dynamic_view_type.name.underscore])
+    if @view.save
+      flash[:notice] = I18n.t("controllers.dynamic_view.created", :dynamic_view_type => dynamic_view_type, :name => @view.name)
+      redirect_to cms_index_path_for(dynamic_view_type.name.underscore.pluralize)
+    else
+      render :action => "new"
+    end
+  end
+  
+  def show
+    redirect_to [:edit, :cms, @view]
+  end
+  
+  def update
+    if @view.update_attributes(params[dynamic_view_type.name.underscore])
+      flash[:notice] = I18n.t("controllers.dynamic_view.updated", :dynamic_view_type => dynamic_view_type, :name => @view.name)
+      redirect_to cms_index_path_for(dynamic_view_type.name.underscore.pluralize)
+    else
+      render :action => "edit"
+    end
+  end
+  
+  def destroy
+    @view.destroy
+    flash[:notice] = I18n.t("controllers.dynamic_view.deleted", :dynamic_view_type => dynamic_view_type, :name => @view.name)
+    redirect_to cms_index_path_for(dynamic_view_type.name.underscore.pluralize)    
+  end
+  
+  protected
+    def dynamic_view_type
+      @dynamic_view_type ||= begin
+        type = request.request_uri.split('/')[2].classify.constantize
+        raise "Invalid Type" unless type.ancestors.include?(DynamicView)
+        type
+      end
+    end
+  
+    def set_menu_section
+      @menu_section = dynamic_view_type.name.underscore.pluralize
+    end  
+    
+    def load_view
+      @view = dynamic_view_type.find(params[:id])
+    end
+  
+end

data/app/controllers/cms/email_messages_controller.rb

@@ -0,0 +1,14 @@
+class Cms::EmailMessagesController < Cms::BaseController
+  layout 'cms/administration'
+  
+  check_permissions :administrate
+  
+  def index
+    @messages = EmailMessage.paginate(:page => params[:page])
+  end
+  
+  def show
+    @message = EmailMessage.find(params[:id])
+  end
+  
+end

data/app/controllers/cms/error_handling.rb

@@ -0,0 +1,25 @@
+module Cms
+  module ErrorHandling
+    def self.included(controller)
+      controller.class_eval do
+        rescue_from Exception, :with => :handle_server_error unless RAILS_ENV == "test"
+        rescue_from Cms::Errors::AccessDenied, :with => :handle_access_denied
+      end
+    end
+    
+    def handle_server_error(exception)
+      logger.error "Handling Exception: #{exception}"
+      render :layout => 'cms/application', 
+        :template => 'cms/shared/error', 
+        :status => :internal_server_error,
+        :locals => {:exception => exception}
+    end
+    
+    def handle_access_denied(exception)
+      render :layout   => 'cms/application', 
+             :template => 'cms/shared/access_denied',
+             :status => 403
+    end
+
+  end
+end

data/app/controllers/cms/file_blocks_controller.rb

@@ -0,0 +1,2 @@
+class Cms::FileBlocksController < Cms::ContentBlockController
+end

data/app/controllers/cms/groups_controller.rb

@@ -0,0 +1,26 @@
+class Cms::GroupsController < Cms::ResourceController
+  layout 'cms/administration'
+  
+  check_permissions :administrate
+  before_filter :set_menu_section
+  
+  def index
+    @groups = Group.paginate(
+      :include => :group_type,
+      :page => params[:page], 
+      :order => params[:order] || "groups.name")
+  end
+  
+  protected
+    def after_create_url
+      index_url
+    end
+    def after_update_url
+      index_url
+    end
+
+    def set_menu_section
+      @menu_section = 'groups'
+    end
+    
+end

data/app/controllers/cms/home_controller.rb

@@ -0,0 +1,5 @@
+class Cms::HomeController < Cms::BaseController
+  def index
+    redirect_to '/'
+  end
+end

data/app/controllers/cms/html_blocks_controller.rb

@@ -0,0 +1,2 @@
+class Cms::HtmlBlocksController < Cms::ContentBlockController
+end

data/app/controllers/cms/image_blocks_controller.rb

@@ -0,0 +1,2 @@
+class Cms::ImageBlocksController < Cms::ContentBlockController
+end

data/app/controllers/cms/links_controller.rb

@@ -0,0 +1,66 @@
+class Cms::LinksController < Cms::BaseController
+
+  before_filter :set_toolbar_tab
+  before_filter :load_section, :only => [:new, :create, :move_to]
+  before_filter :load_link, :only => [:destroy, :update]
+  before_filter :load_draft_link, :only => [:edit]
+  
+  def new
+    @link = Link.new(:section => @section)
+  end
+
+  def create
+    @link = Link.new(params[:link])
+    @link.section = @section
+    if @link.save
+      flash[:notice] = I18n.t("controllers.links.created", :name => @link.name)
+      redirect_to [:cms, @section]
+    else
+      render :action => "new"
+    end
+  end
+  
+  def update
+    if @link.update_attributes(params[:link])
+      flash[:notice] = I18n.t("controllers.links.updated", :name => @link.name)
+      redirect_to [:cms, @link.section]
+    else
+      render :action => 'edit'
+    end      
+  end
+  
+  def destroy
+    respond_to do |format|
+      if @link.destroy
+        message = I18n.t("controllers.links.deleted", :name => @link.name)
+        format.html { flash[:notice] = message; redirect_to(cms_sitemap_url) }
+        format.json { render :json => {:success => true, :message => message } }
+      else
+        message = I18n.t("controllers.links.failed_delete", :name => @link.name)
+        format.html { flash[:error] = message; redirect_to(cms_sitemap_url) }
+        format.json { render :json => {:success => false, :message => message } }
+      end
+    end    
+  end
+
+  protected
+
+    def load_section
+      @section = Section.find(params[:section_id])
+      raise Cms::Errors::AccessDenied unless current_user.able_to_edit?(@section)
+    end
+
+    def load_link
+      @link = Link.find(params[:id])
+      raise Cms::Errors::AccessDenied unless current_user.able_to_edit?(@link)
+    end
+    
+    def load_draft_link
+      load_link
+      @link = @link.as_of_draft_version
+    end
+
+    def set_toolbar_tab
+      @toolbar_tab = :sitemap
+    end
+end