lc_alchemy_cms 3.2.0

data/app/controllers/alchemy/admin/attachments_controller.rb

@@ -0,0 +1,106 @@
+module Alchemy
+  module Admin
+    class AttachmentsController < ResourcesController
+      helper 'alchemy/admin/tags'
+
+      def index
+        @attachments = Attachment.all
+        if params[:only].present?
+          @attachments = @attachments.where("file_mime_type LIKE '%#{params[:only]}%'")
+        end
+        if params[:except].present?
+          @attachments = @attachments.where("file_mime_type NOT LIKE '%#{params[:except]}%'")
+        end
+        if params[:tagged_with].present?
+          @attachments = @attachments.tagged_with(params[:tagged_with])
+        end
+        @attachments = @attachments.find_paginated(params, 15, sort_order)
+        @options = options_from_params
+        if in_overlay?
+          archive_overlay
+        end
+      end
+
+      # The resources controller renders the edit form as default for show actions.
+      def show
+        render :show
+      end
+
+      def new
+        @attachment = Attachment.new
+        if in_overlay?
+          set_instance_variables
+        end
+      end
+
+      def create
+        @attachment = Attachment.new(attachment_attributes)
+        if @attachment.save
+          if in_overlay?
+            set_instance_variables
+          end
+          message = _t('File uploaded succesfully', name: @attachment.name)
+          render json: {files: [@attachment.to_jq_upload], growl_message: message}, status: :created
+        else
+          message = _t('File upload error', error: @attachment.errors[:file].join)
+          render json: {files: [@attachment.to_jq_upload], growl_message: message}, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        @attachment.update_attributes(attachment_attributes)
+        render_errors_or_redirect(
+          @attachment,
+          admin_attachments_path(page: params[:page], query: params[:query], per_page: params[:per_page]),
+          _t("File successfully updated")
+        )
+      end
+
+      def destroy
+        name = @attachment.name
+        @attachment.destroy
+        @url = admin_attachments_url(
+          per_page: params[:per_page],
+          page: params[:page],
+          query: params[:query]
+        )
+        flash[:notice] = _t('File deleted successfully', name: name)
+      end
+
+      def download
+        @attachment = Attachment.find(params[:id])
+        send_data @attachment.file.data, {
+          filename: @attachment.file_name,
+          type: @attachment.file_mime_type
+        }
+      end
+
+      private
+
+      def in_overlay?
+        params[:content_id].present?
+      end
+
+      def archive_overlay
+        @content = Content.find_by(id: params[:content_id])
+        @options = options_from_params
+        respond_to do |format|
+          format.html { render partial: 'archive_overlay' }
+          format.js   { render action:  'archive_overlay' }
+        end
+      end
+
+      def attachment_attributes
+        params.require(:attachment).permit(:file, :name, :file_name, :tag_list)
+      end
+
+      def set_instance_variables
+        @while_assigning = true
+        @content = Content.find_by(id: params[:content_id])
+        @swap = params[:swap]
+        @options = options_from_params
+      end
+
+    end
+  end
+end

data/app/controllers/alchemy/admin/base_controller.rb

@@ -0,0 +1,168 @@
+module Alchemy
+  module Admin
+    class BaseController < Alchemy::BaseController
+      include Userstamp
+      include Alchemy::Locale
+
+      before_filter { enforce_ssl if ssl_required? && !request.ssl? }
+
+      helper_method :clipboard_empty?, :trash_empty?, :get_clipboard, :is_admin?
+
+      check_authorization
+
+      rescue_from Exception do |exception|
+        if exception.is_a? CanCan::AccessDenied
+          permission_denied(exception)
+        elsif raise_exception?
+          raise
+        else
+          exception_handler(exception)
+        end
+      end
+
+      layout :set_layout
+
+      def leave
+        authorize! :leave, :alchemy_admin
+        render template: '/alchemy/admin/leave', layout: !request.xhr?
+      end
+
+      private
+
+      # Disable layout rendering for xhr requests.
+      def set_layout
+        request.xhr? ? false : 'alchemy/admin'
+      end
+
+      # Handles exceptions
+      def exception_handler(e)
+        exception_logger(e)
+        show_error_notice(e)
+        if defined?(Airbrake)
+          notify_airbrake(e) unless Rails.env.development? || Rails.env.test?
+        end
+      end
+
+      # Displays an error notice in the Alchemy backend.
+      def show_error_notice(e)
+        @error = e
+        # truncate the message, because very long error messages (i.e from mysql2) causes cookie overflow errors
+        @notice = e.message[0..255]
+        @trace = e.backtrace[0..50]
+        if request.xhr?
+          render :action => "error_notice"
+        else
+          render '500', :status => 500
+        end
+      end
+
+      def redirect_back_or_to_default(default_path = admin_dashboard_path)
+        if request.referer.present?
+          redirect_to :back
+        else
+          redirect_to default_path
+        end
+      end
+
+      # Returns clipboard items for given category
+      def get_clipboard(category)
+        session[:alchemy_clipboard] ||= {}
+        session[:alchemy_clipboard][category.to_s] ||= []
+      end
+
+      # Checks if clipboard for given category is blank
+      def clipboard_empty?(category)
+        get_clipboard(category).blank?
+      end
+
+      def trash_empty?(category)
+        "alchemy/#{category.singularize}".classify.constantize.trashed.blank?
+      end
+
+      def set_stamper
+        if Alchemy.user_class < ActiveRecord::Base
+          Alchemy.user_class.stamper = current_alchemy_user
+        end
+      end
+
+      def reset_stamper
+        if Alchemy.user_class < ActiveRecord::Base
+          Alchemy.user_class.reset_stamper
+        end
+      end
+
+      # Returns true if the current_alchemy_user (The logged-in Alchemy User) has the admin role.
+      def is_admin?
+        return false if !current_alchemy_user
+        current_alchemy_user.admin?
+      end
+
+      # Displays errors in a #errors div if any errors are present on the object.
+      # Or redirects to the given redirect url.
+      #
+      # @param object [ActiveRecord::Base]
+      # @param redirect_url [String]
+      # @param flash_notice [String]
+      #
+      def render_errors_or_redirect(object, redirect_url, flash_notice)
+        if object.errors.empty?
+          flash[:notice] = _t(flash_notice)
+          do_redirect_to redirect_url
+        else
+          render action: (params[:action] == 'update' ? 'edit' : 'new')
+        end
+      end
+
+      def per_page_value_for_screen_size
+        return 25 if session[:screen_size].blank?
+        screen_height = session[:screen_size].split('x').last.to_i
+        (screen_height / 30) - 10
+      end
+
+      # Does redirects for html and js requests
+      #
+      def do_redirect_to(url_or_path)
+        respond_to do |format|
+          format.js   {
+            @redirect_url = url_or_path
+            render :redirect
+          }
+          format.html { redirect_to url_or_path }
+        end
+      end
+
+      # Extracts options from params.
+      #
+      # Helps to parse JSONified options into Hash or Array
+      #
+      def options_from_params
+        case params[:options]
+        when ''
+          {}
+        when String
+          JSON.parse(params[:options])
+        when Hash
+          params[:options]
+        when Array
+          params[:options]
+        else
+          {}
+        end.symbolize_keys
+      end
+
+      # This method decides if we want to raise an exception or not.
+      #
+      # I.e. in test environment.
+      #
+      def raise_exception?
+        Rails.env.test? || is_page_preview?
+      end
+
+      # Are we currently in the page edit mode page preview.
+      def is_page_preview?
+        controller_path == 'alchemy/admin/pages' && action_name == 'show'
+      end
+
+    end
+  end
+end

data/app/controllers/alchemy/admin/clipboard_controller.rb

@@ -0,0 +1,51 @@
+module Alchemy
+  module Admin
+    class ClipboardController < Alchemy::Admin::BaseController
+      authorize_resource class: :alchemy_admin_clipboard
+      before_filter :set_clipboard
+
+      def index
+        @clipboard_items = model_class.all_from_clipboard(@clipboard)
+        respond_to do |format|
+          format.html
+        end
+      end
+
+      def insert
+        @item = model_class.find(params[:remarkable_id])
+        unless @clipboard.detect { |item| item['id'] == params[:remarkable_id] }
+          @clipboard << {
+            'id' => params[:remarkable_id],
+            'action' => params[:remove] ? 'cut' : 'copy'
+          }
+        end
+        respond_to do |format|
+          format.js
+        end
+      end
+
+      def remove
+        @item = model_class.find(params[:remarkable_id])
+        @clipboard.delete_if { |item| item['id'] == params[:remarkable_id] }
+        respond_to do |format|
+          format.js
+        end
+      end
+
+      def clear
+        @clipboard.clear
+      end
+
+      private
+
+      def set_clipboard
+        @clipboard = get_clipboard(params[:remarkable_type])
+      end
+
+      def model_class
+        "alchemy/#{params[:remarkable_type]}".classify.constantize
+      end
+
+    end
+  end
+end

data/app/controllers/alchemy/admin/contents_controller.rb

@@ -0,0 +1,76 @@
+module Alchemy
+  module Admin
+    class ContentsController < Alchemy::Admin::BaseController
+      helper 'alchemy/admin/essences'
+
+      authorize_resource class: Alchemy::Content
+
+      def new
+        @element = Element.find(params[:element_id])
+        @options = options_from_params
+        @contents = @element.available_contents
+        @content = @element.contents.build
+      end
+
+      def create
+        @element = Element.find(params[:content][:element_id])
+        @content = Content.create_from_scratch(@element, content_params)
+        @options = options_from_params
+        @html_options = params[:html_options] || {}
+        if picture_gallery_editor?
+          @content.update_essence(picture_id: params[:picture_id])
+          @options = options_for_picture_gallery
+          @content_dom_id = "#add_picture_#{@element.id}"
+        else
+          @content_dom_id = "#add_content_for_element_#{@element.id}"
+        end
+        @locals = essence_editor_locals
+      end
+
+      def update
+        @content = Content.find(params[:id])
+        @content.update_essence(content_params)
+      end
+
+      def order
+        params[:content_ids].each do |id|
+          content = Content.find(id)
+          content.move_to_bottom
+        end
+        @notice = _t("Successfully saved content position")
+      end
+
+      def destroy
+        @content = Content.find(params[:id])
+        @content_dom_id = @content.dom_id
+        @notice = _t("Successfully deleted content", content: @content.name_for_label)
+        @content.destroy
+      end
+
+      private
+
+      def content_params
+        params.require(:content).permit(:element_id, :name, :ingredient, :essence_type)
+      end
+
+      def picture_gallery_editor?
+        params[:content][:essence_type] == 'Alchemy::EssencePicture' && @options[:grouped] == 'true'
+      end
+
+      def options_for_picture_gallery
+        @gallery_pictures = @element.contents.gallery_pictures
+        @dragable = @gallery_pictures.size > 1
+        @options.merge(dragable: @dragable)
+      end
+
+      def essence_editor_locals
+        {
+          content: @content,
+          options: @options.symbolize_keys,
+          html_options: @html_options.symbolize_keys
+        }
+      end
+
+    end
+  end
+end

data/app/controllers/alchemy/admin/dashboard_controller.rb

@@ -0,0 +1,89 @@
+require 'net/http'
+require 'alchemy/version'
+
+module Alchemy
+  module Admin
+    class DashboardController < Alchemy::Admin::BaseController
+      authorize_resource class: :alchemy_admin_dashboard
+
+      def index
+        @last_edited_pages = Page.from_current_site.all_last_edited_from(current_alchemy_user)
+        @locked_pages = Page.from_current_site.all_locked
+        if Alchemy.user_class.respond_to?(:logged_in)
+          @online_users = Alchemy.user_class.logged_in.to_a - [current_alchemy_user]
+        end
+        if current_alchemy_user.respond_to?(:sign_in_count) && current_alchemy_user.respond_to?(:last_sign_in_at)
+          @last_sign_at = current_alchemy_user.last_sign_in_at
+          @first_time = current_alchemy_user.sign_in_count == 1 && @last_sign_at.nil?
+        end
+        @sites = Site.all
+      end
+
+      def info
+        @alchemy_version = Alchemy.version
+      end
+
+      def update_check
+        @alchemy_version = Alchemy.version
+        if @alchemy_version < latest_alchemy_version
+          render :text => 'true'
+        else
+          render :text => 'false'
+        end
+      rescue UpdateServiceUnavailable => e
+        render :text => e, :status => 503
+      end
+
+      private
+
+      # Returns latest alchemy version.
+      def latest_alchemy_version
+        versions = get_alchemy_versions
+        return '' if versions.blank?
+        # reject any non release version
+        versions.reject! { |v| v =~ /[a-z]/ }
+        versions.sort.last
+      end
+
+      # Get alchemy versions from rubygems or github, if rubygems failes.
+      def get_alchemy_versions
+        # first we try rubygems.org
+        response = query_rubygems
+        if response.code == "200"
+          alchemy_versions = JSON.parse(response.body)
+          alchemy_versions.collect { |h| h['number'] }.sort
+        else
+          # rubygems.org not available?
+          # then we try github
+          response = query_github
+          if response.code == "200"
+            alchemy_tags = JSON.parse(response.body)
+            alchemy_tags.collect { |h| h['name'] }.sort
+          else
+            # no luck at all?
+            raise UpdateServiceUnavailable
+          end
+        end
+      end
+
+      # Query the RubyGems API for Alchemy versions.
+      def query_rubygems
+        make_api_request('https://rubygems.org/api/v1/versions/alchemy_cms.json')
+      end
+
+      # Query the GitHub API for Alchemy tags.
+      def query_github
+        make_api_request('https://api.github.com/repos/AlchemyCMS/alchemy_cms/tags')
+      end
+
+      # Make a HTTP API request for given request url.
+      def make_api_request(request_url)
+        url = URI.parse(request_url)
+        request = Net::HTTP::Get.new(url.path)
+        connection = Net::HTTP.new(url.host, url.port)
+        connection.use_ssl = true
+        connection.request(request)
+      end
+    end
+  end
+end