pageflow 15.5.0 → 15.7.0

data/app/helpers/pageflow/entries_helper.rb

@@ -5,8 +5,47 @@ module Pageflow
     end
 
     def pretty_entry_url(entry, options = {})
-      params = options.reverse_merge(Pageflow.config.theming_url_options(entry.theming) || {})
-      pageflow.short_entry_url(entry.to_model, params)
+      PrettyUrl.build(pageflow, entry, options)
+    end
+
+    # @api private
+    module PrettyUrl
+      extend self
+
+      def build(routes, entry, options)
+        with_custom_canonical_url_prefix(entry) ||
+          default(routes, entry, options)
+      end
+
+      private
+
+      def with_custom_canonical_url_prefix(entry)
+        return if entry.theming.canonical_entry_url_prefix.blank?
+        entry = ensure_entry_with_revision(entry)
+
+        [
+          entry.theming.canonical_entry_url_prefix.gsub(':locale', entry.locale),
+          entry.to_param,
+          entry.theming.trailing_slash_in_canonical_urls ? '/' : ''
+        ].join
+      end
+
+      def default(routes, entry, options)
+        params =
+          options
+          .reverse_merge(trailing_slash: entry.theming.trailing_slash_in_canonical_urls)
+          .reverse_merge(Pageflow.config.theming_url_options(entry.theming) || {})
+
+        routes.short_entry_url(entry.to_model, params)
+      end
+
+      def ensure_entry_with_revision(entry)
+        if entry.is_a?(EntryAtRevision)
+          entry
+        else
+          PublishedEntry.new(entry, entry.published_revision || entry.draft)
+        end
+      end
     end
 
     def entry_privacy_link_url(entry)

data/app/helpers/pageflow/file_background_images_helper.rb

@@ -37,7 +37,7 @@ module Pageflow
       end
 
       def rules_for_file(file_type, file)
-        file_type.css_background_image_urls.call(file).map do |name, url|
+        file_type.css_background_image_urls_for(file, entry: entry).map do |name, url|
           {
             prefix: rule_prefix(file_type, name),
             file: file,

data/app/helpers/pageflow/page_types_helper.rb

@@ -4,7 +4,7 @@ module Pageflow
 
     def page_type_json_seeds(config)
       render_json_partial('pageflow/page_types/page_type',
-                          collection: config.page_types,
+                          collection: config.page_types.to_a,
                           as: :page_type)
     end
 

data/app/helpers/pageflow/themes_helper.rb

@@ -10,7 +10,7 @@ module Pageflow
 
     def theme_json_seeds(config)
       render_json_partial('pageflow/themes/theme',
-                          collection: config.themes,
+                          collection: config.themes.to_a,
                           as: :theme)
     end
   end

data/app/jobs/pageflow/poll_meta_data_from_zencoder_job.rb

@@ -1,7 +1,7 @@
 module Pageflow
   class PollMetaDataFromZencoderJob < PollZencoderJob
     def perform_with_result(file, _options)
-      super(file, skip_thumbnail: true)
+      super(file, skip_post_processing: true)
     end
   end
 end

data/app/jobs/pageflow/poll_zencoder_job.rb

@@ -10,7 +10,7 @@ module Pageflow
       catch(:halt) do
         poll_zencoder(file, api)
         fetch_input_details(file, api)
-        fetch_thumbnail(file) unless options[:skip_thumbnail]
+        file.post_process_encoded_files unless options[:skip_post_processing]
 
         :ok
       end
@@ -39,14 +39,6 @@ module Pageflow
       raise
     end
 
-    def fetch_thumbnail(file)
-      return unless file.respond_to?(:thumbnail)
-      file.thumbnail = URI.parse(file.zencoder_thumbnail.url(default_protocol: 'https'))
-      file.poster = URI.parse(file.zencoder_poster.url(default_protocol: 'https'))
-    rescue OpenURI::HTTPError
-      throw(:halt, :pending)
-    end
-
     def fetch_input_details(file, api)
       file.meta_data_attributes = api.get_details(file.job_id)
     rescue ZencoderApi::RecoverableError => e

data/app/models/pageflow/audio_file.rb

@@ -5,6 +5,17 @@ module Pageflow
 
     belongs_to :confirmed_by, class_name: 'User', optional: true
 
+    has_attached_file(:peak_data,
+                      Pageflow.config.paperclip_s3_default_options
+                        .merge(styles: {
+                                 original: {
+                                   processors: [:pageflow_audio_waveform],
+                                   format: 'json'
+                                 }
+                               }))
+
+    do_not_validate_attachment_file_type :peak_data
+
     def attachment_s3_url
       "s3://#{File.join(attachment.bucket_name, attachment.path)}"
     end
@@ -28,5 +39,11 @@ module Pageflow
     def meta_data_attributes=(attributes)
       self.attributes = attributes.symbolize_keys.slice(:format, :duration_in_ms)
     end
+
+    def post_process_encoded_files
+      self.peak_data = URI.parse(ogg.url(default_protocol: 'https'))
+    rescue OpenURI::HTTPError
+      throw(:halt, :pending)
+    end
   end
 end

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_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