alchemy_cms 5.3.1 → 6.0.0.b1

data/app/models/alchemy/page/page_natures.rb

@@ -1,171 +1,168 @@
 # frozen_string_literal: true
 
 module Alchemy
-  module Page::PageNatures
-    extend ActiveSupport::Concern
-
-    def public?
-      current_time = Time.current
-      already_public_for?(current_time) && still_public_for?(current_time)
-    end
-
-    def expiration_time
-      public_until? ? public_until - Time.current : nil
-    end
-
-    def taggable?
-      definition["taggable"] == true
-    end
+  class Page < BaseRecord
+    module PageNatures
+      extend ActiveSupport::Concern
+
+      # Determines if this page has a public version and this version is public.
+      #
+      # @see PageVersion#public?
+      # @returns Boolean
+      def public?
+        language.public? && !!public_version&.public?
+      end
 
-    deprecate :taggable?, deprecator: Alchemy::Deprecation
+      def expiration_time
+        public_until ? public_until - Time.current : nil
+      end
 
-    def rootpage?
-      !new_record? && parent_id.blank?
-    end
+      def taggable?
+        definition["taggable"] == true
+      end
 
-    def folded?(user_id)
-      return unless Alchemy.user_class < ActiveRecord::Base
+      deprecate :taggable?, deprecator: Alchemy::Deprecation
 
-      folded_pages.where(user_id: user_id, folded: true).any?
-    end
+      def rootpage?
+        !new_record? && parent_id.blank?
+      end
 
-    def contains_feed?
-      definition["feed"]
-    end
+      def folded?(user_id)
+        return unless Alchemy.user_class < ActiveRecord::Base
 
-    # Returns an Array of Alchemy roles which are able to edit this template
-    #
-    #     # config/alchemy/page_layouts.yml
-    #     - name: contact
-    #       editable_by:
-    #         - freelancer
-    #         - admin
-    #
-    # @returns Array
-    #
-    def has_limited_editors?
-      definition["editable_by"].present?
-    end
+        folded_pages.where(user_id: user_id, folded: true).any?
+      end
 
-    def editor_roles
-      return unless has_limited_editors?
+      def contains_feed?
+        definition["feed"]
+      end
 
-      definition["editable_by"]
-    end
+      # Returns an Array of Alchemy roles which are able to edit this template
+      #
+      #     # config/alchemy/page_layouts.yml
+      #     - name: contact
+      #       editable_by:
+      #         - freelancer
+      #         - admin
+      #
+      # @returns Array
+      #
+      def has_limited_editors?
+        definition["editable_by"].present?
+      end
 
-    # True if page locked_at timestamp and locked_by id are set
-    def locked?
-      locked_by? && locked_at?
-    end
+      def editor_roles
+        return unless has_limited_editors?
 
-    # Returns a Hash describing the status of the Page.
-    #
-    def status
-      {
-        public: public?,
-        locked: locked?,
-        restricted: restricted?,
-      }
-    end
+        definition["editable_by"]
+      end
 
-    # Returns the translated status for given status type.
-    #
-    # @param [Symbol] status_type
-    #
-    def status_title(status_type)
-      Alchemy.t(status[status_type].to_s, scope: "page_states.#{status_type}")
-    end
+      # True if page locked_at timestamp and locked_by id are set
+      def locked?
+        locked_by? && locked_at?
+      end
 
-    # Returns the self#page_layout definition from config/alchemy/page_layouts.yml file.
-    def definition
-      definition = PageLayout.get(page_layout)
-      if definition.nil?
-        log_warning "Page definition for `#{page_layout}` not found. Please check `page_layouts.yml` file."
-        return {}
+      # Returns a Hash describing the status of the Page.
+      #
+      def status
+        {
+          public: public?,
+          locked: locked?,
+          restricted: restricted?,
+        }
       end
-      definition
-    end
 
-    # Returns translated name of the pages page_layout value.
-    # Page layout names are defined inside the config/alchemy/page_layouts.yml file.
-    # Translate the name in your config/locales language yml file.
-    def layout_display_name
-      Alchemy.t(page_layout, scope: "page_layout_names")
-    end
+      # Returns the translated status for given status type.
+      #
+      # @param [Symbol] status_type
+      #
+      def status_title(status_type)
+        Alchemy.t(status[status_type].to_s, scope: "page_states.#{status_type}")
+      end
 
-    # Returns the name for the layout partial
-    #
-    def layout_partial_name
-      page_layout.parameterize.underscore
-    end
+      # Returns the self#page_layout definition from config/alchemy/page_layouts.yml file.
+      def definition
+        definition = PageLayout.get(page_layout)
+        if definition.nil?
+          log_warning "Page definition for `#{page_layout}` not found. Please check `page_layouts.yml` file."
+          return {}
+        end
+        definition
+      end
 
-    # Returns the key that's taken for cache path.
-    #
-    # Uses the +published_at+ value that's updated when the user publishes the page.
-    #
-    # If the page is the current preview it uses the updated_at value as cache key.
-    #
-    def cache_key
-      if Page.current_preview == self
-        "alchemy/pages/#{id}-#{updated_at}"
-      else
-        "alchemy/pages/#{id}-#{published_at}"
+      # Returns translated name of the pages page_layout value.
+      # Page layout names are defined inside the config/alchemy/page_layouts.yml file.
+      # Translate the name in your config/locales language yml file.
+      def layout_display_name
+        Alchemy.t(page_layout, scope: "page_layout_names")
       end
-    end
 
-    # We use the published_at value for the cache_key.
-    #
-    # If no published_at value is set yet, i.e. because it was never published,
-    # we return the updated_at value.
-    #
-    def published_at
-      read_attribute(:published_at) || updated_at
-    end
+      # Returns the name for the layout partial
+      #
+      def layout_partial_name
+        page_layout.parameterize.underscore
+      end
 
-    # Returns true if the page cache control headers should be set.
-    #
-    # == Disable Alchemy's page caching globally
-    #
-    #     # config/alchemy/config.yml
-    #     ...
-    #     cache_pages: false
-    #
-    # == Disable caching on page layout level
-    #
-    #     # config/alchemy/page_layouts.yml
-    #     - name: contact
-    #       cache: false
-    #
-    # == Note:
-    #
-    # This only sets the cache control headers and skips rendering of the page body,
-    # if the cache is fresh.
-    # This does not disable the fragment caching in the views.
-    # So if you don't want a page and it's elements to be cached,
-    # then be sure to not use <% cache element %> in the views.
-    #
-    # @returns Boolean
-    #
-    def cache_page?
-      return false unless caching_enabled?
-
-      page_layout = PageLayout.get(self.page_layout)
-      page_layout["cache"] != false && page_layout["searchresults"] != true
-    end
+      # Returns the key that's taken for cache path.
+      #
+      # Uses the +published_at+ value that's updated when the user publishes the page.
+      #
+      # If the page is the current preview it uses the updated_at value as cache key.
+      #
+      def cache_key
+        if Page.current_preview == self
+          "alchemy/pages/#{id}-#{updated_at}"
+        else
+          "alchemy/pages/#{id}-#{published_at}"
+        end
+      end
 
-    private
+      # We use the published_at value for the cache_key.
+      #
+      # If no published_at value is set yet, i.e. because it was never published,
+      # we return the updated_at value.
+      #
+      def published_at
+        read_attribute(:published_at) || updated_at
+      end
 
-    def caching_enabled?
-      Alchemy::Config.get(:cache_pages) &&
-        Rails.application.config.action_controller.perform_caching
-    end
+      # Returns true if the page cache control headers should be set.
+      #
+      # == Disable Alchemy's page caching globally
+      #
+      #     # config/alchemy/config.yml
+      #     ...
+      #     cache_pages: false
+      #
+      # == Disable caching on page layout level
+      #
+      #     # config/alchemy/page_layouts.yml
+      #     - name: contact
+      #       cache: false
+      #
+      # == Note:
+      #
+      # This only sets the cache control headers and skips rendering of the page body,
+      # if the cache is fresh.
+      # This does not disable the fragment caching in the views.
+      # So if you don't want a page and it's elements to be cached,
+      # then be sure to not use <% cache element %> in the views.
+      #
+      # @returns Boolean
+      #
+      def cache_page?
+        return false unless caching_enabled?
+
+        page_layout = PageLayout.get(self.page_layout)
+        page_layout["cache"] != false && page_layout["searchresults"] != true
+      end
 
-    def already_public_for?(time)
-      !public_on.nil? && public_on <= time
-    end
+      private
 
-    def still_public_for?(time)
-      public_until.nil? || public_until >= time
+      def caching_enabled?
+        Alchemy::Config.get(:cache_pages) &&
+          Rails.application.config.action_controller.perform_caching
+      end
     end
   end
 end

data/app/models/alchemy/page/page_scopes.rb

@@ -3,110 +3,121 @@
 module Alchemy
   # ActiveRecord scopes for Alchemy::Page
   #
-  module Page::PageScopes
-    extend ActiveSupport::Concern
-
-    included do
-      # All language root pages
-      #
-      scope :language_roots, -> { where(language_root: true) }
-
-      # All layout pages
-      #
-      scope :layoutpages, -> { where(layoutpage: true) }
-
-      # All locked pages
-      #
-      scope :locked, -> { where.not(locked_at: nil).where.not(locked_by: nil) }
-
-      # All pages locked by given user
-      #
-      scope :locked_by,
-        ->(user) {
-          if user.class.respond_to? :primary_key
-            locked.where(locked_by: user.send(user.class.primary_key))
-          end
-        }
-
-      # All not locked pages
-      #
-      scope :not_locked, -> { where(locked_at: nil, locked_by: nil) }
-
-      # All not restricted pages
-      #
-      scope :not_restricted, -> { where(restricted: false) }
-
-      # All restricted pages
-      #
-      scope :restricted, -> { where(restricted: true) }
-
-      # All pages that are a published language root
-      #
-      scope :public_language_roots,
-        -> {
-          published.language_roots.where(
-            language_code: Language.published.pluck(:language_code),
-          )
-        }
-
-      # Last 5 pages that where recently edited by given user
-      #
-      scope :all_last_edited_from,
-        ->(user) {
-          where(updater_id: user.id).order("updated_at DESC").limit(5)
-        }
-
-      # Returns all pages that have the given +language_id+
-      #
-      scope :with_language, ->(language_id) { where(language_id: language_id) }
-
-      # Returns all content pages.
-      #
-      scope :contentpages, -> { where(layoutpage: [false, nil]) }
-
-      # Returns all public contentpages that are not locked.
-      #
-      # Used for flushing all pages caches at once.
-      #
-      scope :flushables, -> { not_locked.published.contentpages }
-
-      # Returns all layoutpages that are not locked.
-      #
-      # Used for flushing all pages caches at once.
-      #
-      scope :flushable_layoutpages, -> { not_locked.layoutpages }
-
-      # All searchable pages
-      #
-      scope :searchables, -> { not_restricted.published.contentpages }
-
-      # All pages from +Alchemy::Site.current+
-      #
-      scope :from_current_site,
-        -> {
-          where(Language.table_name => { site_id: Site.current || Site.default }).joins(:language)
-        }
-
-      # All pages for xml sitemap
-      #
-      scope :sitemap, -> { from_current_site.published.contentpages.where(sitemap: true) }
-    end
-
-    module ClassMethods
-      # All public pages
-      #
-      def published
-        where("#{table_name}.public_on <= :time AND " \
-              "(#{table_name}.public_until IS NULL " \
-              "OR #{table_name}.public_until >= :time)", time: Time.current)
+  class Page < BaseRecord
+    module PageScopes
+      extend ActiveSupport::Concern
+
+      included do
+        # All language root pages
+        #
+        scope :language_roots, -> { where(language_root: true) }
+
+        # All layout pages
+        #
+        scope :layoutpages, -> { where(layoutpage: true) }
+
+        # All locked pages
+        #
+        scope :locked, -> { where.not(locked_at: nil).where.not(locked_by: nil) }
+
+        # All pages locked by given user
+        #
+        scope :locked_by,
+          ->(user) {
+            if user.class.respond_to? :primary_key
+              locked.where(locked_by: user.send(user.class.primary_key))
+            end
+          }
+
+        # All not locked pages
+        #
+        scope :not_locked, -> { where(locked_at: nil, locked_by: nil) }
+
+        # All not restricted pages
+        #
+        scope :not_restricted, -> { where(restricted: false) }
+
+        # All restricted pages
+        #
+        scope :restricted, -> { where(restricted: true) }
+
+        # All public pages
+        #
+        scope :published,
+          -> {
+            joins(:language, :versions).
+              merge(Language.published).
+              merge(PageVersion.public_on(Time.current))
+          }
+
+        # All pages that are a published language root
+        #
+        scope :public_language_roots,
+          -> {
+            published.language_roots.where(
+              language_code: Language.published.pluck(:language_code),
+            )
+          }
+
+        # Last 5 pages that where recently edited by given user
+        #
+        scope :all_last_edited_from,
+          ->(user) {
+            where(updater_id: user.id).order("updated_at DESC").limit(5)
+          }
+
+        # Returns all pages that have the given +language_id+
+        #
+        scope :with_language, ->(language_id) { where(language_id: language_id) }
+
+        # Returns all content pages.
+        #
+        scope :contentpages, -> { where(layoutpage: [false, nil]) }
+
+        # Returns all public contentpages that are not locked.
+        #
+        # Used for flushing all pages caches at once.
+        #
+        scope :flushables, -> { not_locked.published.contentpages }
+
+        # Returns all layoutpages that are not locked.
+        #
+        # Used for flushing all pages caches at once.
+        #
+        scope :flushable_layoutpages, -> { not_locked.layoutpages }
+
+        # All searchable pages
+        #
+        scope :searchables, -> { not_restricted.published.contentpages }
+
+        # All pages from +Alchemy::Site.current+
+        #
+        scope :from_current_site,
+          -> {
+            where(Language.table_name => { site_id: Site.current || Site.default }).joins(:language)
+          }
+
+        # All pages for xml sitemap
+        #
+        scope :sitemap, -> { from_current_site.published.contentpages.where(sitemap: true) }
       end
 
-      # All not public pages
-      #
-      def not_public
-        where("#{table_name}.public_on IS NULL OR " \
-              "#{table_name}.public_on >= :time OR " \
-              "#{table_name}.public_until <= :time", time: Time.current)
+      module ClassMethods
+        # All pages that do not have any public version
+        #
+        def not_public(time = Time.current)
+          where <<~SQL
+            alchemy_pages.id NOT IN (
+              SELECT alchemy_page_versions.page_id
+              FROM alchemy_page_versions
+              WHERE alchemy_page_versions.public_on <= '#{connection.quoted_date(time)}'
+              AND (
+                alchemy_page_versions.public_until IS NULL
+                OR alchemy_page_versions.public_until >= '#{connection.quoted_date(time)}'
+              )
+            )
+          SQL
+        end
       end
     end
   end

data/app/models/alchemy/page/publisher.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_dependency "alchemy/page"
+
+module Alchemy
+  class Page < BaseRecord
+    # Handles publishing of pages
+    class Publisher
+      def initialize(page)
+        @page = page
+      end
+
+      # Copies all currently visible elements to the public version of page
+      #
+      # Creates a new published version if none exists yet.
+      #
+      # Sends a publish notification to all registered publish targets
+      #
+      def publish!(public_on:)
+        Page.transaction do
+          version = public_version(public_on)
+          DeleteElements.new(version.elements).call
+
+          repository = page.draft_version.element_repository
+          ActiveRecord::Base.no_touching do
+            Element.acts_as_list_no_update do
+              repository.visible.not_nested.each.with_index(1) do |element, position|
+                Alchemy::DuplicateElement.new(element, repository: repository).call(
+                  page_version_id: version.id,
+                  position: position
+                )
+              end
+            end
+          end
+        end
+
+        Alchemy.publish_targets.each { |p| p.perform_later(page) }
+      end
+
+      private
+
+      attr_reader :page
+
+      # Load the pages public version or create one
+      def public_version(public_on)
+        page.public_version || page.versions.create!(public_on: public_on)
+      end
+    end
+  end
+end

data/app/models/alchemy/page/url_path.rb

@@ -29,7 +29,7 @@ module Alchemy
       def call
         if @page.language_root?
           language_root_path
-        elsif @site.languages.select(&:public?).length > 1
+        elsif @site.languages.count(&:public?) > 1
           page_path_with_language_prefix
         else
           page_path_with_leading_slash