georgia 0.7.0

data/app/controllers/georgia/concerns/helpers.rb

@@ -0,0 +1,28 @@
+require 'active_support/concern'
+
+module Georgia
+  module Concerns
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :instance_name
+        helper_method :model
+      end
+
+      def instance_name
+        controller_name.singularize
+      end
+
+      def model
+        begin
+          self.class.to_s.gsub(/Controller/,'').singularize.constantize
+          # If no constant is found, check if the non-namespaced one exists. i.e. Partner => Admin::PartnersController
+        rescue NameError
+          self.class.to_s.gsub(/Controller/,'').gsub(/\w+::/,'').singularize.constantize
+        end
+      end
+
+    end
+  end
+end

data/app/controllers/georgia/dashboard_controller.rb

@@ -0,0 +1,14 @@
+module Georgia
+  class DashboardController < Georgia::ApplicationController
+
+    def show
+      if can?(:approve, Georgia::Revision) or can?(:review, Georgia::Revision)
+        @awaiting_revisions = Georgia::Revision.reviews.select{|r| r.revisionable.present?}
+      end
+      if can?(:index, Georgia::Message)
+        @messages = Georgia::Message.ham.latest.limit(5).decorate
+      end
+    end
+
+  end
+end

data/app/controllers/georgia/links_controller.rb

@@ -0,0 +1,13 @@
+module Georgia
+  class LinksController < ApplicationController
+
+    # Renders new portlet for menus#edit
+    def create
+      @link = Link.create
+      @link.contents.build(locale: current_locale)
+      render :show, layout: false
+    end
+
+  end
+
+end

data/app/controllers/georgia/media_controller.rb

@@ -0,0 +1,101 @@
+module Georgia
+  class MediaController < ApplicationController
+
+    load_and_authorize_resource class: Ckeditor::Asset
+    # destroy's :id param is an Array and makes load_resource fails
+    skip_load_resource only: :destroy
+
+    def index
+      redirect_to action: :search
+    end
+
+    def search
+      @asset = Ckeditor::Asset.new
+      session[:search_params] = params
+      @search = Ckeditor::Asset.search do
+        fulltext params[:query] do
+          fields(:filename, :tags)
+        end
+        with(:extension, params[:e]) unless params[:e].blank?
+        with(:tags).any_of(params[:tg]) unless params[:tg].blank?
+        order_by (params[:o] || :updated_at), (params[:dir] || :desc)
+        paginate(page: params[:page], per_page: (params[:per] || 8))
+      end
+      @assets = Ckeditor::AssetDecorator.decorate_collection(@search.results)
+    end
+
+    def create
+      @assets = []
+      params[:assets].each do |asset|
+        klass = asset.content_type.match(/^image/) ? Ckeditor::Picture : Ckeditor::Asset
+        @assets << klass.create(data: asset)
+      end
+      render layout: false
+    end
+
+    def show
+      redirect_to edit_media_path(id: params[:id])
+    end
+
+    def edit
+      @asset = Ckeditor::Asset.find(params[:id])
+    end
+
+    def update
+      @asset = Ckeditor::Asset.find(params[:id])
+      if @asset.update_attributes(params[:asset])
+        respond_to do |format|
+          format.html { redirect_to edit_media_path(@asset), notice: "Asset was successfully updated." }
+          format.js { head :ok }
+        end
+      else
+        respond_to do |format|
+          format.html { redirect_to edit_media_path(@asset), alert: "Oups. Something went wrong." }
+          format.js { head :internal_server_error }
+        end
+      end
+    end
+
+    # Destroy multiple assets
+    def destroy
+      @assets = Ckeditor::Asset.where(id: params[:id])
+      if can?(:destroy, Ckeditor::Asset) and @assets.destroy_all
+        respond_to do |format|
+          format.html { redirect_to search_media_index_path, notice: "Assets were successfully deleted." }
+          format.js { head :ok }
+        end
+      else
+        respond_to do |format|
+          format.html { redirect_to search_media_index_path, alert: "Oups. Something went wrong." }
+          format.js { head :internal_server_error }
+        end
+      end
+    end
+
+    # Download multiple assets as a zip file
+    # TODO: We could send via AJAX with jquery.fileDownload plugin
+    # We could then have a download spinner while the request is processing, even a progress bar
+    def download
+      ids = params[:ids].split(',')
+      @files = Ckeditor::Asset.find(ids)
+      t = Tempfile.new("tmp-zip-#{Time.now.to_i}")
+      Zip::OutputStream.open(t.path) do |zos|
+        @files.each do |file|
+          filename = file.filename
+          zos.put_next_entry(filename)
+          tmp_file = Tempfile.new(filename)
+          open(file.url) do |data|
+            tmp_file.write data.read.force_encoding('UTF-8')
+          end
+          zos.print IO.read(tmp_file)
+          tmp_file.close
+        end
+      end
+      filename = "#{Georgia.title.try(:parameterize) || 'georgia'}_assets_#{Time.now.strftime('%Y%m%d%H%M%S')}.zip"
+      t.close
+
+      send_file t.path, type: "application/zip", disposition: 'attachment', filename: filename
+    end
+
+  end
+end

data/app/controllers/georgia/menus_controller.rb

@@ -0,0 +1,80 @@
+module Georgia
+  class MenusController < ApplicationController
+
+    load_and_authorize_resource class: Menu
+
+    def index
+      @menus = Menu.scoped.page(params[:page])
+    end
+
+    def new
+      @menu = Menu.new
+    end
+
+    def create
+      @menu = Menu.new(params[:menu])
+      if @menu.save
+        respond_to do |format|
+          format.html { redirect_to [:edit, @menu], notice: "#{@menu.title} was successfully created." }
+          format.js { render layout: false }
+        end
+      else
+        respond_to do |format|
+          format.html { render :edit }
+          format.js { render layout: false }
+        end
+      end
+    end
+
+    def show
+      redirect_to edit_menu_path(params[:id])
+    end
+
+    def edit
+      @menu = Menu.find(params[:id])
+      @links = @menu.links.roots
+    end
+
+    def update
+      @menu = Menu.find(params[:id])
+      update_links_attributes(params[:menu].delete(:ancestry))
+      update_links_menu_id
+      if @menu.update_attributes(params[:menu])
+        respond_to do |format|
+          format.html { redirect_to [:edit, @menu], notice: "#{@menu.title} was successfully updated." }
+          format.js { head :ok }
+        end
+      else
+        respond_to do |format|
+          format.html { render :edit, alert: "Oups. Something went wrong." }
+          format.js { head :internal_server_error }
+        end
+      end
+    end
+
+    def destroy
+      @menu = Menu.find(params[:id])
+      @menu.destroy
+
+      redirect_to menus_url
+    end
+
+    private
+
+    def update_links_attributes ancestry_tree
+      return unless ancestry_tree
+      ancestry_attributes(ancestry_tree).each do |k,v|
+        params[:menu][:links_attributes][k].merge!(v)
+      end
+    end
+
+    def update_links_menu_id
+      Link.where(id: params[:menu][:links_attributes].keys).update_all(menu_id: params[:id])
+    end
+
+    def ancestry_attributes(ancestry_tree)
+      MenuAncestryParser.new(ancestry_tree).to_hash
+    end
+
+  end
+end

data/app/controllers/georgia/messages_controller.rb

@@ -0,0 +1,74 @@
+module Georgia
+  class MessagesController < ApplicationController
+
+    load_and_authorize_resource class: Georgia::Message
+
+    before_filter :prepare_search, only: [:search, :show, :spam, :ham]
+
+
+    def index
+      redirect_to action: :search
+    end
+
+    def search
+    end
+
+    # Destroy multiple assets
+    def destroy
+      ids = params[:id].split(',')
+      if @messages = Message.destroy(ids)
+        render layout: false
+      else
+        head :internal_server_error
+      end
+    end
+
+    def destroy_all_spam
+      if Message.spam.destroy_all
+        redirect_to :back, notice: 'All spam messages have been successfully deleted.'
+      else
+        redirect_to :back, alert: 'Oups. Something went wrong.'
+      end
+    end
+
+    def show
+      @message = Message.find(params[:id]).decorate
+    end
+
+    def spam
+      @message = Message.find(params[:id])
+      if @message.spam!
+        @message.update_attribute(:spam, true)
+        redirect_to :back, notice: 'Message successfully marked as spam.'
+      else
+        redirect_to :back, alert: 'Oups. Something went wrong.'
+      end
+    end
+
+    def ham
+      @message = Message.find(params[:id])
+      if @message.ham! == false
+        @message.update_attribute(:spam, false)
+        redirect_to :back, notice: 'Message successfully marked as ham.'
+      else
+        redirect_to :back, alert: 'Oups. Something went wrong.'
+      end
+    end
+
+    private
+
+    def prepare_search
+      @search = Georgia::Message.search do
+        fulltext params[:query] do
+          fields(:name, :email, :message, :subject, :phone)
+        end
+        facet :spam
+        with(:spam, (params[:s] || 'clean'))
+        order_by (params[:o] || :created_at), (params[:dir] || :desc)
+        paginate(page: params[:page], per_page: (params[:per] || 25))
+      end
+      @messages = Georgia::MessageDecorator.decorate_collection(@search.results)
+    end
+
+  end
+end

data/app/controllers/georgia/pages_controller.rb

@@ -0,0 +1,180 @@
+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]
+    end
+
+    # Edit current revision
+    def edit
+      redirect_to [:edit, @page, @page.current_revision]
+    end
+
+    # Edit current page
+    def settings
+    end
+
+    # Create page, load first current revision and js redirect to revisions#edit
+    def create
+      @page = model.new(slug: params[:title].try(:parameterize))
+      if @page.save
+        @page.revisions.create(template: Georgia.templates.first) do |rev|
+          rev.contents << Georgia::Content.new(locale: I18n.default_locale, title: params[:title])
+        end
+        @page.update_attribute(:current_revision, @page.revisions.first)
+        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
+        respond_to do |format|
+          format.html { redirect_to :back, alert: "Oups. Something went wrong." }
+          format.js { render layout: false }
+        end
+      end
+    end
+
+    # Update page settings
+    def update
+      Georgia::Page.update_tree(params[:page_tree]) if params[:page_tree]
+      if @page.update_attributes(params[:page])
+        respond_to do |format|
+          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.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"
+    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])
+      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
+      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])
+
+      unless @pages.map(&:publish).include?(false)
+        respond_to do |format|
+          format.html { redirect_to :back, notice: "Successfully published." }
+          format.js { head :ok }
+        end
+      else
+        respond_to do |format|
+          format.html { redirect_to :back, alert: "Oups. Something went wrong." }
+          format.js { head :internal_server_error }
+        end
+      end
+    end
+
+    # Unpublishes the page
+    def unpublish
+      @pages = model.where(id: params[:id])
+
+      unless @pages.map(&:unpublish).include?(false)
+        respond_to do |format|
+          format.html { redirect_to :back, notice: "Successfully unpublished." }
+          format.js { head :ok }
+        end
+      else
+        respond_to do |format|
+          format.html { redirect_to :back, alert: "Oups. Something went wrong." }
+          format.js { head :internal_server_error }
+        end
+      end
+    end
+
+    # Sorts subpages/children from pages#settings
+    # FIXME: This should be taken care of in pages#update
+    def sort
+      if params[:page]
+        params[:page].each_with_index do |id, index|
+          model.update_all({position: index+1}, {id: id})
+        end
+      end
+      render nothing: true
+    end
+
+    def index
+      redirect_to search_pages_path
+    end
+
+    def search
+      session[:search_params] = params
+      @search = model.search do
+        fulltext params[:query] do
+          fields(:title, :excerpt, :text, :keywords, :tags, :url, :template)
+        end
+        facet :state, :template, :tag_list
+        # ensure pages indexed in the wrong bucket don't get displayed
+        with(:class_name, model.to_s)
+        with(:state, params[:s]) unless params[:s].blank?
+        with(:template, params[:t]) unless params[:t].blank?
+        with(:tag_list).all_of(params[:tg]) unless params[:tg].blank?
+        order_by (params[:o] || :updated_at), (params[:dir] || :desc)
+        paginate(page: params[:page], per_page: (params[:per] || 25))
+        instance_eval &model.extra_search_params if model.respond_to? :extra_search_params
+      end
+      @pages = Georgia::PageDecorator.decorate_collection(@search.results)
+    end
+
+    private
+
+    def prepare_new_page
+      @page = model.new
+    end
+
+    def prepare_page
+      @page = model.find(params[:id]).decorate
+    end
+
+  end
+end