pages_controller.rb in georgia-0.8.0

- old
+ new

@@ -1,36 +1,52 @@
 module Georgia
   class PagesController < ApplicationController
 
     include Georgia::Concerns::Helpers
 
-    # load_and_authorize_resource class: Georgia::Page
-
     before_filter :prepare_new_page, only: [:search]
     before_filter :prepare_page, only: [:show, :edit, :settings, :update, :copy, :preview, :draft]
 
     def show
-      redirect_to [:edit, @page]
+      if @page
+        authorize @page
+        redirect_to edit_page_revision_path(@page, @page.current_revision)
+      else
+        authorize Georgia::Page
+        redirect_to [:search, model], alert: "This #{instance_name} has been deleted."
+      end
     end
 
     # Edit current revision
     def edit
-      redirect_to [:edit, @page, @page.current_revision]
+      if @page and @page.current_revision
+        authorize @page
+        redirect_to edit_page_revision_path(@page, @page.current_revision)
+      else
+        authorize Georgia::Page
+        redirect_to [:search, model], alert: "This #{instance_name} has been deleted."
+      end
     end
 
     # Edit current page
     def settings
+      authorize @page
+      @revision = @page.current_revision
+      @activities = @page.activities.order(created_at: :desc)
+      @awaiting_revisions = @page.revisions.where(status: Georgia::Revision.statuses[:review])
     end
 
     # Create page, load first current revision and js redirect to revisions#edit
     def create
       @page = model.new(slug: params[:title].try(:parameterize))
+      authorize @page
       if @page.save
-        @page.revisions.create(template: Georgia.templates.first) do |rev|
+        @page.revisions.create(template: Georgia.templates.first, revised_by_id: current_user.id, status: :published) do |rev|
           rev.contents << Georgia::Content.new(locale: I18n.default_locale, title: params[:title])
         end
         @page.update_attribute(:current_revision, @page.revisions.first)
+        CreateActivity.new(@page, :create, owner: current_user).call
         respond_to do |format|
           format.html { redirect_to edit_page_revision_path(@page, @page.current_revision), notice: "#{@page.title} was successfully created." }
           format.js { render layout: false }
         end
       else
@@ -41,96 +57,77 @@
       end
     end
 
     # Update page settings
     def update
-      Georgia::Page.update_tree(params[:page_tree]) if params[:page_tree]
-      if @page.update_attributes(params[:page])
+      authorize @page
+      model.update_tree(params[:page_tree]) if params[:page_tree]
+      if @page.update(sanitized_params)
+        CreateActivity.new(@page, :update, owner: current_user).call
         respond_to do |format|
-          format.html { render :settings, notice: "#{@page.title} was successfully updated." }
+          format.html { redirect_to [:settings, @page], notice: "#{@page.title} was successfully updated." }
           format.js { head :ok }
         end
       else
         respond_to do |format|
-          format.html { redirect_to [:settings, @page], notice: "Oups. Something went wrong." }
+          format.html { redirect_to [:settings, @page], alert: "Oups. Something went wrong." }
           format.js { head :internal_server_error }
         end
       end
     end
 
     # Creates a copy of a page and redirects to its revisions#edit
     def copy
-      @copy = @page.copy
-      redirect_to edit_page_revision_path(@copy, @copy.current_revision), notice: "Do not forget to change your url"
+      authorize @page
+      if @copy = CopyPage.new(@page.model).call
+        CreateActivity.new(@page, :copy, owner: current_user).call
+        redirect_to edit_page_revision_path(@copy, @copy.current_revision), notice: "#{instance_name.humanize} successfully copied. Do not forget to change your url"
+      else
+        render_error("Oups. Something went wrong.")
+      end
     end
 
     # Destroys page and its revisions from page
     # Also used to destroy multiple pages from table checkboxes
     def destroy
       back_url = url_for(controller: controller_name, action: :search)
       @pages = model.where(id: params[:id])
+      authorize @pages
+      message = @pages.length > 1 ? "#{instance_name.humanize.pluralize(@pages.length)} successfully deleted." : "#{@pages.first.title} successfully deleted."
       if @pages.destroy_all
-        respond_to do |format|
-          format.html { redirect_to back_url, notice: "#{instance_name.humanize} successfully deleted." }
-          format.js { head :ok }
-        end
+        render_success(message, redirect_url: [:search, model])
       else
-        respond_to do |format|
-          format.html { redirect_to back_url, alert: "Oups. Something went wrong." }
-          format.js { head :internal_server_error }
-        end
+        render_error("Oups. Something went wrong.")
       end
     end
 
-    # Flush cache from multiple pages
-    def flush_cache
-      @pages = model.where(id: params[:id])
-      @cache_keys = @pages.map(&:cache_key)
-      unless @cache_keys.map{|k| expire_action(k)}.include?(false)
-        respond_to do |format|
-          format.html { redirect_to :back, notice: "Cache was successfully cleared." }
-          format.js { head :ok }
-        end
-      else
-        respond_to do |format|
-          format.html { redirect_to :back, alert: "Oups. Either there wasn't any cache to start with or something went wrong." }
-          format.js { head :internal_server_error }
-        end
-      end
-    end
-
     # Publishes multiple pages from table checkboxes
     def publish
-      @pages = model.where(id: params[:id])
-
+      set_pages
+      authorize @pages
       unless @pages.map(&:publish).include?(false)
-        respond_to do |format|
-          format.html { redirect_to :back, notice: "Successfully published." }
-          format.js { head :ok }
+        @pages.each do |page|
+          CreateActivity.new(page, :publish, owner: current_user).call
         end
+        render_success("Successfully published.")
       else
-        respond_to do |format|
-          format.html { redirect_to :back, alert: "Oups. Something went wrong." }
-          format.js { head :internal_server_error }
-        end
+        render_error("Oups. Something went wrong.")
       end
     end
 
-    # Unpublishes the page
+    # Unpublishes multiple pages from table checkboxes
     def unpublish
-      @pages = model.where(id: params[:id])
+      set_pages
+      authorize @pages
 
       unless @pages.map(&:unpublish).include?(false)
-        respond_to do |format|
-          format.html { redirect_to :back, notice: "Successfully unpublished." }
-          format.js { head :ok }
+        @pages.each do |page|
+          CreateActivity.new(page, :unpublish, owner: current_user).call
         end
+        render_success("Successfully unpublished.")
       else
-        respond_to do |format|
-          format.html { redirect_to :back, alert: "Oups. Something went wrong." }
-          format.js { head :internal_server_error }
-        end
+        render_error("Oups. Something went wrong.")
       end
     end
 
     # Sorts subpages/children from pages#settings
     # FIXME: This should be taken care of in pages#update
@@ -142,26 +139,69 @@
       end
       render nothing: true
     end
 
     def index
-      redirect_to search_pages_path
+      authorize model
+      redirect_to [:search, model]
     end
 
     def search
+      authorize model
       session[:search_params] = params
-      @search = Georgia::Indexer.adapter.search(model, params)
-      @pages = Georgia::PageDecorator.decorate_collection(@search.results)
+      if model.count > 0
+        search_conditions = model.search_conditions(params)
+        @search = model.search(search_conditions).page(params[:page])
+        @pages = Georgia::PageDecorator.decorate_collection(@search.records)
+      else
+        @pages = []
+      end
     end
 
     private
 
     def prepare_new_page
       @page = model.new
     end
 
     def prepare_page
-      @page = model.find(params[:id]).decorate
+      @page = model.where(id: params[:id]).first.try(:decorate)
+    end
+
+    def page_params
+      params.require(:page).permit(permitted_keys)
+    end
+
+    def sanitized_params
+      ParseJsonTags.new(page_params).call
+    end
+
+    def permitted_keys
+      [:slug, :parent_id, :tag_list]
+    end
+
+    def set_pages
+      @pages = model.where(id: params[:id])
+    end
+
+    def render_success success_message, redirect_url: :back
+      @status_message = success_message
+      @status = :notice
+      respond_to do |format|
+        format.html { redirect_to redirect_url, notice: @status_message }
+        format.js   { render layout: false }
+        format.json { render json: { ids: @pages.map(&:id), message: @status_message, status: @status } }
+      end
+    end
+
+    def render_error error_message
+      @status_message = error_message
+      @status = :alert
+      respond_to do |format|
+        format.html { redirect_to :back, alert: @status_message }
+        format.js   { render layout: false }
+        format.json { render json: { message: @status_message, status: @status } }
+      end
     end
 
   end
 end