pages_core 3.4.2

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module PagesCore
+  module Taggable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :taggings, as: :taggable, dependent: :destroy
+      has_many :tags, through: :taggings
+    end
+
+    module ClassMethods
+      def tagged_with(*tags)
+        all
+          .includes(:tags)
+          .where("tags.name IN (?)", Tag.parse(tags))
+          .references(:tags)
+      end
+    end
+
+    def serialized_tags
+      tags.order("name ASC").map(&:name).to_json
+    end
+
+    def serialized_tags=(json)
+      tag_with(ActiveSupport::JSON.decode(json))
+    end
+
+    def tag_with(*list)
+      Tag.transaction do
+        taggings.destroy_all
+        Tag.parse(list).each do |name|
+          Tag.find_or_create_by(name: name).on(self)
+        end
+      end
+    end
+
+    def tag_list=(tag_list)
+      tag_with(tag_list)
+    end
+
+    def tag_list
+      tags.order("name ASC").map(&:name).join(", ")
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module PagesCore
+  module Templateable
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :ensure_template
+    end
+
+    def template_config
+      PagesCore::Templates::TemplateConfiguration.new(template)
+    end
+
+    def template
+      !self[:template].blank? ? self[:template] : 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 inherited_or_default_template
+      default_options = PagesCore::Templates.configuration.get(
+        :default, :template, :options
+      )
+      if parent
+        t = parent.default_subtemplate
+      elsif default_options && default_options[:root]
+        t = default_options[:root]
+      elsif default_template
+        t = default_template
+      end
+      t ||= :index
+      t.to_s
+    end
+
+    def ensure_template
+      self[:template] ||= inherited_or_default_template
+    end
+  end
+end

data/app/models/image.rb

@@ -0,0 +1,23 @@
+class Image < ActiveRecord::Base
+  include DynamicImage::Model
+
+  localizable do
+    attribute :alternative
+    attribute :caption
+  end
+
+  def byline
+    ActiveSupport::Deprecation.warn "Image#byline is deprecated, use #caption"
+    caption
+  end
+
+  def byline?
+    ActiveSupport::Deprecation.warn "Image#byline? is deprecated, use #caption?"
+    caption?
+  end
+
+  def byline=(new_caption)
+    ActiveSupport::Deprecation.warn "Image#byline= is deprecated, use #caption="
+    self.caption = new_caption
+  end
+end

data/app/models/invite.rb

@@ -0,0 +1,33 @@
+class Invite < ActiveRecord::Base
+  include PagesCore::HasRoles
+
+  belongs_to :user
+  has_many :roles, class_name: "InviteRole", dependent: :destroy
+
+  before_validation :ensure_token
+
+  validates :user_id, presence: true
+
+  validates :email,
+            presence: true,
+            format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i },
+            uniqueness: { case_sensitive: false }
+
+  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
+    self.token ||= SecureRandom.hex(32)
+  end
+end

data/app/models/invite_role.rb

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

data/app/models/localization.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+class Localization < ActiveRecord::Base
+  belongs_to :localizable, polymorphic: true
+
+  class << self
+    def locales
+      select("DISTINCT locale").map(&:locale)
+    end
+
+    def names
+      select("DISTINCT name").map(&:name)
+    end
+  end
+
+  def to_s
+    value || ""
+  end
+
+  def empty?
+    to_s.empty?
+  end
+
+  def translate(locale)
+    localizable.localizations.where(name: name, locale: locale).first
+  end
+end

data/app/models/page.rb

@@ -0,0 +1,281 @@
+# encoding: utf-8
+
+class Page < ActiveRecord::Base
+  include PagesCore::HumanizableParam
+  include PagesCore::PageTree
+  include PagesCore::SearchablePage
+  include PagesCore::Sweepable
+  include PagesCore::Taggable
+  include PagesCore::Templateable
+
+  belongs_to :author, class_name: "User", foreign_key: :user_id
+
+  has_and_belongs_to_many :categories, join_table: "pages_categories"
+
+  belongs_to_image :image
+  belongs_to_image :meta_image, class_name: "Image"
+
+  has_many :page_images, -> { order("position") }
+
+  has_many :images,
+           -> { where("`page_images`.`primary` = ?", false).order("position") },
+           through: :page_images
+
+  has_many :comments,
+           class_name: "PageComment",
+           dependent: :destroy
+
+  has_many :page_files,
+           -> { order("position ASC") },
+           class_name: "PageFile",
+           dependent: :destroy
+
+  acts_as_list scope: :parent_page
+
+  localizable do
+    attribute :name
+    attribute :body
+    attribute :excerpt
+    attribute :headline
+    attribute :boxout
+
+    attribute :meta_description
+    attribute :open_graph_title
+    attribute :open_graph_description
+
+    dictionary -> { PagesCore::Templates::TemplateConfiguration.all_blocks }
+  end
+
+  validates_format_of :redirect_to,
+                      with: %r{\A(/|https?://)},
+                      allow_nil: true,
+                      allow_blank: true
+
+  validates_format_of :unique_name,
+                      with: /\A[\w\d_\-]+\z/,
+                      allow_nil: true,
+                      allow_blank: true
+
+  validates_uniqueness_of :unique_name, allow_nil: true, allow_blank: true
+
+  validates :template, presence: true
+  validates :content_order, presence: true
+  validates :published_at, presence: true
+
+  before_validation :published_at
+  before_validation :set_autopublish
+  before_validation :set_content_order
+  after_save :ensure_page_images_contains_primary_image
+  after_save :queue_autopublisher
+  after_save ThinkingSphinx::RealTime.callback_for(:page)
+
+  scope :by_date,    -> { order("published_at DESC") }
+  scope :published,  -> { where(status: 2, autopublish: false) }
+  scope :visible,    -> { where("status < 4") }
+  scope :news_pages, -> { visible.where(news_page: true) }
+  scope :pinned,     -> { where(pinned: true) }
+
+  class << self
+    def archive_finder
+      PagesCore::ArchiveFinder.new(all, timestamp: :published_at)
+    end
+
+    # Find all published and feed enabled pages
+    def enabled_feeds(locale, options = {})
+      conditions = (options[:include_hidden]) ? "status IN (2,3)" : "status = 2"
+      Page.where(feed_enabled: true).where(conditions).localized(locale)
+    end
+
+    def status_labels
+      {
+        0 => "Draft",
+        1 => "Reviewed",
+        2 => "Published",
+        3 => "Hidden",
+        4 => "Deleted"
+      }
+    end
+
+    def order_by_tags(tags)
+      joins(
+        "LEFT JOIN taggings ON taggings.taggable_id = pages.id AND " \
+          "taggable_type = \"Page\"",
+        "LEFT JOIN tags ON tags.id = taggings.tag_id AND tags.id IN (" +
+          tags.map(&:id).join(",") +
+          ")"
+      )
+        .group("pages.id, localizations.id")
+        .reorder("COUNT(tags.id) DESC, position ASC")
+    end
+  end
+
+  def comments_closed_after_time?
+    if PagesCore.config.close_comments_after.nil?
+      false
+    else
+      (Time.now - published_at) > PagesCore.config.close_comments_after
+    end
+  end
+
+  def comments_allowed?
+    if self.comments_closed_after_time?
+      false
+    else
+      self[:comments_allowed]
+    end
+  end
+
+  def extended?
+    excerpt? && body?
+  end
+
+  def empty?
+    !body? && !excerpt?
+  end
+  alias_method :blank?, :empty?
+
+  def excerpt_or_body
+    excerpt? ? excerpt : body
+  end
+
+  def image
+    super.try { |i| i.localize(locale) }
+  end
+
+  def images
+    super.in_locale(locale)
+  end
+
+  def page_images
+    super.in_locale(locale)
+  end
+
+  def files
+    page_files.in_locale(locale)
+  end
+
+  def headline_or_name
+    headline? ? headline : name
+  end
+
+  # Does this page have an image?
+  def image?
+    self.image_id?
+  end
+
+  # Get subpages
+  def pages(_options = nil)
+    if self.locale?
+      subpages.published.localized(locale)
+    else
+      subpages.published
+    end
+  end
+
+  def subpages
+    children.order(pinned_content_order)
+  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
+
+  # Get publication date, which defaults to the creation date
+  def published_at
+    if self.created_at?
+      self[:published_at] ||= created_at
+    else
+      self[:published_at] ||= Time.now
+    end
+  end
+
+  # Returns boolean true if page has a valid redirect
+  def redirects?
+    self.redirect_to?
+  end
+
+  def redirect_path(params = {})
+    path = redirect_to.dup
+    if path.start_with? "/"
+      params.each do |key, value|
+        unless value.is_a?(String) || value.is_a?(Symbol)
+          fail "redirect_url param must be a string or a symbol"
+        end
+        path.gsub!("/:#{key}", "/#{value}")
+      end
+    end
+    path
+  end
+
+  # Returns true if this page's children is reorderable
+  def reorderable_children?
+    !self.content_order? || content_order =~ /position/
+  end
+
+  # Returns true if this page is reorderable
+  def reorderable?
+    !parent || !parent.content_order? || parent.content_order =~ /position/
+  end
+
+  def draft?
+    status == 0
+  end
+
+  def reviewed?
+    status == 1
+  end
+
+  def published?
+    status == 2 && !autopublish?
+  end
+
+  def hidden?
+    status == 3
+  end
+
+  def deleted?
+    status == 4
+  end
+
+  def to_param
+    humanized_param(name)
+  end
+
+  def content_order
+    self[:content_order] || "position"
+  end
+
+  private
+
+  def ensure_page_images_contains_primary_image
+    return if !image_id? || !image_id_changed?
+    page_image = page_images.where(image_id: image_id).first
+    if page_image
+      page_image.update(primary: true)
+    else
+      page_images.create(image_id: image_id, primary: true)
+    end
+  end
+
+  def pinned_content_order
+    self.news_page? ? "pages.pinned DESC, #{content_order}" : content_order
+  end
+
+  def set_autopublish
+    self.autopublish = published_at? && published_at > Time.now
+    true
+  end
+
+  def set_content_order
+    self[:content_order] ||= "position"
+  end
+
+  def queue_autopublisher
+    Autopublisher.queue! if self.autopublish?
+  end
+end

data/app/models/page_builder.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+# # PageBuilder
+#
+# PageBuilder is a simple DSL for building pages, for use in ie. seeds.rb
+#
+# Example:
+#
+#   PageBuilder.build(User.first) do
+#     page "Home", template: "home"
+#     page "Products" do
+#       page "Product 1"
+#       page "Product 2"
+#     end
+#     page "Contact", unique_name: "contact"
+#   end
+class PageBuilder
+  attr_reader :user, :locale, :parent
+
+  class << self
+    def build(user, locale: nil, parent: nil, &block)
+      new(user, locale: locale, parent: parent)
+        .run(&block)
+    end
+  end
+
+  def initialize(user, locale: nil, parent: nil)
+    @user = user
+    @locale = locale || I18n.default_locale
+    @parent = parent
+  end
+
+  def page(name, options={}, &block)
+    page = Page.create(
+      { name: name }
+        .merge(default_options)
+        .merge(options)
+    )
+    if block_given?
+      self.class
+        .new(user, locale: locale, parent: page)
+        .run(&block)
+    end
+    page
+  end
+
+  def run(&block)
+    instance_eval(&block)
+  end
+
+  private
+
+  def default_options
+    {
+      author: user,
+      parent: parent,
+      status: 2,
+      locale: locale
+    }
+  end
+end

data/app/models/page_comment.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+class PageComment < ActiveRecord::Base
+  include PagesCore::Sweepable
+
+  belongs_to :page, counter_cache: :comments_count
+  attr_accessor :invalid_captcha
+
+  def valid_captcha?
+    (invalid_captcha) ? false : true
+  end
+
+  after_create do |page_comment|
+    if page_comment.page && page_comment.valid?
+      page_comment.page.update(last_comment_at: page_comment.created_at)
+    end
+  end
+end

data/app/models/page_file.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+class PageFile < ActiveRecord::Base
+  include Dis::Model
+
+  belongs_to :page
+
+  validates_data_presence
+  validates :content_type, presence: true
+  validates :filename, presence: true
+  validates :content_length, presence: true
+
+  acts_as_list scope: :page
+
+  localizable do
+    attribute :description
+  end
+
+  before_validation :set_name_from_filename
+
+  after_save ThinkingSphinx::RealTime.callback_for(:page_file)
+
+  class << self
+    def formats
+      {
+        "audio/mpeg"      => :mp3,
+        "image/gif"       => :gif,
+        "image/jpeg"      => :jpg,
+        "image/jpg"       => :jpg,
+        "image/pjpeg"     => :jpg,
+        "image/png"       => :png,
+        "application/pdf" => :pdf
+      }
+    end
+  end
+
+  def format?
+    content_type && self.class.formats.keys.include?(content_type)
+  end
+
+  def format
+    self.class.formats[content_type]
+  end
+
+  def filename_extension
+    if filename_extension?
+      filename.match(/\.([^\.]+)$/)[1]
+    else
+      ""
+    end
+  end
+
+  def filename_extension?
+    filename =~ /\./
+  end
+
+  def to_param
+    if filename_extension?
+      "#{id}.#{filename_extension}"
+    else
+      "#{id}"
+    end
+  end
+
+  def published
+    page.published
+  end
+
+  private
+
+  def set_name_from_filename
+    self.name = File.basename(filename, ".*") if self.filename? && !self.name?
+  end
+end