pages_core 3.4.3 → 3.7.0

data/app/controllers/admin/page_comments_controller.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-module Admin
-  class PageCommentsController < Admin::AdminController
-    before_action :find_page
-    before_action :find_page_comment, only: [:show, :edit, :update, :destroy]
-
-    def index
-      redirect_to admin_page_path(@locale, @page)
-    end
-
-    def show
-    end
-
-    def new
-      @page_comment = @page.comments.new
-    end
-
-    def edit
-    end
-
-    def create
-      @page_comment = @page.comments.create(page_comment_params)
-      if @page_comment.valid?
-        flash[:notice] = "The comment was created"
-        redirect_to admin_page_path(@locale, @page)
-      else
-        render action: :new
-      end
-    end
-
-    def update
-      if @page_comment.update(page_comment_params)
-        flash[:notice] = "The comment was updated"
-        redirect_to admin_page_path(@locale, @page)
-      else
-        render action: :edit
-      end
-    end
-
-    def destroy
-      @page_comment.destroy
-      flash[:notice] = "The comment was deleted"
-      redirect_to admin_page_path(@locale, @page)
-    end
-
-    protected
-
-    def find_page
-      @page = Page.find(params[:page_id])
-    end
-
-    def find_page_comment
-      @page_comment = @page.comments.find(params[:id])
-    end
-
-    def page_comment_params
-      params.require(:page_comment).permit(:name, :email, :url, :body)
-    end
-  end
-end

data/app/controllers/admin/page_files_controller.rb

@@ -1,81 +0,0 @@
-# encoding: utf-8
-
-module Admin
-  class PageFilesController < Admin::AdminController
-    before_action :find_page
-    before_action :find_page_file,   only: [:show, :edit, :update, :destroy]
-    before_action :redirect_to_page, only: [:index, :show, :new, :edit]
-
-    require_authorization(
-      PageFile,
-      proc { @page_file },
-      collection: [:index, :reorder, :new, :create]
-    )
-
-    def index
-    end
-
-    def reorder
-      if params[:ids]
-        files = Array(params[:ids]).map { |id| PageFile.find(id) }
-        files.each_with_index do |file, index|
-          file.update(position: index)
-        end
-      end
-      if request.xhr?
-        render text: "ok"
-      else
-        redirect_to_page
-      end
-    end
-
-    def show
-    end
-
-    def new
-    end
-
-    def create
-      @page_file = @page.files.new
-      @page_file.update(page_file_params.merge(locale: @locale))
-      flash[:notice] = "Error uploading file!" unless @page_file.valid?
-      redirect_to_page
-    end
-
-    def edit
-    end
-
-    def update
-      if @page_file.update(page_file_params)
-        flash[:notice] = "File updated"
-      else
-        flash[:notice] = "Error updating file!"
-      end
-      redirect_to_page
-    end
-
-    def destroy
-      @page_file.destroy
-      flash[:notice] = "File deleted"
-      redirect_to_page
-    end
-
-    protected
-
-    def page_file_params
-      params.require(:page_file).permit(:name, :filename, :file)
-    end
-
-    def redirect_to_page
-      redirect_to(edit_admin_page_path(@locale, @page, anchor: "files"))
-    end
-
-    def find_page
-      @page = Page.find(params[:page_id]).localize(@locale)
-    end
-
-    def find_page_file
-      @page_file = @page.files.find(params[:id])
-    end
-  end
-end

data/app/controllers/admin/page_images_controller.rb

@@ -1,116 +0,0 @@
-# encoding: utf-8
-
-module Admin
-  class PageImagesController < Admin::AdminController
-    before_action :find_page
-    before_action :find_page_image, only: [:show, :edit, :update, :destroy]
-
-    require_authorization(
-      PageImage,
-      proc { @page_image },
-      collection: [:index, :reorder, :new, :create]
-    )
-
-    def index
-      @page_images = @page.page_images
-      respond_to do |format|
-        format.json do
-          render json: @page_images, each_serializer: Admin::PageImageSerializer
-        end
-      end
-    end
-
-    def reorder
-      @page_images = params[:ids].map { |id| PageImage.find(id) }
-      @page_images.each_with_index do |pi, i|
-        pi.update_column(:position, i)
-      end
-      respond_to do |format|
-        format.json do
-          render json: @page_images, each_serializer: Admin::PageImageSerializer
-        end
-      end
-    end
-
-    def show
-    end
-
-    def new
-      @page_image = @page.page_images.new
-    end
-
-    def create
-      if page_images_params?
-        page_images_params.each do |_index, attributes|
-          if attributes[:image]
-            @page.page_images.create(attributes.merge(locale: @locale))
-          end
-        end
-      else
-        @page.page_images.create(page_image_params.merge(locale: @locale))
-      end
-      redirect_to(admin_page_path(@locale, @page, anchor: "images"))
-    end
-
-    def update
-      if @page_image.update(page_image_params)
-        respond_to do |format|
-          format.html do
-            flash[:notice] = "The image was updated"
-            redirect_to(admin_page_path(@locale, @page, anchor: "images"))
-          end
-          format.json do
-            render json: @page_image.to_json
-          end
-        end
-      else
-        render action: :edit
-      end
-    end
-
-    def destroy
-      @page_image.destroy
-      respond_to do |format|
-        format.html do
-          flash[:notice] = "The image was deleted"
-          redirect_to(admin_page_path(@locale, @page, anchor: "images"))
-        end
-        format.json do
-          render json: @page_image.to_json
-        end
-      end
-    end
-
-    protected
-
-    def find_page
-      @page = Page.find(params[:page_id]).localize(@locale)
-    end
-
-    def find_page_image
-      @page_image = @page.page_images.find(params[:id]).localize(@locale)
-    end
-
-    def page_image_params
-      params.require(:page_image).permit(
-        :image, :primary,
-        image_attributes: [
-          :id, :alternative, :caption,
-          :crop_start_x, :crop_start_y, :crop_width, :crop_height
-        ]
-      )
-    end
-
-    def page_images_params
-      params.permit(
-        page_images: [:image, :primary, {
-          image_attributes: [:alternative, :caption]
-        }]
-      )[:page_images]
-    end
-
-    def page_images_params?
-      params[:page_images] ? true : false
-    end
-  end
-end

data/app/controllers/concerns/pages_core/domain_based_cache.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-module PagesCore
-  module DomainBasedCache
-    extend ActiveSupport::Concern
-
-    included do
-      before_action :set_domain_based_cache_path
-    end
-
-    module ClassMethods
-      def default_page_cache_directory
-        @default_page_cache_directory ||=
-          ActionController::Base.page_cache_directory
-      end
-    end
-
-    protected
-
-    def set_domain_based_cache_path
-      return unless PagesCore.config(:domain_based_cache)
-      ActionController::Base.page_cache_directory = File.join(
-        ApplicationController.default_page_cache_directory,
-        request.domain
-      )
-    end
-  end
-end

data/app/controllers/concerns/pages_core/exception_handler.rb

@@ -1,114 +0,0 @@
-# encoding: utf-8
-
-module PagesCore
-  module ExceptionHandler
-    extend ActiveSupport::Concern
-
-    included do
-      unless Rails.application.config.consider_all_requests_local
-        rescue_from Exception,                           with: :handle_exception
-        rescue_from PagesCore::NotAuthorized,            with: :handle_exception
-        rescue_from ActiveRecord::RecordNotFound,        with: :handle_exception
-        rescue_from ActionController::RoutingError,      with: :handle_exception
-        rescue_from ActionController::UnknownController, with: :handle_exception
-        rescue_from AbstractController::ActionNotFound,  with: :handle_exception
-      end
-    end
-
-    # Renders a fancy error page from app/views/errors. If the error name
-    # is numeric, it will also be set as the response status. Example:
-    #
-    #   render_error 404
-    #
-    def render_error(error, options = {})
-      options[:status] ||= error if error.is_a? Numeric
-      options[:template] ||= "errors/#{error}"
-      options[:layout] ||= "errors"
-      @email = logged_in? ? current_user.email : ""
-      render options
-    end
-
-    protected
-
-    def log_error(exception)
-      trace = exception.backtrace
-      ActiveSupport::Deprecation.silence do
-        message = "\n#{exception.class} (#{exception.message}):\n"
-        if exception.respond_to?(:annoted_source_code)
-          message << exception.annoted_source_code.to_s
-        end
-        message << "  " << trace.join("\n  ")
-        logger.fatal("#{message}\n\n")
-      end
-    end
-
-    def env_as_object
-      request.env.each_with_object({}) do |hash, value|
-        if value.first.is_a?(String) && value.last.is_a?(String)
-          hash[value.first] = value.last
-        end
-      end
-    end
-
-    def filtered_backtrace(exception)
-      Rails.backtrace_cleaner.send(:filter, exception.backtrace)
-    end
-
-    def exception_url
-      [
-        "http://",
-        request.env["HTTP_HOST"],
-        request.env["REQUEST_URI"]
-      ].compact.join
-    end
-
-    def error_report(exception)
-      {
-        message: exception.to_s,
-        url: exception_url,
-        params: params,
-        env: env_as_object,
-        session: session.to_hash,
-        backtrace: filtered_backtrace(exception),
-        timestamp: Time.now,
-        user_id: logged_in? ? current_user.id : nil
-      }
-    end
-
-    def write_error(str)
-      sha1_hash = Digest::SHA1.hexdigest(str)
-      error_report_dir  = Rails.root.join("log", "error_reports")
-      error_report_file = error_report_dir.join("#{sha1_hash}.yml")
-      `mkdir -p #{error_report_dir}` unless File.exist?(error_report_dir)
-
-      unless File.exist?(error_report_file)
-        File.open(error_report_file, "w") do |fh|
-          fh.write str
-        end
-      end
-      sha1_hash
-    end
-
-    def handle_exception(exception)
-      log_error exception
-      if exception.is_a?(ActionController::RoutingError) ||
-          exception.is_a?(ActiveRecord::RecordNotFound)
-        render_error 404
-      elsif exception.is_a?(PagesCore::NotAuthorized)
-        render_error 403
-      else
-        session[:error_report] = @error_id = write_error(
-          error_report(exception).to_yaml
-        )
-        logger.error "Logged error #{@error_id}"
-
-        render_error 500
-      end
-    rescue => error
-      logger.fatal "Error in handle_exception"
-      log_error(error)
-      render(template: "errors/500_critical", status: 500, layout: false)
-      return
-    end
-  end
-end

data/app/helpers/pages_core/login_helper.rb

@@ -1,14 +0,0 @@
-module PagesCore
-  module LoginHelper
-    def login_form(success_url:, login_url:)
-      render(
-        partial: "admin/users/login_form",
-        locals: { success_url: success_url, login_url: login_url }
-      )
-    end
-
-    def logout_link(name, login_url:)
-      link_to name, session_path(login_url: login_url), method: "delete"
-    end
-  end
-end

data/app/indices/page_file_index.rb

@@ -1,9 +0,0 @@
-ThinkingSphinx::Index.define :page_file, with: :real_time do
-  indexes name
-  indexes filename
-
-  has page_id,    type: :integer
-  has created_at, type: :timestamp
-  has updated_at, type: :timestamp
-  has published,  type: :boolean
-end

data/app/indices/page_index.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-ThinkingSphinx::Index.define :page, with: :real_time do
-  indexes localization_values
-  indexes category_names
-  indexes tag_list
-  indexes author.name,  as: :author_name
-  indexes author.email, as: :author_email
-  indexes comment_names
-  indexes comment_bodies
-  indexes file_names
-  indexes file_filenames
-
-  has category_ids,   type: :integer, multi: true
-  has tag_ids,        type: :integer, multi: true
-
-  has published_at,   type: :timestamp
-  has created_at,     type: :timestamp
-  has updated_at,     type: :timestamp
-  has user_id,        type: :integer
-  has parent_page_id, type: :integer
-  has status,         type: :integer
-  has template,       type: :string
-  has autopublish,    type: :boolean
-  has feed_enabled,   type: :boolean
-  has published,      type: :boolean
-
-  set_property group_concat_max_len: 16.megabytes
-end