alchemy_cms 5.2.0.rc1 → 6.0.0.b2

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

@@ -3,110 +3,125 @@
 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 pages of given page layout
+        #
+        scope :by_page_layout, ->(page_layout) { where(page_layout: page_layout) }
+
+        # 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

data/app/models/alchemy/page_version.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class PageVersion < BaseRecord
+    belongs_to :page, class_name: "Alchemy::Page", inverse_of: :versions
+
+    has_many :elements, -> { order(:position) },
+      class_name: "Alchemy::Element",
+      inverse_of: :page_version
+
+    scope :drafts, -> { where(public_on: nil).order(updated_at: :desc) }
+    scope :published, -> { where.not(public_on: nil).order(public_on: :desc) }
+
+    def self.public_on(time = Time.current)
+      where("#{table_name}.public_on <= :time AND " \
+            "(#{table_name}.public_until IS NULL " \
+            "OR #{table_name}.public_until >= :time)", time: time)
+    end
+
+    before_destroy :delete_elements
+
+    # Determines if this version is public
+    #
+    # Takes the two timestamps +public_on+ and +public_until+
+    # and returns true if the time given (+Time.current+ per default)
+    # is in this timespan.
+    #
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def public?(time = Time.current)
+      already_public_for?(time) && still_public_for?(time)
+    end
+
+    # Determines if this version is already public for given time
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def already_public_for?(time = Time.current)
+      !public_on.nil? && public_on <= time
+    end
+
+    # Determines if this version is still public for given time
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def still_public_for?(time = Time.current)
+      public_until.nil? || public_until >= time
+    end
+
+    def element_repository
+      ElementsRepository.new(elements.includes({ contents: :essence }, :tags))
+    end
+
+    private
+
+    def delete_elements
+      DeleteElements.new(elements).call
+    end
+  end
+end

data/app/models/alchemy/picture.rb

@@ -86,12 +86,14 @@ module Alchemy
     dragonfly_accessor :image_file, app: :alchemy_pictures do
       # Preprocess after uploading the picture
       after_assign do |image|
-        self.class.preprocessor_class.new(image).call
+        if has_convertible_format?
+          self.class.preprocessor_class.new(image).call
+        end
       end
     end
 
     # Create important thumbnails upfront
-    after_create -> { PictureThumb.generate_thumbs!(self) }
+    after_create -> { PictureThumb.generate_thumbs!(self) if has_convertible_format? }
 
     # We need to define this method here to have it available in the validations below.
     class << self
@@ -114,6 +116,7 @@ module Alchemy
     scope :recent, -> { where("#{table_name}.created_at > ?", Time.current - 24.hours).order(:created_at) }
     scope :deletable, -> { where("#{table_name}.id NOT IN (SELECT picture_id FROM #{EssencePicture.table_name})") }
     scope :without_tag, -> { left_outer_joins(:taggings).where(gutentag_taggings: { id: nil }) }
+    scope :by_file_format, ->(format) { where(image_file_format: format) }
 
     # Class methods
 
@@ -132,6 +135,19 @@ module Alchemy
         @_url_class = klass
       end
 
+      def alchemy_resource_filters
+        [
+          {
+            name: :by_file_format,
+            values: distinct.pluck(:image_file_format),
+          },
+          {
+            name: :misc,
+            values: %w(recent last_upload without_tag),
+          },
+        ]
+      end
+
       def searchable_alchemy_resource_attributes
         %w(name image_file_name)
       end
@@ -142,34 +158,6 @@ module Alchemy
 
         Picture.where(upload_hash: last_picture.upload_hash)
       end
-
-      def search_by(params, query, per_page = nil)
-        pictures = query.result
-
-        if params[:tagged_with].present?
-          pictures = pictures.tagged_with(params[:tagged_with])
-        end
-
-        if params[:filter].present?
-          pictures = pictures.filtered_by(params[:filter])
-        end
-
-        if per_page
-          pictures = pictures.page(params[:page] || 1).per(per_page)
-        end
-
-        pictures.order(:name)
-      end
-
-      def filtered_by(filter = "")
-        case filter
-        when "recent" then recent
-        when "last_upload" then last_upload
-        when "without_tag" then without_tag
-        else
-          all
-        end
-      end
     end
 
     # Instance methods
@@ -201,16 +189,6 @@ module Alchemy
       nil
     end
 
-    def previous(params = {})
-      query = Picture.ransack(params[:q])
-      Picture.search_by(params, query).where("name < ?", name).last
-    end
-
-    def next(params = {})
-      query = Picture.ransack(params[:q])
-      Picture.search_by(params, query).where("name > ?", name).first
-    end
-
     # Updates name and tag_list attributes.
     #
     # Used by +Admin::PicturesController#update_multiple+

data/app/models/alchemy/picture/calculations.rb

@@ -27,15 +27,9 @@ module Alchemy
       # Given a string with an x, this function returns a Hash with point
       # :width and :height.
       #
-      def sizes_from_string(string = "0x0")
-        string = "0x0" if string.nil? || string.empty?
+      def sizes_from_string(string)
+        width, height = string.to_s.split("x", 2).map(&:to_i)
 
-        raise ArgumentError unless string =~ /(\d*x\d*)/
-
-        width, height = string.scan(/(\d*)x(\d*)/)[0].map(&:to_i)
-
-        width = 0 if width.nil?
-        height = 0 if height.nil?
         {
           width: width,
           height: height,