nate-browsercms 3.0.210

data/app/controllers/cms/content_block_controller.rb

@@ -0,0 +1,256 @@
+# 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
+  
+  # Basic REST Crud Action
+  
+  def index
+    load_blocks
+    render "#{template_directory}/index"
+  end
+  
+  def show
+    load_block
+    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
+    after_create_on_error
+  end
+  
+  def edit
+    load_block
+    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
+    after_update_on_error
+  end
+  
+  def destroy
+    do_command("deleted") { @block.destroy }
+    redirect_to_first params[:_redirect_to], blocks_path
+  end
+  
+  # Additional CMS Action
+  
+  def publish
+    do_command("published") { @block.publish! }
+    redirect_to_first params[:_redirect_to], block_path
+  end
+  
+  def revert_to
+    do_command("reverted to 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
+    @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)
+    end
+  
+    def load_block
+      @block = model_class.find(params[:id])
+    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])
+    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
+      flash[:notice] = "#{content_type.display_name} '#{@block.name}' was created"
+      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] = "#{content_type_name.titleize} '#{@block.name}' was updated"
+      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] = "#{content_type_name.titleize} '#{@block.name}' was #{result}"
+      else
+        flash[:error] = "#{content_type_name.titleize} '#{@block.name}' could not be #{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
+
+    # 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,211 @@
+class Cms::ContentController < Cms::ApplicationController
+
+  rescue_from Exception, :with => :handle_server_error_on_page
+  rescue_from Cms::Errors::AccessDenied, :with => :handle_access_denied_on_page
+  rescue_from ActiveRecord::RecordNotFound, :with => :handle_not_found_on_page
+
+  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
+
+  # ----- Error Handlers -------------------------------------------------------
+  
+  def handle_not_found_on_page(exception)
+    logger.warn "Page Not Found"
+    handle_error_with_cms_page('/system/not_found', exception, :not_found)
+  end
+
+  def handle_access_denied_on_page(exception)
+    logger.warn "Access Denied"
+    handle_error_with_cms_page('/system/access_denied', exception, :forbidden)
+  end
+
+  def handle_server_error_on_page(exception)
+    logger.warn "Exception: #{exception.message}\n"
+    logger.warn "#{exception.backtrace.join("\n")}\n"
+    handle_error_with_cms_page('/system/server_error', exception, :internal_server_error)
+  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
+    render :layout => @page.layout, :action => 'show'
+  end
+  
+  def render_page_with_caching
+    render_page
+    cache_page if perform_caching
+  end
+  
+  # This is the method all error handlers delegate to
+  def handle_error_with_cms_page(error_page_path, exception, status, options={})
+
+    # If we are in the CMS, we just want to show the exception
+    if perform_caching
+      return handle_server_error(exception) if cms_site?
+    else
+      return handle_server_error(exception) if current_user.able_to?(:edit_content, :publish_content)
+    end
+    
+    # We must be showing the page outside of the CMS
+    # So we will show the error page
+    if @page = Page.find_live_by_path(error_page_path)
+      logger.info "Rendering Error Page: #{@page.inspect}"
+      @mode = "view"
+      @show_page_toolbar = false
+      
+      # copy new instance variables to the template
+      %w[page mode show_page_toolbar].each do |v|
+        @template.instance_variable_set("@#{v}", instance_variable_get("@#{v}"))
+      end
+      
+      # clear out any content already captured 
+      # by previous attempts to render the page within this request
+      @template.instance_variables.select{|v| v =~ /@content_for_/ }.each do |v|
+        @template.instance_variable_set("#{v}", nil)
+      end
+      
+      render :layout => @page.layout, :template => 'cms/content/show', :status => status
+    else
+      handle_server_error(exception)
+    end      
+  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
+  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)
+          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)
+        @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)
+      @page = Page.first(:conditions => {:path => @path})
+      page_not_found unless @page
+    else
+      @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,9 @@
+class Cms::DashboardController < Cms::BaseController
+      
+  def index
+    @unpublished_pages = Page.unpublished.all(:order => "updated_at desc")
+    @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] = "#{dynamic_view_type} '#{@view.name}' was created"
+      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] = "#{dynamic_view_type} '#{@view.name}' was updated"
+      redirect_to cms_index_path_for(dynamic_view_type.name.underscore.pluralize)
+    else
+      render :action => "edit"
+    end
+  end
+  
+  def destroy
+    @view.destroy
+    flash[:notice] = "#{dynamic_view_type} '#{@view.name}' was deleted"
+    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/email_page_portlet_controller.rb

@@ -0,0 +1,14 @@
+class Cms::EmailPagePortletController < Cms::PortletController
+  
+  def deliver
+    message = EmailMessage.new(params[:email_message])
+    message.subject = @portlet.subject
+    message.body = "#{params[:url]}\n\n#{message.body}"
+    if message.save
+      redirect_to_success_url
+    else
+      redirect_to_failure_url_with_errors(message.errors)
+    end
+  end
+  
+end

data/app/controllers/cms/error_handling.rb

@@ -0,0 +1,18 @@
+module Cms
+  module ErrorHandling
+    def self.included(controller)
+      controller.class_eval do
+          rescue_from Exception, :with => :handle_server_error
+      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
+
+  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,59 @@
+class Cms::LinksController < Cms::BaseController
+
+  before_filter :set_toolbar_tab
+  before_filter :load_section, :only => [:new, :create, :move_to]
+  before_filter :load_link, :only => [:edit, :update, :destroy]
+  
+  def new
+    @link = Link.new(:section => @section)
+  end
+
+  def create
+    @link = Link.new(params[:link])
+    @link.section = @section
+    if @link.save
+      flash[:notice] = "Link was '#{@link.name}' created."
+      redirect_to [:cms, @section]
+    else
+      render :action => "new"
+    end
+  end
+  
+  def update
+    if @link.update_attributes(params[:link])
+      flash[:notice] = "Link '#{@link.name}' was updated"
+      redirect_to [:cms, @link.section]
+    else
+      render :action => 'edit'
+    end      
+  end
+  
+  def destroy
+    respond_to do |format|
+      if @link.destroy
+        message = "Link '#{@link.name}' was deleted."
+        format.html { flash[:notice] = message; redirect_to(cms_sitemap_url) }
+        format.json { render :json => {:success => true, :message => message } }
+      else
+        message = "Link '#{@link.name}' could not be deleted"
+        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])
+    end
+
+    def load_link
+      @link = Link.find(params[:id])
+    end
+
+    def set_toolbar_tab
+      @toolbar_tab = :sitemap
+    end
+
+end