pageflow 15.6.1 → 15.7.1

data/app/models/pageflow/audio_file_url_templates.rb

@@ -5,6 +5,7 @@ module Pageflow
         m4a: url_template(:m4a),
         mp3: url_template(:mp3),
         ogg: url_template(:ogg),
+        peak_data: url_template(:peak_data)
       }
     end
 
@@ -15,7 +16,9 @@ module Pageflow
     end
 
     def example_file
-      @example_file ||= AudioFile.new(id: 0, file_name: ':basename.mp3')
+      @example_file ||= AudioFile.new(id: 0,
+                                      file_name: ':basename.mp3',
+                                      peak_data_file_name: 'audio.json')
     end
   end
 end

data/app/models/pageflow/customized_theme.rb

@@ -0,0 +1,37 @@
+module Pageflow
+  # @api private
+  class CustomizedTheme < SimpleDelegator
+    def initialize(theme, overrides, files)
+      super(theme)
+      @options = __getobj__.options.deep_merge(overrides || {})
+      @files = files
+    end
+
+    attr_reader :options, :files
+
+    def self.find(entry:, theme:)
+      build(
+        entry: entry,
+        theme: theme,
+        theme_customization: Pageflow.theme_customizations.get(
+          account: entry.account,
+          entry_type_name: entry.type_name
+        )
+      )
+    end
+
+    def self.build(entry:, theme:, theme_customization:)
+      config = Pageflow.config_for(entry)
+
+      new(theme,
+          config.transform_theme_customization_overrides.call(
+            theme_customization.overrides,
+            entry
+          ),
+          config.transform_theme_customization_files.call(
+            theme_customization.selected_files.transform_values(&:urls),
+            entry
+          ))
+    end
+  end
+end

data/app/models/pageflow/draft_entry.rb

@@ -1,42 +1,13 @@
 module Pageflow
-  class DraftEntry
-    include ActiveModel::Conversion
-
+  # A merged view of an entry and its draft revision
+  class DraftEntry < EntryAtRevision
     class InvalidForeignKeyCustomAttributeError < StandardError; end
 
-    attr_reader :entry, :draft
-
-    delegate(:id, :slug,
-             :entry_type,
-             :edit_lock, :account, :theming, :slug,
-             :enabled_feature_names,
-             :published_until, :published?,
-             :password_digest,
-             :to_model, :to_key, :persisted?, :to_json,
-             :first_published_at,
-             :type_name,
-             :to => :entry)
-
-    delegate(:title, :summary, :credits,
-             :widgets,
-             :storylines, :main_storyline_chapters, :chapters, :pages,
-             :share_url, :share_image_id, :share_image_x, :share_image_y,
-             :share_providers, :active_share_providers,
-             :find_files, :find_file, :find_file_by_perma_id,
-             :image_files, :video_files, :audio_files,
-             :locale,
-             :author, :publisher, :keywords,
-             :theme,
-             :published_at,
-             :configuration,
-             :to => :draft)
-
     def initialize(entry, draft = nil)
-      @entry = entry
-      @draft = draft || entry.draft
+      super(entry, draft || entry.draft)
     end
 
-    alias revision draft
+    alias draft revision
 
     # So we can always get to the original Entry title.
     def entry_title
@@ -50,8 +21,8 @@ module Pageflow
         f.entry = entry
       end
 
-      usage = @draft.file_usages.create_with_lock!(file: file,
-                                                   configuration: attributes[:configuration])
+      usage = revision.file_usages.create_with_lock!(file: file,
+                                                     configuration: attributes[:configuration])
       UsedFile.new(file, usage)
     end
 
@@ -106,30 +77,6 @@ module Pageflow
       draft.cache_key
     end
 
-    def home_button
-      HomeButton.new(draft, theming)
-    end
-
-    def overview_button
-      OverviewButton.new(draft)
-    end
-
-    def manual_start
-      revision.configuration['manual_start']
-    end
-
-    def emphasize_chapter_beginning
-      revision.configuration['emphasize_chapter_beginning']
-    end
-
-    def emphasize_new_pages
-      revision.configuration['emphasize_new_pages']
-    end
-
-    def resolve_widgets(options = {})
-      widgets.resolve(Pageflow.config_for(entry), options)
-    end
-
     private
 
     def check_foreign_key_custom_attributes(custom_attributes, attributes)

data/app/models/pageflow/entry.rb

@@ -126,6 +126,14 @@ module Pageflow
       [:title, [:title, :id]]
     end
 
+    def self.ransackable_attributes(_auth_object)
+      %w[title type_name created_at edited_at first_published_at]
+    end
+
+    def self.ransackable_associations(_auth_object)
+      %w[account published_revision]
+    end
+
     def self.ransackable_scopes(_)
       [:with_publication_state, :published]
     end

data/app/models/pageflow/entry_at_revision.rb

@@ -0,0 +1,68 @@
+module Pageflow
+  # A simplified view of an entry at a given revision. Hides the
+  # revision concept and makes revision attributes available along
+  # with entry attributes.
+  class EntryAtRevision
+    include ActiveModel::Conversion
+
+    attr_reader :entry, :revision
+
+    def initialize(entry, revision, theme: nil)
+      @entry = entry
+      @revision = revision
+      @theme = theme
+    end
+
+    delegate(:id, :slug,
+             :entry_type,
+             :account, :theming,
+             :feature_state, :enabled_feature_names,
+             :edit_lock,
+             :password_digest,
+             :to_model, :to_key, :to_param, :persisted?, :to_json,
+             :first_published_at, :published_until, :published?,
+             :type_name,
+             to: :entry)
+
+    delegate(:title, :summary, :credits,
+             :widgets,
+             :storylines, :main_storyline_chapters, :chapters, :pages,
+             :share_url, :share_image_id, :share_image_x, :share_image_y,
+             :share_providers, :active_share_providers,
+             :find_files, :find_file, :find_file_by_perma_id,
+             :image_files, :video_files, :audio_files,
+             :locale,
+             :author, :publisher, :keywords,
+             :published_at,
+             :configuration,
+             to: :revision)
+
+    def resolve_widgets(options = {})
+      widgets.resolve(Pageflow.config_for(entry), options)
+    end
+
+    def theme
+      @theme ||= CustomizedTheme.find(entry: self, theme: revision.theme)
+    end
+
+    def home_button
+      HomeButton.new(revision, theming)
+    end
+
+    def overview_button
+      OverviewButton.new(revision)
+    end
+
+    def manual_start
+      revision.configuration['manual_start']
+    end
+
+    def emphasize_chapter_beginning
+      revision.configuration['emphasize_chapter_beginning']
+    end
+
+    def emphasize_new_pages
+      revision.configuration['emphasize_new_pages']
+    end
+  end
+end

data/app/models/pageflow/entry_role_query.rb

@@ -11,33 +11,39 @@ module Pageflow
 
       def with_role_at_least(role)
         scope
-          .joins(memberships_for_entries_with_at_least_role(role))
-          .joins(memberships_for_account_of_entries_with_at_least_role(role))
-          .where(either_membership_is_present)
+          .joins(memberships_for_account_of_entries)
+          .joins(memberships_for_entries)
+          .where(either_membership_has_at_least_role(role))
       end
 
       def with_account_role_at_least(role)
         scope
-          .joins(memberships_for_account_of_entries_with_at_least_role(role))
-          .where(entry_account_membership_is_present)
+          .joins(memberships_for_account_of_entries)
+          .where(entry_account_membership_has_at_least_role(role))
       end
 
       private
 
-      def memberships_for_entries_with_at_least_role(role)
-        join_memberships(table_alias: table_alias_for('entry'),
+      def memberships_for_account_of_entries
+        # Since every user with an entry membership also has a
+        # membership for the entry's account, we can use an INNER JOIN
+        # to prevent a full scan of the entries table. The database
+        # will first look up the account memberships and then get the
+        # entries using the index on `account_id`. Those are then
+        # filtered further based on entry memberships and roles.
+        join_memberships(join_type: 'INNER',
+                         table_alias: table_alias_for('entry_account'),
                          user_id: user.id,
-                         roles: Roles.at_least(role),
-                         entity_id_column: 'pageflow_entries.id',
-                         entity_type: 'Pageflow::Entry')
+                         entity_id_column: 'pageflow_entries.account_id',
+                         entity_type: 'Pageflow::Account')
       end
 
-      def memberships_for_account_of_entries_with_at_least_role(role)
-        join_memberships(table_alias: table_alias_for('entry_account'),
+      def memberships_for_entries
+        join_memberships(join_type: 'LEFT OUTER',
+                         table_alias: table_alias_for('entry'),
                          user_id: user.id,
-                         roles: Roles.at_least(role),
-                         entity_id_column: 'pageflow_entries.account_id',
-                         entity_type: 'Pageflow::Account')
+                         entity_id_column: 'pageflow_entries.id',
+                         entity_type: 'Pageflow::Entry')
       end
 
       def join_memberships(options)
@@ -45,25 +51,39 @@ module Pageflow
         entity_id_column = options[:entity_id_column]
 
         sanitize_sql(<<-SQL, options)
-          LEFT OUTER JOIN pageflow_memberships as #{table_alias} ON
+          #{options[:join_type]} JOIN pageflow_memberships as #{table_alias} ON
           #{table_alias}.user_id = :user_id AND
-          #{table_alias}.role IN (:roles) AND
           #{table_alias}.entity_id = #{entity_id_column} AND
           #{table_alias}.entity_type = :entity_type
         SQL
       end
 
-      def either_membership_is_present
-        [entry_membership_is_present,
-         entry_account_membership_is_present].join(' OR ')
+      def either_membership_has_at_least_role(role)
+        [
+          entry_account_membership_has_at_least_role(role),
+          entry_membership_has_at_least_role(role)
+        ].join(' OR ')
+      end
+
+      def entry_account_membership_has_at_least_role(role)
+        membership_has_at_least_role(
+          table_alias: table_alias_for('entry_account'),
+          role: role
+        )
       end
 
-      def entry_membership_is_present
-        "#{table_alias_for(:entry)}.entity_id IS NOT NULL"
+      def entry_membership_has_at_least_role(role)
+        membership_has_at_least_role(
+          table_alias: table_alias_for('entry'),
+          role: role
+        )
       end
 
-      def entry_account_membership_is_present
-        "#{table_alias_for(:entry_account)}.entity_id IS NOT NULL"
+      def membership_has_at_least_role(table_alias:, role:)
+        sanitize_sql(
+          "#{table_alias}.role IN (:roles)",
+          roles: Roles.at_least(role)
+        )
       end
 
       def table_alias_for(type)

data/app/models/pageflow/image_file_css_background_image_urls.rb

@@ -1,10 +1,10 @@
 module Pageflow
   # @api private
   class ImageFileCssBackgroundImageUrls
-    def call(image_file)
+    def call(image_file, entry:)
       {
         default: {
-          desktop: image_file.ready? ? image_file.attachment.url(:large) : '',
+          desktop: image_file.ready? ? image_file.attachment.url(desktop_style(entry)) : '',
           mobile: image_file.ready? ? image_file.attachment.url(:medium) : ''
         },
         panorama: {
@@ -13,5 +13,11 @@ module Pageflow
         }
       }
     end
+
+    private
+
+    def desktop_style(entry)
+      entry.feature_state('highdef_background_images') ? :ultra : :large
+    end
   end
 end

data/app/models/pageflow/published_entry.rb

@@ -1,56 +1,21 @@
 module Pageflow
-  class PublishedEntry
-    include ActiveModel::Conversion
+  # A merged view of an entry and its published revision.
+  class PublishedEntry < EntryAtRevision
     extend ActiveModel::Naming
 
-    attr_reader :entry, :revision
     attr_accessor :share_target
 
-    delegate(:id, :slug,
-             :entry_type,
-             :account, :theming,
-             :enabled_feature_names,
-             :to_model, :to_key, :persisted?,
-             :authenticate,
-             :first_published_at,
-             :type_name,
-             :to => :entry)
-
-    delegate(:widgets,
-             :storylines, :main_storyline_chapters, :chapters, :pages,
-             :find_files, :find_file, :find_file_by_perma_id,
-             :image_files, :video_files, :audio_files,
-             :summary, :credits,
-             :share_url, :share_image_id, :share_image_x, :share_image_y,
-             :share_providers, :active_share_providers,
-             :locale,
-             :author, :publisher, :keywords,
-             :theme,
-             :password_protected?,
-             :published_at,
-             :configuration,
-             :to => :revision)
-
-    def initialize(entry, revision = nil)
-      @entry = entry
-      @revision = revision || entry.published_revision
-      @custom_revision = !!revision
-    end
+    delegate(:authenticate, to: :entry)
 
-    def title
-      revision.title.presence || entry.title
-    end
+    delegate(:password_protected?, to: :revision)
 
-    def manual_start
-      revision.configuration['manual_start']
+    def initialize(entry, revision = nil, theme: nil)
+      super(entry, revision || entry.published_revision, theme: theme)
+      @custom_revision = revision
     end
 
-    def emphasize_chapter_beginning
-      revision.configuration['emphasize_chapter_beginning']
-    end
-
-    def emphasize_new_pages
-      revision.configuration['emphasize_new_pages']
+    def title
+      revision.title.presence || entry.title
     end
 
     def stylesheet_model
@@ -98,18 +63,6 @@ module Pageflow
       ].compact.join('-').presence
     end
 
-    def home_button
-      HomeButton.new(revision, theming)
-    end
-
-    def overview_button
-      OverviewButton.new(revision)
-    end
-
-    def resolve_widgets(options = {})
-      widgets.resolve(Pageflow.config_for(entry), options)
-    end
-
     private
 
     def custom_revision?

data/app/models/pageflow/theme_customization.rb

@@ -0,0 +1,46 @@
+module Pageflow
+  # Override theme options and upload theme files for an entry type on
+  # a per account basis.
+  #
+  # @since 15.7
+  class ThemeCustomization < ApplicationRecord
+    belongs_to :account
+
+    serialize :overrides, JSON
+    serialize :selected_file_ids, JSON
+
+    has_many :uploaded_files, class_name: 'ThemeCustomizationFile'
+
+    # Options that were passed to [ThemeCustomizations#update].
+    #
+    # @return [Hash<Symbol, Object>]
+    def overrides
+      super&.deep_symbolize_keys || {}
+    end
+
+    # Theme customization files that have been assigned a role via
+    # [ThemeCustomizations#update].
+    #
+    # @return [Hash<Symbol, ThemeCustomizationFile>]
+    def selected_files
+      selected_file_ids.compact.transform_values do |id|
+        selected_files_by_id[id]
+      end
+    end
+
+    # @api private
+    def entry_type
+      Pageflow.config.entry_types.find_by_name!(entry_type_name)
+    end
+
+    private
+
+    def selected_file_ids
+      super&.deep_symbolize_keys || {}
+    end
+
+    def selected_files_by_id
+      @selected_files_by_id ||= uploaded_files.where(id: selected_file_ids.values).index_by(&:id)
+    end
+  end
+end

data/app/models/pageflow/theme_customization_file.rb

@@ -0,0 +1,58 @@
+module Pageflow
+  # A file that has been uploaded by the user to customize a theme,
+  # e.g., to use a custom logo.
+  #
+  # @since 15.7
+  class ThemeCustomizationFile < ApplicationRecord
+    belongs_to :theme_customization
+
+    has_attached_file(:attachment,
+                      Pageflow
+                        .config.paperclip_s3_default_options
+                        .merge(styles: ->(attachment) { attachment.instance.attachment_styles }))
+
+    # Paperclip requires a content type validator for security
+    # reasons. Sub-classes are fine, though. The original validator
+    # does not provide a way to dynamically determine the permitted
+    # content types.
+    #
+    # @api private
+    class AttachmentContentTypeValidator < Paperclip::Validators::AttachmentContentTypeValidator
+      def validate_whitelist(record, attribute, value)
+        return if value =~ record.options_from_entry_type[:content_type]
+        record.errors.add(attribute, :invalid)
+      end
+
+      # Override to not require :content_type option.
+      def check_validity!
+        true
+      end
+    end
+
+    validates_with AttachmentContentTypeValidator, attributes: :attachment
+
+    # The name of the originally uploaded file
+    def file_name
+      attachment_file_name
+    end
+
+    # A hash of urls based on the styles that were defined when
+    # registering the entry type.
+    def urls
+      attachment_styles.map { |style, _|
+        [style, attachment.url(style)]
+      }.to_h
+    end
+
+    # @api private
+    def options_from_entry_type
+      theme_customization.entry_type.theme_files.fetch(type_name.to_sym, {})
+    end
+
+    # @api private
+    def attachment_styles
+      styles = options_from_entry_type.fetch(:styles, {})
+      styles.respond_to?(:call) ? styles.call(self) : styles
+    end
+  end
+end

data/app/models/pageflow/video_file.rb

@@ -114,7 +114,10 @@ module Pageflow
     def hls_playlist
       if Pageflow.config.zencoder_options[:hls_smil_suffix].present?
         ZencoderAttachment.new(self,
-                               'hls-playlist.smil',
+                               Pageflow.config.zencoder_options.fetch(
+                                 :hls_smil_file_name,
+                                 'hls-playlist.smil'
+                               ),
                                host: :hls,
                                url_suffix: Pageflow.config.zencoder_options[:hls_smil_suffix])
       else
@@ -153,5 +156,12 @@ module Pageflow
                                                         :height,
                                                         :output_presences)
     end
+
+    def post_process_encoded_files
+      self.thumbnail = URI.parse(zencoder_thumbnail.url(default_protocol: 'https'))
+      self.poster = URI.parse(zencoder_poster.url(default_protocol: 'https'))
+    rescue OpenURI::HTTPError
+      throw(:halt, :pending)
+    end
   end
 end

data/app/models/pageflow/video_file_url_templates.rb

@@ -27,6 +27,7 @@ module Pageflow
     def example_file
       @example_file ||= VideoFile.new(id: 0).tap do |video_file|
         video_file.file_name = ':basename.mp4'
+        video_file.output_presences = {':pageflow_hls_qualities' => true}
         video_file.poster_file_name = video_file.zencoder_poster.original_filename
       end
     end

data/app/policies/pageflow/entry_policy.rb

@@ -46,6 +46,10 @@ module Pageflow
       @entry
     end
 
+    def filter_by_type?
+      user.admin?
+    end
+
     def preview?
       query.has_at_least_role?(:previewer)
     end

data/app/state_machines/pageflow/media_encoding_state_machine.rb

@@ -22,9 +22,9 @@ module Pageflow
 
         event :retry_encoding do
           transition 'encoding_failed' => 'waiting_for_confirmation',
-                     if: -> { Pageflow.config.confirm_encoding_jobs }
+                     if: ->(file) { Pageflow.config.confirm_encoding_jobs?(file) }
           transition 'encoded' => 'waiting_for_confirmation',
-                     if: -> { Pageflow.config.confirm_encoding_jobs }
+                     if: ->(file) { Pageflow.config.confirm_encoding_jobs?(file) }
 
           transition 'encoding_failed' => 'waiting_for_encoding'
           transition 'encoded' => 'waiting_for_encoding'
@@ -39,7 +39,14 @@ module Pageflow
         job PollMetaDataFromZencoderJob do
           on_enter 'fetching_meta_data'
           result :pending, retry_after: 2.seconds
-          result ok: 'waiting_for_confirmation'
+
+          result(
+            :ok,
+            state: 'waiting_for_confirmation',
+            if: ->(file) { Pageflow.config.confirm_encoding_jobs?(file) }
+          )
+          result ok: 'waiting_for_encoding'
+
           result error: 'fetching_meta_data_failed'
         end
 
@@ -51,6 +58,10 @@ module Pageflow
           Pageflow.config.hooks.invoke(:file_encoding_confirmed, file: file)
         end
 
+        after_transition any => 'waiting_for_encoding' do |file|
+          Pageflow.config.hooks.invoke(:file_encoding, file: file)
+        end
+
         job SubmitFileToZencoderJob do
           on_enter 'waiting_for_encoding'
           result ok: 'encoding'
@@ -76,7 +87,15 @@ module Pageflow
 
     # UploadableFile-overrides
     def retryable?
-      can_retry_encoding? && !encoded?
+      # Calling `can_retry_encoding?` invokes
+      # `Pageflow.config.confirm_encoding_jobs` which might depend on
+      # accessing `file.entry.account`. If the file has been reused in
+      # a different entry and the original entry has been deleted, we
+      # default to making the file not retryable to prevent
+      # exceptions.
+      entry &&
+        can_retry_encoding? &&
+        !encoded?
     end
 
     def ready?