georgia 0.7.8 → 0.8.0

data/app/controllers/georgia/pages_controller.rb

@@ -3,32 +3,48 @@ module Georgia
 
     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 }
@@ -43,15 +59,17 @@ module Georgia
 
     # 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
@@ -59,8 +77,13 @@ module Georgia
 
     # 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
@@ -68,67 +91,41 @@ module Georgia
     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
-      else
-        respond_to do |format|
-          format.html { redirect_to back_url, alert: "Oups. Something went wrong." }
-          format.js { head :internal_server_error }
-        end
-      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
+        render_success(message, redirect_url: [:search, model])
       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
+        render_error("Oups. Something went wrong.")
       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
 
@@ -144,13 +141,20 @@ module Georgia
     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
@@ -160,7 +164,43 @@ module Georgia
     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

data/app/controllers/georgia/revisions_controller.rb

@@ -1,77 +1,140 @@
 module Georgia
   class RevisionsController < ApplicationController
 
-    load_and_authorize_resource class: Georgia::Revision
-
     before_filter :prepare_revision, except: :index
     before_filter :prepare_page, only: :index
     before_filter :prepare_content, only: [:edit, :update]
 
     def index
-      @revisions = @page.revisions.order('created_at DESC').reject{|r| r == @page.current_revision}
+      @revisions = @page.revisions.order(created_at: :desc)
+      authorize @revisions
     end
 
     def show
-      redirect_to [:edit, @page, @revision]
+      authorize @revision
+      redirect_to edit_page_revision_path(@page, @revision)
     end
 
     def edit
+      authorize @revision
       locale = params.fetch(:locale, current_locale)
+      @activities = (@page.activities + @revision.activities).uniq.sort_by(&:created_at).reverse
       @slides = @revision.slides.ordered.with_locale(locale)
       @ui_sections = Georgia::UiSection.all
+      @status_message = RevisionStatusMessage.new(current_user, @page, @revision)
+      @awaiting_revisions = @page.revisions.where(status: Georgia::Revision.statuses[:review])
+      @draft_revision = @page.revisions.where.not(id: @revision.id).where(user: current_user).where(status: [Georgia::Revision.statuses[:review], Georgia::Revision.statuses[:draft]]).first
     end
 
     # Stores a copy of the current revision before updating
     def update
-      if RevisionPolicy.update(self, @page, @revision, params[:revision])
-        redirect_to [:edit, @page, @revision], notice: "#{@revision.title} was successfully updated."
-      else
-        redirect_to [:edit, @page, @revision], alert: @revision.errors.full_messages.join('. ')
+      authorize @revision
+      update_with_service do |service|
+        service_object = service.new(current_user, @page, @revision, sanitized_attributes)
+        if service_object.call
+          CreateActivity.new(@revision, :update, owner: current_user).call
+          redirect_to edit_page_revision_path(@page, service_object.revision), notice: "#{service_object.revision.title} was successfully updated."
+        else
+          redirect_to edit_page_revision_path(@page, @revision), alert: service_object.revision.errors.full_messages.join('. ')
+        end
       end
     end
 
     def destroy
-      @revision.destroy
-      redirect_to page_revisions_path(@page), notice: "#{@revision.title or 'Revision'} was successfully deleted."
+      authorize @revision
+      # FIXME: Check if this is the last revision for the page. Can't delete the last revision.
+      if @revision.destroy
+        redirect_to [:edit, @page], notice: "Revision was successfully deleted."
+      else
+        redirect_to page_revisions_path(@page), alert: "Oups! Something went wrong."
+      end
     end
 
     # Sends revision to main_app router
     # FIXME: bypass this once Georgia will be loaded on root
     def preview
+      authorize @page
       redirect_to preview_url
     end
 
-    def review
-      @revision.review
-      notify("#{current_user.name} is asking you to review #{@revision.title}.", edit_page_revision_path(@page, @revision, only_path: false))
-      redirect_to [:edit, @page, @revision], notice: "You successfully submited #{@revision.title} for review."
+    def draft
+      authorize @revision
+      ensure_remove_previous_drafts_of_the_same_page
+      if @draft = Georgia::CloneRevision.create(@revision, status: 'draft', revised_by_id: current_user.id)
+        CreateActivity.new(@draft, :draft, owner: current_user).call
+        redirect_to edit_page_revision_path(@page, @draft), notice: "You successfully created a new draft."
+      else
+        redirect_to edit_page_revision_path(@page, @revision), alert: "Oups! Something went wrong."
+      end
+    end
+
+    def request_review
+      authorize @revision
+      if @revision.update(status: :review)
+        CreateActivity.new(@revision, :review, owner: current_user).call
+        notify("#{current_user.name} is asking you to review #{@revision.title}.", edit_page_revision_path(@page, @revision, only_path: false))
+        redirect_to edit_page_revision_path(@page, @revision), notice: "You successfully submited #{@revision.title} for review."
+      else
+        redirect_to edit_page_revision_path(@page, @revision), alert: "Oups! Something went wrong."
+      end
     end
 
     def approve
-      @revision.approve
-      redirect_to @page, notice: "#{current_user.name} has successfully approved and published #{@revision.title}."
+      authorize @revision
+      if @revision.update(status: :published)
+        @page.current_revision.update(status: :revision)
+        @page.update(revision_id: @revision.id)
+        CreateActivity.new(@revision, :approve, owner: current_user).call
+        redirect_to edit_page_revision_path(@page, @revision), notice: "You have successfully approved and published #{@revision.title}."
+      else
+        redirect_to edit_page_revision_path(@page, @revision), alert: "Oups! Something went wrong."
+      end
     end
 
     def decline
-      @revision.decline
-      redirect_to [:edit, @page, @revision], notice: "#{current_user.name} has successfully published #{@revision.title}."
+      authorize @revision
+      if @revision.update(status: :draft)
+        CreateActivity.new(@page, :decline, owner: current_user).call
+        message = "#{current_user.name} has successfully declined a review for #{@revision.title}."
+        @revision.destroy
+        redirect_to [:edit, @page], notice: message
+      else
+        redirect_to edit_page_revision_path(@page, @revision), alert: "Oups! Something went wrong."
+      end
     end
 
     def restore
-      @revision.restore
-      redirect_to @page, notice: "#{current_user.name} has successfully published #{@revision.title}."
+      authorize @revision
+      if @revision.update(status: :published)
+        @page.current_revision.update(status: :revision)
+        @page.update(revision_id: @revision.id)
+        CreateActivity.new(@revision, :restore, owner: current_user).call
+        redirect_to @page, notice: "#{current_user.name} has successfully restored a previous revision for #{@revision.title}."
+      else
+        redirect_to page_revisions_path(@page), alert: "Oups! Something went wrong."
+      end
     end
 
     private
 
     def prepare_page
       polymorphic_resource_key = params.keys.select{|k| k.match('_id')}.first
-      @page = Georgia::Page.find(params[polymorphic_resource_key])
+      @page = Page.where(id: params[polymorphic_resource_key]).first
     end
 
     def prepare_revision
-      @revision = Revision.find(params[:id])
-      @page = @revision.revisionable
+      @revision = Revision.where(id: params[:id]).first
+      if @revision
+        @page = @revision.try(:revisionable)
+      else
+        authorize Georgia::Revision
+        prepare_page
+        if @page
+          redirect_to [:edit, @page], alert: 'This revision has been deleted or does not exist.'
+        else
+          redirect_to georgia.root_path, alert: "This resource has been deleted or does not exist."
+        end
+      end
     end
 
     def prepare_content
@@ -85,12 +148,45 @@ module Georgia
     end
 
     def notify(message, url)
-      Notifier.notify_admins(message, url).deliver
+      Notifier.notify_editors(message, url).deliver
     end
 
     def preview_url
       "#{@page.decorate.url}?r=#{@revision.id}"
     end
 
+    def revision_params
+      params.require(:revision).permit(
+        :template,
+        contents_attributes: [:text, :title, :locale, :excerpt, :keyword_list, :image_id, :id],
+        slides_attributes: [:position, :id, :_destroy, contents_attributes: [:text, :title, :image_id, :locale, :id]],
+        ui_associations_attributes: [:id, :_destroy, :position, :ui_section_id, :widget_id]
+      )
+    end
+
+    def sanitized_attributes
+      attributes = revision_params
+      attributes.fetch(:contents_attributes, []).each do |id, content_attributes|
+        attributes[:contents_attributes][id] = ParseJsonTags.new(content_attributes, key: :keyword_list).call
+      end
+      attributes
+    end
+
+    def update_with_service
+      service = 
+        if policy(@revision).publish?
+          UpdateRevision::Admin
+        elsif policy(@revision).draft_changes?
+          UpdateRevision::Contributor
+        else
+          UpdateRevision::Guest
+        end
+      yield service
+    end
+
+    def ensure_remove_previous_drafts_of_the_same_page
+      @page.revisions.where(user: current_user).where(status: [Georgia::Revision.statuses[:review], Georgia::Revision.statuses[:draft]]).destroy_all
+    end
+
   end
 end