pages_core 3.4.3 → 3.7.0

data/app/controllers/pages_core/frontend/pages_controller.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Frontend
@@ -7,113 +7,33 @@ module PagesCore
       include PagesCore::Templates::ControllerActions
       include PagesCore::HeadTagsHelper
 
-      caches_page :index if PagesCore.config(:page_cache)
+      include PagesCore::PreviewPagesController
+      include PagesCore::RssController
 
-      before_action :disable_xss_protection, only: [:preview]
       before_action :load_root_pages
-      before_action :find_page, only: [:show, :preview, :add_comment]
+      before_action :find_page_by_path, only: [:show]
+      before_action :find_page, only: %i[show preview]
+      before_action :require_page, only: %i[show preview]
       before_action :canonicalize_url, only: [:show]
-      after_action :cache_page_request, only: [:show]
+      static_cache :index, :show
 
       def index
         respond_to do |format|
-          format.html do
-            if self.respond_to?(:no_page_given)
-              no_page_given
-            elsif root_pages.any?
-              @page = root_pages.first
-              render_page
-            else
-              render_error 404
-            end
-          end
-          format.rss do
-            render_rss(all_feed_items)
-          end
+          format.html { render_published_page(root_pages.try(&:first)) }
+          format.rss { render_rss(all_feed_items) }
         end
       end
 
       def show
         respond_to do |format|
-          format.html do
-            if @page && @page.published?
-              render_page
-            else
-              render_error 404
-            end
-          end
-          format.rss do
-            render_rss(
-              @page.pages.limit(20),
-              title: "#{PagesCore.config(:side_name)}: #{@page.name}"
-            )
-          end
-          format.json do
-            render json: @page
-          end
+          format.html { render_published_page(@page) }
+          format.rss { render_rss(@page.pages.limit(20), title: @page.name) }
+          format.json { render json: @page }
         end
       end
 
-      # 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
-
-        if @page.comments_allowed? && !honeypot_triggered?
-          @comment.save
-          if PagesCore.config(:comment_notifications)
-            deliver_comment_notifications(@page, @comment)
-          end
-        end
-
-        redirect_to(page_url(@locale, @page))
-      end
-
-      # Search pages
-      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
-
-      def preview
-        redirect_to(page_url(@locale, @page)) && return unless logged_in?
-
-        @page.attributes = page_params.merge(
-          status: 2,
-          published_at: Time.now,
-          locale: @locale,
-          redirect_to: nil
-        )
-
-        render_page
-      end
-
       private
 
-      def all_feed_items
-        Page
-          .where(
-            parent_page_id: Page.enabled_feeds(locale, include_hidden: true)
-          )
-          .order("published_at DESC")
-          .published
-          .limit(20)
-          .localized(locale)
-      end
-
       def canonical_path(page)
         if page.redirects?
           page.redirect_path(locale: page.locale)
@@ -123,22 +43,12 @@ module PagesCore
       end
 
       def canonicalize_url
-        unless @page.redirects?
-          if request.path != canonical_path(@page)
-            redirect_to canonical_path(@page)
-          end
-        end
-      end
-
-      def disable_xss_protection
-        # Disabling this is probably not a good idea,
-        # but the header causes Chrome to choke when being
-        # redirected back after a submit and the page contains an iframe.
-        response.headers['X-XSS-Protection'] = "0"
-      end
+        return if @page.redirects?
+        return if request.path == canonical_path(@page)
+        # Don't canonicalize if any unknown params are present
+        return if (params.keys - %w[controller action path locale id]).any?
 
-      def preview?
-        @page.new_record?
+        redirect_to(canonical_path(@page), status: :moved_permanently)
       end
 
       def render(*args)
@@ -151,10 +61,6 @@ module PagesCore
         super
       end
 
-      def rendered?
-        @already_rendered ? true : false
-      end
-
       def page_template(page)
         if PagesCore::Templates.names.include?(page.template)
           page.template
@@ -164,144 +70,49 @@ module PagesCore
       end
 
       def render_page
-        if @page.redirects?
-          redirect_to(@page.redirect_path(locale: @locale))
-          return
-        end
+        return if redirect_page(@page)
 
         unless document_title?
-          if @page.meta_title?
-            document_title(@page.meta_title)
-          else
-            document_title(@page.name)
-          end
+          document_title(@page.meta_title? ? @page.meta_title : @page.name)
         end
 
-        # Call template method
         template = page_template(@page)
-
         run_template_actions_for(template, @page)
+        return if @already_rendered
 
-        @page_template_layout = false if @disable_layout
-
-        return if rendered?
-
-        if instance_variables.include?("@page_template_layout")
-          render(
-            template: "pages/templates/#{template}",
-            layout: @page_template_layout
-          )
-        else
-          render template: "pages/templates/#{template}"
-        end
-      end
-
-      # Cache pages by hand. This is dirty, but it works.
-      def cache_page_request
-        status_code = response.status.try(&:to_i)
-        unless status_code == 200 &&
-            PagesCore.config(:page_cache) &&
-            @page && @locale
-          return
-        end
-
-        self.class.cache_page response.body, request.path
-      end
-
-      def permitted_page_attributes
-        [
-          :template, :user_id, :status, :content_order,
-          :feed_enabled, :published_at, :redirect_to, :comments_allowed,
-          :image_link, :news_page, :unique_name, :pinned,
-          :parent_page_id
-        ]
-      end
-
-      def page_params
-        params.require(:page).permit(
-          Page.localized_attributes + permitted_page_attributes
-        )
-      end
-
-      def captcha_verified?
-        !PagesCore.config(:recaptcha) || verify_recaptcha
-      end
-
-      def honeypot_triggered?
-        PagesCore.config(:comment_honeypot) && !params[:email].to_s.empty?
-      end
-
-      def remote_ip
-        request.env["REMOTE_ADDR"]
+        render template: "pages/templates/#{template}"
       end
 
-      def new_comment(page)
-        PageComment.new(
-          page_comment_params.merge(remote_ip: remote_ip, page_id: page.id)
-        )
-      end
+      def find_page_by_path
+        return unless params[:path]
 
-      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)
-        comment_recipients(page).each do |r|
-          AdminMailer.comment_notification(
-            r,
-            page,
-            comment,
-            page_url(locale, page)
-          ).deliver_now
-        end
+        @page = PagePath.get(locale, params[:path]).try(&:page)
       end
 
       def find_page
-        @page ||= find_page_by_id(params[:id]) || unique_page(params[:id])
-        @page.locale = @locale || I18n.default_locale.to_s
+        @page ||= Page.find_by(id: params[:id]) || unique_page(params[:id])
+        @page.locale = @locale || I18n.default_locale.to_s if @page
       end
 
-      def find_page_by_id(id)
-        Page.find(id)
-      rescue
-        nil
+      def render_published_page(page)
+        if page&.published?
+          @page = page
+          render_page
+        else
+          render_error 404
+        end
       end
 
-      def page_comment_params
-        params.require(:page_comment).permit(:name, :email, :url, :body)
-      end
+      def redirect_page(page)
+        return false unless page.redirects?
 
-      def normalize_search_query(str)
-        str
-          .split(/\s+/)
-          .map { |p| "#{p}*" }
-          .join(" ")
+        redirect_to(page.redirect_path(locale: locale))
       end
 
-      def render_rss(items, title: nil)
-        @items, @title = items, title
-        response.headers["Content-Type"] = "application/rss+xml;charset=utf-8"
-        render template: "feeds/pages", layout: false
-      end
+      def require_page
+        return if @page
 
-      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
-          }
-        }
-        unless category_id.blank?
-          options[:with][:category_ids] = category_id
-        end
-        options
+        render_error 404
       end
     end
   end

data/app/controllers/pages_core/frontend_controller.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # Abstract controller for all frontend controllers.
 module PagesCore
@@ -19,16 +19,23 @@ module PagesCore
 
     private
 
-    def set_i18n_locale
-      legacy_locales = {
+    def legacy_locales
+      {
         "nor" => "nb",
         "eng" => "en"
       }
+    end
+
+    def set_i18n_locale
       locale_param = params[:locale] || I18n.default_locale
       if legacy_locales[locale_param]
         locale_param = legacy_locales[locale_param]
       end
       I18n.locale = locale_param
+    rescue I18n::InvalidLocale
+      raise if Rails.application.config.consider_all_requests_local
+
+      render_error 404
     end
   end
 end

data/app/controllers/pages_core/images_controller.rb

@@ -1,10 +1,10 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   class ImagesController < ::ApplicationController
     include DynamicImage::Controller
 
-    caches_page :show, :uncropped, :original
+    static_cache :show, :uncropped, :original, permanent: true
 
     private
 

data/app/controllers/pages_core/sitemaps_controller.rb

@@ -1,8 +1,9 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
-  class SitemapsController < ApplicationController
-    caches_page :show
+  class SitemapsController < ::ApplicationController
+    include PagesCore::PagePathHelper
+    static_cache :show
 
     def show
       @entries = formatted_entries
@@ -11,7 +12,7 @@ module PagesCore
     private
 
     def format_time(timestamp)
-      if timestamp.kind_of?(Date)
+      if timestamp.is_a?(Date)
         timestamp.strftime("%Y-%m-%d")
       else
         timestamp.strftime("%Y-%m-%dT%H:%M:%S#{timestamp.formatted_offset}")
@@ -38,18 +39,18 @@ module PagesCore
     end
 
     def localized?(record)
-      record.is_a?(PagesCore::Localizable::InstanceMethods)
+      record.is_a?(LocalizableModel::InstanceMethods)
     end
 
     def pages
-      ([Page.root.localize(I18n.default_locale)] +
-        locales.flat_map do |locale|
-        Page.published.localized(locale)
-      end).uniq
+      ([Page.root.try(:localize, I18n.default_locale)] +
+       locales.flat_map do |locale|
+         Page.published.localized(locale).includes(:parent)
+       end).compact.uniq
     end
 
     def page_record_url(record)
-      if record == Page.root && record.locale == I18n.default_locale
+      if record == root_page && record.locale == I18n.default_locale
         root_url
       else
         page_url(record.locale, record)
@@ -69,5 +70,9 @@ module PagesCore
     def records
       pages
     end
+
+    def root_page
+      @root_page ||= Page.root
+    end
   end
 end

data/app/controllers/sessions_controller.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 class SessionsController < ::ApplicationController
   def create
@@ -6,18 +6,18 @@ class SessionsController < ::ApplicationController
     authenticate!(user) if user
 
     if logged_in?
-      redirect_to success_url
+      redirect_to admin_default_url
     else
       flash[:notice] = "The provided email address and password combination " \
         "was not valid"
-      redirect_to login_url
+      redirect_to login_admin_users_url
     end
   end
 
   def destroy
     flash[:notice] = "You have been logged out"
     deauthenticate!
-    redirect_to login_url
+    redirect_to login_admin_users_url
   end
 
   protected
@@ -25,14 +25,4 @@ class SessionsController < ::ApplicationController
   def find_user(username, password)
     User.authenticate(username, password: password) if username && password
   end
-
-  def success_url
-    # TODO: Validate URL
-    params[:success_url] || admin_default_url
-  end
-
-  def login_url
-    # TODO: Validate URL
-    params[:login_url] || login_admin_users_url
-  end
 end