pages_core 3.5.1 → 3.6.0

data/app/controllers/admin/page_images_controller.rb

@@ -1,111 +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
-      respond_with_page_image(@page_image)
-    end
-
-    def update
-      if @page_image.update(page_image_params)
-        respond_with_page_image(@page_image)
-      else
-        render action: :edit
-      end
-    end
-
-    def destroy
-      @page_image.destroy
-      respond_with_page_image(@page_image)
-    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
-
-    def respond_with_page_image(page_image)
-      respond_to do |format|
-        format.html do
-          redirect_to(admin_page_path(@locale, @page, anchor: "images"))
-        end
-        format.json do
-          render json: page_image.to_json
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# encoding: utf-8
-
-module PagesCore
-  module AddCommentsController
-    extend ActiveSupport::Concern
-
-    # Add a comment to a page. Recaptcha is performed if
-    # PagesCore.config(:recaptcha) is set.
-    def add_comment
-      @comment = new_comment(@page)
-
-      unless captcha_verified?
-        @comment.invalid_captcha = true
-        render_page
-        return
-      end
-
-      return unless @page.comments_allowed? && !honeypot_triggered?
-
-      @comment.save
-      deliver_comment_notifications(@page, @comment)
-      redirect_to(page_url(@locale, @page))
-    end
-
-    private
-
-    def captcha_verified?
-      !PagesCore.config(:recaptcha) || verify_recaptcha
-    end
-
-    def comment_recipients(page)
-      PagesCore.config(:comment_notifications)
-               .map { |r| r == :author ? page.author.name_and_email : r }
-               .uniq
-    end
-
-    def deliver_comment_notifications(page, comment)
-      return unless PagesCore.config(:comment_notifications)
-      comment_recipients(page).each do |r|
-        AdminMailer.comment_notification(
-          r,
-          page,
-          comment,
-          page_url(locale, page)
-        ).deliver_now
-      end
-    end
-
-    def honeypot_triggered?
-      PagesCore.config(:comment_honeypot) && !params[:email].to_s.empty?
-    end
-
-    def new_comment(page)
-      PageComment.new(
-        page_comment_params.merge(remote_ip: remote_ip, page_id: page.id)
-      )
-    end
-
-    def page_comment_params
-      params.require(:page_comment).permit(:name, :email, :url, :body)
-    end
-
-    def remote_ip
-      request.env["REMOTE_ADDR"]
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-# encoding: utf-8
-
-module PagesCore
-  module ExceptionHandler
-    module Rescues
-      extend ActiveSupport::Concern
-
-      included do
-        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
-
-    extend ActiveSupport::Concern
-
-    included do
-      unless Rails.application.config.consider_all_requests_local
-        include PagesCore::ExceptionHandler::Rescues
-      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] = error_layout(error) unless options.key?(:layout)
-      @email = logged_in? ? current_user.email : ""
-      render options
-      true
-    end
-
-    protected
-
-    def error_layout(error)
-      if error == 404 && PagesCore.config.error_404_layout?
-        PagesCore.config.error_404_layout
-      else
-        "errors"
-      end
-    end
-
-    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.utc,
-        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_critical_exception(exception)
-      logger.fatal "Error in handle_exception"
-      log_error(exception)
-      render(template: "errors/500_critical", status: 500, layout: false)
-    end
-
-    def handle_exception(exception)
-      log_error(exception)
-      return if handle_40x(exception)
-      @error_id = write_error(error_report(exception).to_yaml)
-      session[:error_report] = @error_id
-      logger.error "Logged error #{@error_id}"
-      render_error 500
-    rescue => error
-      handle_critical_exception(error)
-    end
-
-    private
-
-    def handle_40x(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
-        false
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-module PagesCore
-  module SearchPagesController
-    extend ActiveSupport::Concern
-
-    def search
-      @search_query = params[:q] || params[:query] || ""
-      @search_category_id = params[:category_id]
-
-      @pages = Page.search(
-        normalize_search_query(@search_query),
-        search_options(category_id: @search_category_id)
-      )
-      @pages.each { |p| p.localize!(locale) }
-      @pages
-    end
-
-    private
-
-    def normalize_search_query(str)
-      str.split(/\s+/)
-         .map { |p| "#{p}*" }
-         .join(" ")
-    end
-
-    def search_options(category_id: nil)
-      options = {
-        page:      (params[:page] || 1).to_i,
-        per_page:  20,
-        include:   [:localizations, :categories, :image, :author],
-        order:     :published_at,
-        sort_mode: :desc,
-        with:      { status: 2, autopublish: 0 }
-      }
-      options[:with][:category_ids] = category_id unless category_id.blank?
-      options
-    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

data/app/indices/user_index.rb

@@ -1,11 +0,0 @@
-# encoding: utf-8
-
-ThinkingSphinx::Index.define :user, with: :real_time do
-  indexes username
-  indexes name
-  indexes email
-
-  has last_login_at, type: :timestamp
-  has created_at, type: :timestamp
-  has activated, type: :boolean
-end

data/app/models/concerns/pages_core/page_model/commentable.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-module PagesCore
-  module PageModel
-    module Commentable
-      extend ActiveSupport::Concern
-
-      included do
-        has_many :comments, class_name: "PageComment", dependent: :destroy
-      end
-
-      def comments_closed_after_time?
-        if PagesCore.config.close_comments_after.nil?
-          false
-        else
-          (Time.now.utc - published_at) > PagesCore.config.close_comments_after
-        end
-      end
-
-      def comments_allowed?
-        if comments_closed_after_time?
-          false
-        else
-          self[:comments_allowed]
-        end
-      end
-    end
-  end
-end