pages_core 3.4.3 → 3.7.0

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Sortable
+      extend ActiveSupport::Concern
+
+      included do
+        acts_as_list scope: :parent_page
+        after_save :check_list_position
+      end
+
+      module ClassMethods
+        def order_by_tags(tags)
+          joins(
+            "LEFT JOIN taggings ON taggings.taggable_id = pages.id AND " \
+            "taggings.tag_id IN (#{tags.map(&:id).join(',')}) AND " \
+            "taggings.taggable_type = " \
+            "#{ActiveRecord::Base.connection.quote('Page')}"
+          )
+            .group("pages.id, localizations.id")
+            .reorder(Arel.sql("COUNT(taggings.id) DESC"))
+        end
+      end
+
+      def reorderable_children?
+        !news_page?
+      end
+
+      def reorderable?
+        !parent || !parent.news_page?
+      end
+
+      def content_order
+        if news_page?
+          "pages.pinned DESC, published_at DESC"
+        else
+          "position ASC"
+        end
+      end
+
+      private
+
+      def check_list_position
+        if deleted?
+          remove_from_list
+        elsif !position?
+          assume_bottom_position
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Status
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def status_labels
+          {
+            0 => "Draft",
+            1 => "Reviewed",
+            2 => "Published",
+            3 => "Hidden",
+            4 => "Deleted"
+          }
+        end
+      end
+
+      # Return the status of the page as a string
+      def status_label
+        self.class.status_labels[status]
+      end
+
+      def flag_as_deleted!
+        update(status: 4)
+      end
+
+      def draft?
+        status.zero?
+      end
+
+      def reviewed?
+        status == 1
+      end
+
+      def published?
+        status == 2 && !autopublish?
+      end
+
+      def hidden?
+        status == 3
+      end
+
+      def deleted?
+        status == 4
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Templateable
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :ensure_template
+      end
+
+      def template_config
+        PagesCore::Templates::TemplateConfiguration.new(template)
+      end
+
+      def template
+        return self[:template] if self[:template].present?
+
+        inherited_or_default_template
+      end
+
+      def default_subtemplate
+        template_config.value(:sub_template) ||
+          default_template ||
+          subtemplate_with_postfix ||
+          singularized_subtemplate ||
+          template
+      end
+
+      private
+
+      def singularized_subtemplate
+        singularized = ActiveSupport::Inflector.singularize(base_template)
+        return if base_template == singularized
+
+        find_template_by_expression(
+          Regexp.new("^#{Regexp.quote(singularized)}")
+        )
+      end
+
+      def subtemplate_with_postfix
+        find_template_by_expression(
+          Regexp.new(
+            "^#{Regexp.quote(base_template)}_?(post|page|subpage|item)"
+          )
+        )
+      end
+
+      def base_template
+        template.split(/_/)
+                .reject { |w| %w[index list archive liste arkiv].include?(w) }
+                .join(" ")
+      end
+
+      def default_template
+        configured = PagesCore::Templates.configuration.get(
+          :default, :template, :value
+        )
+        configured if configured != :autodetect
+      end
+
+      def find_template_by_expression(expr)
+        PagesCore::Templates.names
+                            .select { |t| t.match(expr) }
+                            .try(&:first)
+      end
+
+      def default_template_options
+        PagesCore::Templates.configuration.get(
+          :default, :template, :options
+        ) || {}
+      end
+
+      def inherited_or_default_template
+        return parent.default_subtemplate.to_s if parent
+
+        (default_template_options[:root] || default_template || :index).to_s
+      end
+
+      def ensure_template
+        self[:template] ||= inherited_or_default_template
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Tree
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :parent,
+                   class_name: "Page",
+                   foreign_key: :parent_page_id,
+                   inverse_of: :children,
+                   optional: true,
+                   touch: true
+
+        has_many :children,
+                 class_name: "Page",
+                 foreign_key: :parent_page_id,
+                 inverse_of: :parent,
+                 dependent: :destroy
+
+        # This must be included after the belongs_to call in order
+        # to override the .parent method.
+        include PagesCore::PageModel::Tree::InstanceMethods
+      end
+
+      module ClassMethods
+        def admin_list(locale)
+          left_outer_joins(:parent)
+            .where("pages.status < 4")
+            .order(admin_list_order).in_locale(locale)
+        end
+
+        def admin_list_order
+          Arel.sql(
+            <<-QUERY
+            pages.parent_page_id, parents_pages.news_page,
+            case when parents_pages.news_page
+              then pages.pinned end desc,
+            case when parents_pages.news_page
+              then pages.published_at end desc,
+            position asc
+            QUERY
+          )
+        end
+
+        # Returns all root pages
+        def roots
+          where(parent_page_id: nil).order("position ASC")
+        end
+
+        # Returns the first root page
+        def root
+          roots.first
+        end
+      end
+
+      module InstanceMethods
+        # Returns list of ancestors, starting from parent until root.
+        #
+        #   subchild1.ancestors # => [child1, root]
+        def ancestors
+          node = self
+          nodes = []
+          nodes << node = node.parent while node.parent
+          nodes
+        end
+
+        # Returns all children, recursively
+        def all_subpages
+          return nil unless subpages.any?
+
+          localized_subpages.map { |p| [p, p.all_subpages] }.flatten.compact
+        end
+
+        def localized_subpages
+          return subpages unless locale?
+
+          subpages.localized(locale)
+        end
+
+        # Finds the page's next sibling. Returns nil if there isn't one.
+        def next_sibling
+          return unless siblings.any?
+
+          siblings[(siblings.to_a.index(self) + 1)...siblings.length]
+            .try(&:first)
+        end
+
+        # Returns the pages parent
+        def parent
+          super.try { |node| node.localize(locale) }
+        end
+
+        # Get subpages
+        def pages(_options = nil)
+          localized_subpages.published
+        end
+
+        # Finds the page's next sibling. Returns nil if there isn't one.
+        def previous_sibling
+          return unless siblings.any?
+
+          siblings[0...siblings.to_a.index(self)].try(&:last)
+        end
+
+        # Returns the root node of the tree.
+        def root
+          self_and_ancestors.last
+        end
+
+        # Returns ancestors and current node itself.
+        #
+        #   subchild1.self_and_ancestors # => [subchild1, child1, root]
+        def self_and_ancestors
+          [self] + ancestors
+        end
+
+        # Returns all siblings, including self.
+        def siblings
+          if parent
+            parent.pages
+          else
+            self.class.roots.map { |node| node.localize(locale) }
+          end
+        end
+
+        def subpages
+          children.order(content_order)
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/sweepable.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Sweepable
@@ -14,9 +14,9 @@ module PagesCore
     protected
 
     def sweep_cache!
-      return unless PagesCore::CacheSweeper.enabled
       return if cache_swept
-      PagesCore::SweepCacheJob.perform_later
+
+      PagesCore::StaticCache.handler.sweep!
       self.cache_swept = true
     end
   end

data/app/models/concerns/pages_core/taggable.rb

@@ -1,11 +1,14 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Taggable
     extend ActiveSupport::Concern
 
     included do
-      has_many :taggings, as: :taggable, dependent: :destroy
+      has_many :taggings,
+               as: :taggable,
+               dependent: :destroy,
+               inverse_of: :taggable
       has_many :tags, through: :taggings
     end
 
@@ -13,7 +16,7 @@ module PagesCore
       def tagged_with(*tags)
         all
           .includes(:tags)
-          .where("tags.name IN (?)", Tag.parse(tags))
+          .where(tags: { name: Tag.parse(tags) })
           .references(:tags)
       end
     end
@@ -40,7 +43,11 @@ module PagesCore
     end
 
     def tag_list
-      tags.order("name ASC").map(&:name).join(", ")
+      tag_names.join(", ")
+    end
+
+    def tag_names
+      tags.map(&:name).sort
     end
   end
 end

data/app/models/image.rb

@@ -1,5 +1,10 @@
-class Image < ActiveRecord::Base
+# frozen_string_literal: true
+
+class Image < ApplicationRecord
   include DynamicImage::Model
+  include PagesCore::Sweepable
+
+  validate :ensure_max_size, on: :create
 
   localizable do
     attribute :alternative
@@ -20,4 +25,13 @@ class Image < ActiveRecord::Base
     ActiveSupport::Deprecation.warn "Image#byline= is deprecated, use #caption="
     self.caption = new_caption
   end
+
+  private
+
+  def ensure_max_size
+    return unless real_width? && real_height?
+    return if real_width * real_height <= 48_000_000
+
+    errors.add(:data, "is too large")
+  end
 end

data/app/models/invite.rb

@@ -1,4 +1,6 @@
-class Invite < ActiveRecord::Base
+# frozen_string_literal: true
+
+class Invite < ApplicationRecord
   include PagesCore::HasRoles
 
   belongs_to :user
@@ -15,16 +17,6 @@ class Invite < ActiveRecord::Base
 
   validates :token, presence: true
 
-  def create_user(attributes)
-    user = User.create(attributes.merge(
-                         role_names: role_names,
-                         creator: self.user,
-                         activated: true
-    ))
-    destroy if user.valid?
-    user
-  end
-
   private
 
   def ensure_token

data/app/models/invite_role.rb

@@ -1,9 +1,11 @@
-class InviteRole < ActiveRecord::Base
+# frozen_string_literal: true
+
+class InviteRole < ApplicationRecord
   belongs_to :invite
   validates :name,
-            presence:   true,
+            presence: true,
             uniqueness: { scope: :invite_id },
-            inclusion:  { in: proc { Role.roles.map(&:name) } }
+            inclusion: { in: proc { Role.roles.map(&:name) } }
 
   def to_s
     name.humanize