pageflow 0.11.4 → 12.0.0.rc1

data/app/models/pageflow/draft_entry.rb

@@ -4,7 +4,7 @@ module Pageflow
 
     attr_reader :entry, :draft
 
-    delegate(:id,
+    delegate(:id, :slug,
              :edit_lock, :account, :theming, :slug,
              :enabled_feature_names,
              :published_until, :published?,
@@ -18,7 +18,7 @@ module Pageflow
              :emphasize_chapter_beginning,
              :emphasize_new_pages,
              :share_url, :share_image_id, :share_image_x, :share_image_y,
-             :files,
+             :find_files, :find_file,
              :image_files, :video_files, :audio_files,
              :locale,
              :author, :publisher, :keywords,
@@ -35,23 +35,33 @@ module Pageflow
     end
 
     def create_file(model, attributes)
-      file = model.create(attributes) do |f|
+      file = model.create(attributes.except(:configuration)) do |f|
         f.entry = entry
       end
 
-      usage = @draft.file_usages.create(:file => file)
-      file.usage_id = usage.id
-
-      file
+      usage = @draft.file_usages.create(file: file, configuration: attributes[:configuration])
+      UsedFile.new(file, usage)
     end
 
     def remove_file(file)
       draft.file_usages.where(file: file).destroy_all
+
+      file.file_type.nested_file_types.each do |nested_file_type|
+        nested_file_ids = file.nested_files(nested_file_type.model).map(&:id)
+
+        draft
+          .file_usages
+          .where(file_type: nested_file_type.model.name,
+                 file_id: nested_file_ids)
+          .destroy_all
+      end
+
       file.destroy if file.usages.empty?
     end
 
-    def add_file(file)
-      draft.file_usages.create!(:file => file)
+    def use_file(file)
+      draft.file_usages.create!(file: file.to_model,
+                                configuration: file.configuration)
     end
 
     def save!

data/app/models/pageflow/entry.rb

@@ -18,7 +18,7 @@ module Pageflow
     has_many :chapters, -> { order('pageflow_chapters.position ASC') }, :through => :revisions
     has_many :pages, -> { order('pageflow_chapters.position ASC, pageflow_pages.position ASC') }, :through => :chapters
 
-    has_many :memberships, :dependent => :destroy
+    has_many :memberships, as: :entity, dependent: :destroy
     has_many :users, :through => :memberships, :class_name => '::User'
 
     has_many :image_files
@@ -33,6 +33,7 @@ module Pageflow
     has_secure_password validations: false
 
     validates :account, :theming, :presence => true
+    validates :title, presence: true
     validate :folder_belongs_to_same_account
 
     scope :editing, -> { joins(:edit_lock).merge(Pageflow::EditLock.active) }

data/app/models/pageflow/entry_duplicate.rb

@@ -28,8 +28,8 @@ module Pageflow
     end
 
     def copy_memberships
-      original_entry.users.each do |member|
-        new_entry.memberships.create(user: member)
+      original_entry.memberships.each do |membership|
+        Membership.create(user: membership.user, role: membership.role.to_sym, entity: new_entry)
       end
     end
 

data/app/models/pageflow/entry_role_query.rb

@@ -0,0 +1,81 @@
+module Pageflow
+  class EntryRoleQuery
+    class Scope
+      attr_reader :user, :scope
+
+      def initialize(user, scope)
+        @user = user
+        @scope = scope
+      end
+
+      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)
+      end
+
+      private
+
+      def memberships_for_entries_with_at_least_role(role)
+        join_memberships(table_alias: 'pageflow_entry_memberships',
+                         user_id: user.id,
+                         roles: Roles.at_least(role),
+                         entity_id_column: 'pageflow_entries.id',
+                         entity_type: 'Pageflow::Entry')
+      end
+
+      def memberships_for_account_of_entries_with_at_least_role(role)
+        join_memberships(table_alias: 'pageflow_entry_account_memberships',
+                         user_id: user.id,
+                         roles: Roles.at_least(role),
+                         entity_id_column: 'pageflow_entries.account_id',
+                         entity_type: 'Pageflow::Account')
+      end
+
+      def join_memberships(options)
+        table_alias = options[:table_alias]
+        entity_id_column = options[:entity_id_column]
+
+        sanitize_sql(<<-SQL, options)
+          LEFT OUTER 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
+        'pageflow_entry_memberships.entity_id IS NOT NULL OR ' \
+        'pageflow_entry_account_memberships.entity_id IS NOT NULL'
+      end
+
+      def sanitize_sql(sql, interpolations)
+        ActiveRecord::Base.send(:sanitize_sql_array, [sql, interpolations])
+      end
+    end
+
+    def initialize(user, entry)
+      @user = user
+      @entry = entry
+    end
+
+    def has_at_least_role?(role)
+      @user
+        .memberships
+        .where(role: Roles.at_least(role))
+        .where("(entity_id = :entry_id AND entity_type = 'Pageflow::Entry') OR " \
+               "(entity_id = :account_id AND entity_type = 'Pageflow::Account')",
+               entry_id: @entry.id, account_id: @entry.account.id)
+        .any?
+    end
+
+    def has_at_least_account_role?(role)
+      @user
+        .memberships
+        .where(role: Roles.at_least(role), entity: @entry.account)
+        .any?
+    end
+  end
+end

data/app/models/pageflow/file_reuse.rb

@@ -0,0 +1,25 @@
+module Pageflow
+  class FileReuse
+    attr_accessor :source_entry, :destination_entry, :file_type, :file
+
+    def initialize(destination_entry, source_entry, file_type, file_id)
+      @source_entry = source_entry
+      @destination_entry = destination_entry
+      @file_type = file_type
+      @file = source_entry.find_file(file_type.model, file_id)
+    end
+
+    def save!
+      destination_entry.use_file(file)
+
+      file_type.nested_file_types.each do |nested_file_type|
+        source_entry.find_files(nested_file_type.model).each do |nested_file|
+          next if nested_file.parent_file_id != file.id ||
+                  nested_file.parent_file_model_type != file.model_name.name
+
+          destination_entry.use_file(nested_file)
+        end
+      end
+    end
+  end
+end

data/app/models/pageflow/file_usage.rb

@@ -1,7 +1,13 @@
 module Pageflow
   class FileUsage < ActiveRecord::Base
     belongs_to :revision
-    belongs_to :file, :polymorphic => true
+    belongs_to :file, polymorphic: true
+
+    serialize :configuration, JSON
+
+    def configuration
+      super || {}
+    end
 
     def copy_to(revision)
       revision.file_usages << dup

data/app/models/pageflow/image_file.rb

@@ -10,6 +10,7 @@ module Pageflow
         .merge(print: ['300x300>', :JPG],
                medium: ['1024x1024>', :JPG],
                large: ['1920x1920>', :JPG],
+               ultra: ['3840x3840>', :JPG],
                panorama_medium: ['1024x1024^', panorama_format],
                panorama_large: ['1920x1080^', panorama_format])
     end
@@ -18,9 +19,10 @@ module Pageflow
       print: '-quality 10 -interlace Plane',
       medium: '-quality 70 -interlace Plane',
       large: '-quality 70 -interlace Plane',
+      ultra: '-quality 90 -interlace Plane',
       panorama_medium: '-quality 70 -interlace Plane',
       panorama_large: '-quality 70 -interlace Plane'
-    }
+    }.freeze
 
     has_attached_file(:unprocessed_attachment,
                       Pageflow.config.paperclip_s3_default_options)
@@ -44,6 +46,10 @@ module Pageflow
       self.unprocessed_attachment = value
     end
 
+    def basename
+      File.basename(attachment.original_filename, '.*')
+    end
+
     def thumbnail_url(*args)
       processed_attachment.url(*args)
     end

data/app/models/pageflow/image_file_url_templates.rb

@@ -0,0 +1,19 @@
+module Pageflow
+  class ImageFileUrlTemplates
+    def call
+      styles.each_with_object({}) do |style, result|
+        result[style] = UrlTemplate.from_attachment(example_file.attachment, style)
+      end
+    end
+
+    private
+
+    def styles
+      ImageFile::STYLES.call(example_file.attachment).keys
+    end
+
+    def example_file
+      @example_file ||= ImageFile.new(id: 0, processed_attachment_file_name: ':basename.jpg')
+    end
+  end
+end

data/app/models/pageflow/invited_user.rb

@@ -2,6 +2,8 @@ module Pageflow
   # Specialized User class containing invitation logic used by in the
   # users admin.
   class InvitedUser < User
+    attr_accessor :initial_account, :initial_role
+
     before_create :prepare_invitation
     after_create :send_invitation
 

data/app/models/pageflow/membership.rb

@@ -1,9 +1,52 @@
 module Pageflow
   class Membership < ActiveRecord::Base
     belongs_to :user
-    belongs_to :entry
+    belongs_to :entity, polymorphic: true
+    belongs_to :entry,
+               -> { where(pageflow_memberships: {entity_type: 'Pageflow::Entry'}) },
+               foreign_key: 'entity_id'
+    belongs_to :account,
+               -> { where(pageflow_memberships: {entity_type: 'Pageflow::Account'}) },
+               foreign_key: 'entity_id'
 
-    validates :user, :entry, :presence => true
-    validates :entry_id, :uniqueness => { :scope => :user_id }
+    validates :user, :entity, :role, presence: true
+    validates :user_id, uniqueness: {scope: [:entity_type, :entity_id]}
+    validate :account_membership_exists, if: :on_entry?
+    validates :role,
+              inclusion: {in: %w(previewer editor publisher manager)},
+              if: :on_entry?
+    validates :role,
+              inclusion: {in: %w(member previewer editor publisher manager)},
+              if: :on_account?
+
+    scope :on_entries, -> { where(entity_type: 'Pageflow::Entry') }
+    scope :on_accounts, -> { where(entity_type: 'Pageflow::Account') }
+    scope :as_manager, -> { where(role: :manager) }
+    scope :as_publisher_or_above, -> { where(role: %w(publisher manager)) }
+    scope :as_previewer_or_above, -> { where(role: %w(previewer editor publisher manager)) }
+
+    after_create do
+      entity.increment!(:users_count)
+    end
+
+    after_destroy do
+      entity.decrement!(:users_count)
+    end
+
+    private
+
+    def account_membership_exists
+      unless user.accounts.include?(entity.account)
+        errors[:base] << 'Entry Membership misses presupposed Membership on account of entry'
+      end
+    end
+
+    def on_entry?
+      entity_type == 'Pageflow::Entry'
+    end
+
+    def on_account?
+      entity_type == 'Pageflow::Account'
+    end
   end
 end

data/app/models/pageflow/published_entry.rb

@@ -6,7 +6,7 @@ module Pageflow
     attr_reader :entry, :revision
     attr_accessor :share_target
 
-    delegate(:id,
+    delegate(:id, :slug,
              :account, :theming,
              :enabled_feature_names,
              :to_model, :to_key, :persisted?,
@@ -15,7 +15,7 @@ module Pageflow
 
     delegate(:widgets,
              :storylines, :main_storyline_chapters, :chapters, :pages,
-             :files,
+             :find_files, :find_file,
              :image_files, :video_files, :audio_files,
              :summary, :credits, :manual_start,
              :emphasize_chapter_beginning,

data/app/models/pageflow/revision.rb

@@ -49,11 +49,15 @@ module Pageflow
       main_storyline ? main_storyline.chapters : Chapter.none
     end
 
-    def files(model)
-      model
-        .select("#{model.table_name}.*, pageflow_file_usages.id AS usage_id")
-        .joins(:usages)
-        .where(pageflow_file_usages: {revision_id: id})
+    def find_files(model)
+      files(model).map do |file|
+        UsedFile.new(file)
+      end
+    end
+
+    def find_file(model, id)
+      file = files(model).find(id)
+      UsedFile.new(file)
     end
 
     def creator
@@ -122,6 +126,13 @@ module Pageflow
 
     private
 
+    def files(model)
+      model
+        .includes(:usages)
+        .references(:pageflow_file_usages)
+        .where(pageflow_file_usages: {revision_id: id})
+    end
+
     def published_until_unchanged
       errors.add(:published_until, :readonly) if published_until_changed?
     end

data/app/models/pageflow/roles.rb

@@ -0,0 +1,36 @@
+module Pageflow
+  module Roles
+    module_function
+
+    def at_least(role_uncasted)
+      role = role_uncasted.to_sym
+      if role == :member
+        %w(member previewer editor publisher manager)
+      elsif role == :previewer
+        %w(previewer editor publisher manager)
+      elsif role == :editor
+        %w(editor publisher manager)
+      elsif role == :publisher
+        %w(publisher manager)
+      elsif role == :manager
+        %w(manager)
+      end
+    end
+
+    def high(user, entry)
+      roles = [:none, :member, :previewer, :editor, :publisher, :manager]
+      account_role = Membership.where(user: user, entity: entry.account).first.role || :none
+      if user.entries.include?(entry)
+        entry_role = Membership.where(user: user, entity: entry).first.role
+      else
+        entry_role = :none
+      end
+
+      if roles.find_index(account_role.to_sym) > roles.find_index(entry_role.to_sym)
+        account_role.to_sym
+      else
+        entry_role.to_sym
+      end
+    end
+  end
+end

data/app/models/pageflow/text_track_file.rb

@@ -0,0 +1,45 @@
+module Pageflow
+  class TextTrackFile < ActiveRecord::Base
+    include HostedFile
+
+    processing_state_machine do
+      state 'processing'
+      state 'processed'
+      state 'processing_failed'
+
+      event :process do
+        transition any => 'processing'
+      end
+
+      job ProcessFileJob do
+        on_enter 'processing'
+        result :ok, state: 'processed'
+        result :error, state: 'processing_failed'
+      end
+    end
+
+    has_attached_file(:processed_attachment,
+                      Pageflow.config.paperclip_s3_default_options
+                        .merge(styles: {
+                                 vtt: {
+                                   format: 'vtt',
+                                   processors: [:pageflow_vtt],
+                                   s3_headers: {
+                                     'Content-Type' => 'text/vtt'
+                                   }
+                                 }
+                               }))
+
+    def ready?
+      processed?
+    end
+
+    def unprocessed_attachment
+      attachment_on_s3
+    end
+
+    def meta_data_attributes=(attributes)
+      self.attributes = attributes.symbolize_keys.slice(:label, :kind, :srclang)
+    end
+  end
+end