browsercms 3.5.7 → 4.0.0.alpha

data/app/controllers/cms/content_controller.rb

@@ -1,5 +1,7 @@
 module Cms
   class ContentController < Cms::ApplicationController
+    respond_to :html
+
     include Cms::ContentRenderingSupport
     include Cms::Attachments::Serving
 
@@ -12,19 +14,42 @@ module Cms
     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]
+    before_filter :load_page, :only => [:show, :show_page_route]
+    before_filter :check_access_to_page, :except => [:edit, :preview]
     before_filter :select_cache_directory
 
+    self.responder = Cms::ContentResponder
 
     # ----- Actions --------------------------------------------------------------
     def show
-      render_page_with_caching
+      if @show_toolbar
+        render_editing_frame
+      else
+        render_page
+      end
+      cache_if_eligible
     end
 
     def show_page_route
-      render_page_with_caching
+      @_page_route.execute(self) if @_page_route
+      render_page
+      cache_if_eligible
+    end
+
+    # Used in the iframe to display a page that's being editted.
+    def edit
+      @show_toolbar = true
+      @mode = "edit"
+      @page = Page.find_draft(params[:id].to_i)
+      render_page
     end
 
+    def preview
+      @mode = "view"
+      @page = Page.find_draft(params[:id].to_i)
+      ensure_current_user_can_view(@page)
+      render_page
+    end
 
     # Used by the rendering behavior
     def instance_variables_for_rendering
@@ -40,25 +65,35 @@ module Cms
 
     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_editing_frame
+      @page_title = @page.page_title
+      render 'editing_frame', :layout => 'cms/page_editor'
+    end
+
     def render_page
-      logger.warn "Render page (id: #{@page.id})"
-      @_page_route.execute(self) if @_page_route
       prepare_connectables_for_render
-      page_layout = determine_page_layout
-      render :layout => page_layout, :action => 'show'
+      prepend_view_path DynamicView.resolver
+      respond_with @page, determine_page_layout
     end
 
-    def render_page_with_caching
-      render_page
-      cache_page if should_write_to_page_cache?
+    def cache_if_eligible
+      cache_page if should_cache_page?
+    end
+
+    # Determine if this page is eligible for caching or not.
+    def should_cache_page?
+      should_cache = (using_cms_subdomains? && !logged_in? && @page.cacheable? && params[:cms_cache] != "false")
+      if should_cache
+        msg = "'#{request.path}' being written to cache."
+      else
+        msg = "'#{request.path}' not eligible for caching."
+      end
+      logger.info msg
+      should_cache
     end
 
     # ----- Before Filters -------------------------------------------------------
     def construct_path
-      # @paths = params[:cms_page_path] || params[:path] || []
       @path = "/#{params[:path]}"
       @paths = @path.split("/")
     end
@@ -118,55 +153,18 @@ module Cms
 
     end
 
-    def check_access_to_page
-      set_page_mode
+    def load_page
       if current_user.able_to?(:edit_content, :publish_content, :administrate)
         logger.debug "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
+        @page = Page.find_draft(@path)
       else
         logger.debug "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
+        @page = Page.find_live(@path)
       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
+    def check_access_to_page
+      ensure_current_user_can_view(@page)
     end
-
-
   end
 end

data/app/controllers/cms/dashboard_controller.rb

@@ -1,14 +1,13 @@
 module Cms
   class DashboardController < Cms::BaseController
 
-    layout 'cms/dashboard'
-
     def index
-      @unpublished_pages = Page.unpublished.all(:order => "updated_at desc")
+      @unpublished_pages = Page.unpublished.order("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 => "#{Task.table_name}.due_date desc, #{Page.table_name}.name")
+      @incomplete_tasks = current_user.tasks.incomplete.
+          includes(:page).
+          order("#{Task.table_name}.due_date desc, #{Page.table_name}.name").
+          references(:page)
     end
   end
 end

data/app/controllers/cms/dynamic_views_controller.rb

@@ -1,16 +1,15 @@
 module Cms
   class DynamicViewsController < Cms::BaseController
 
-    layout 'cms/administration'
+    include Cms::AdminTab
     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")
+      @views = dynamic_view_type.paginate(:page => params[:page]).order("name")
     end
 
     def new
@@ -18,10 +17,10 @@ module Cms
     end
 
     def create
-      @view = dynamic_view_type.new(params[view_param_name])
+      @view = dynamic_view_type.new(dynamic_view_params)
       if @view.save
         flash[:notice] = "#{dynamic_view_type} '#{@view.name}' was created"
-        redirect_to cms_index_path_for(dynamic_view_type)
+        redirect_to engine_aware_path(dynamic_view_type)
       else
         render :action => "new"
       end
@@ -32,9 +31,9 @@ module Cms
     end
 
     def update
-      if @view.update_attributes(params[view_param_name])
+      if @view.update(dynamic_view_params)
         flash[:notice] = "#{dynamic_view_type} '#{@view.name}' was updated"
-        redirect_to cms_index_path_for(dynamic_view_type)
+        redirect_to engine_aware_path(dynamic_view_type)
       else
         render :action => "edit"
       end
@@ -43,13 +42,17 @@ module Cms
     def destroy
       @view.destroy
       flash[:notice] = "#{dynamic_view_type} '#{@view.name}' was deleted"
-      redirect_to cms_index_path_for(dynamic_view_type)
+      redirect_to engine_aware_path(dynamic_view_type)
     end
 
     protected
 
+    def dynamic_view_params
+      params.require(view_param_name).permit(dynamic_view_type.permitted_params)
+    end
+
     def view_param_name
-      dynamic_view_type.resource_collection_name
+      dynamic_view_type.model_name.param_key
     end
 
     def dynamic_view_type

data/app/controllers/cms/email_messages_controller.rb

@@ -1,16 +1,21 @@
 module Cms
-class EmailMessagesController < Cms::BaseController
-  layout 'cms/administration'
-  
-  check_permissions :administrate
-  
-  def index
-    @messages = EmailMessage.paginate(:page => params[:page])
+  class EmailMessagesController < Cms::BaseController
+
+    include Cms::AdminTab
+
+    check_permissions :administrate
+
+    def index
+      @messages = EmailMessage.paginate(:page => params[:page])
+    end
+
+    def show
+      @message = EmailMessage.find(params[:id])
+    end
+
+    private
+    def set_menu_section
+      @menu_section = 'email_messages'
+    end
   end
-  
-  def show
-    @message = EmailMessage.find(params[:id])
-  end
-  
-end
 end

data/app/controllers/cms/form_entries_controller.rb

@@ -0,0 +1,119 @@
+module Cms
+  class FormEntriesController < Cms::BaseController
+
+    include ContentRenderingSupport
+
+    helper_method :content_type
+    helper Cms::ContentBlockHelper
+
+    allow_guests_to [:submit]
+
+    # Handles public submission of a form.
+    def submit
+      find_form_and_populate_entry
+      if @entry.save
+        if @form.show_text?
+          show_content_as_page(@form)
+          render layout: Cms::Form.layout
+        else
+          redirect_to @form.confirmation_redirect
+        end
+        unless @form.notification_email.blank?
+          Cms::EmailMessage.create!(
+              :recipients => @form.notification_email,
+              :subject => "[CMS Form] A new entry has been created",
+              :body => "A visitor has filled out the #{@form.name} form. The entry can be found here:
+              #{Cms::EmailMessage.absolute_cms_url(cms.form_entry_path(@entry)) }"
+          )
+        end
+      else
+        show_content_as_page(@form)
+        render 'error', layout: Cms::Form.layout
+      end
+    end
+
+    # Same behavior as ContentBlockController#index
+    def index
+      form = Cms::Form.where(id: params[:id]).first
+      @blocks = Cms::FormEntry.where(form_id: params[:id]).paginate({page: params[:page], order: params[:order]})
+      @entry = Cms::FormEntry.for(form)
+
+      # Allows us to use the content_block/index view
+      @content_type = FauxContentType.new(form)
+      @search_filter = SearchFilter.build(params[:search_filter], Cms::FormEntry)
+      @total_number_of_items = @blocks.size
+    end
+
+    def edit
+      @entry = Cms::FormEntry.find(params[:id])
+    end
+
+    def update
+      @entry = Cms::FormEntry.find(params[:id]).enable_validations
+      if @entry.update(entry_params(@entry))
+        redirect_to form_entry_path(@entry)
+      else
+        render :edit
+      end
+    end
+
+    def show
+      @entry = Cms::FormEntry.find(params[:id])
+    end
+
+    def new
+      @entry = Cms::FormEntry.for(Form.find(params[:form_id]))
+    end
+
+    def create
+      find_form_and_populate_entry
+      if @entry.save
+        redirect_to entries_path(@form)
+      else
+        save_entry_failure
+      end
+    end
+
+    def save_entry_failure
+      render :new
+    end
+
+    protected
+
+    def find_form_and_populate_entry
+      @form = Cms::Form.find(params[:form_id])
+      @entry = Cms::FormEntry.for(@form)
+      @entry.attributes = entry_params(@entry)
+    end
+
+    def entry_params(entry)
+      params.require(:form_entry).permit(entry.permitted_params)
+    end
+
+    # Allows Entries to be displayed using same view as Content Blocks.
+    class FauxContentType < Cms::ContentType
+      def initialize(form)
+        @form = form
+        self.name = 'Cms::FormEntry'
+      end
+
+      def display_name
+        'Entry'
+      end
+
+      def display_name_plural
+        "Entries for #{@form.name} form"
+      end
+      def columns_for_index
+        cols = @form.fields.collect do |field|
+          {:label => field.label, :method => field.name}
+        end
+        cols
+      end
+    end
+
+    def content_type
+      @content_type
+    end
+  end
+end

data/app/controllers/cms/form_fields_controller.rb

@@ -0,0 +1,74 @@
+module Cms
+  class FormFieldsController < Cms::BaseController
+
+    layout false
+
+    def new
+      @field = Cms::FormField.new(label: 'Untitled', field_type: params[:field_type], form_id: params[:form_id])
+    end
+
+    def preview
+      @form = Cms::Form.find(params[:id])
+      @field = Cms::FormField.new(label: 'Untitled', name: :untitled, field_type: params[:field_type], form: @form)
+    end
+
+    def create
+      form = Cms::Form.find(params[:form_field].delete(:form_id))
+      field = FormField.new(form_field_params)
+      field.form = form
+      if field.save
+        include_edit_path_in_json(field)
+        include_delete_path_in_json(field)
+        render json: field
+      else
+        render json: {
+            errors: field.errors.full_messages
+        },
+               success: false,
+               status: :unprocessable_entity
+      end
+    end
+
+    def edit
+      @field = FormField.find(params[:id])
+      render :new
+    end
+
+    def update
+      field = FormField.find(params[:id])
+      if field.update form_field_params
+        include_edit_path_in_json(field)
+        render json: field
+      else
+        render text: "Fail", status: 500
+      end
+    end
+
+    def destroy
+      field = FormField.find(params[:id])
+      field.destroy
+      render json: field, success: true
+    end
+
+    def insert_at
+      field = FormField.find(params[:id])
+      field.insert_at(params[:position])
+      render json: field
+    end
+
+    protected
+
+    # For UI to update for subsequent editing.
+    def include_edit_path_in_json(field)
+      field.edit_path = cms.edit_form_field_path(field)
+    end
+
+    def include_delete_path_in_json(field)
+      field.delete_path = cms.form_field_path(field)
+    end
+
+    def form_field_params()
+      params.require(:form_field).permit(FormField.permitted_params)
+    end
+  end
+end