pageflow 0.11.4 → 12.0.0.rc1

data/app/assets/stylesheets/pageflow/ui/table_cells/presence_table_cell.scss

@@ -0,0 +1,8 @@
+.presence_table_cell {
+  @include background-icon-left;
+  @include minus-icon;
+
+  &.is_present {
+    @include check-icon;
+  }
+}

data/app/assets/stylesheets/pageflow/ui/table_view.scss

@@ -0,0 +1,33 @@
+$table-view-header-background-color: #444 !default;
+$table-view-header-color: #fff !default;
+$table-view-cell-background-color: #fff !default;
+$table-view-blank-slate-color: #888 !default;
+$table-view-selected-cell-background-color: #d2e5fa !default;
+
+.table_view {
+  border-spacing: 0 1px;
+
+  th {
+    background-color: $table-view-header-background-color;
+    color: $table-view-header-color;
+    padding: 5px 10px;
+    text-align: left;
+
+    font-size: 11px;
+    text-transform: uppercase;
+  }
+
+  td {
+    background-color: $table-view-cell-background-color;
+    padding: 10px;
+  }
+
+  .is_selected > td {
+    background-color: $table-view-selected-cell-background-color;
+  }
+
+  .blank_slate > td {
+    text-align: center;
+    color: $table-view-blank-slate-color;
+  }
+}

data/app/assets/stylesheets/pageflow/ui/tooltip.scss

@@ -9,7 +9,7 @@
   padding: 10px 15px;
   color: #fff;
   font-size: 13px;
-  font-weight: bold;
+  font-weight: normal;
   text-decoration: none;
   pointer-events: none;
   border-radius: 5px;

data/app/controllers/pageflow/editor/encoding_confirmations_controller.rb

@@ -29,7 +29,7 @@ module Pageflow
       def build_encoding_confirmation(entry)
         EncodingConfirmation.new(entry,
                                  encoding_confirmation_params,
-                                 encoding_quota,
+                                 encoding_quota(entry),
                                  current_user)
       end
 
@@ -37,8 +37,8 @@ module Pageflow
         params.require(:encoding_confirmation).permit(video_file_ids: [], audio_file_ids: [])
       end
 
-      def encoding_quota
-        Pageflow.config.quotas.get(:encoding, current_user.account)
+      def encoding_quota(entry)
+        Pageflow.config.quotas.get(:encoding, entry.account)
       end
     end
   end

data/app/controllers/pageflow/editor/entry_publications_controller.rb

@@ -34,7 +34,7 @@ module Pageflow
       def build_entry_publication(entry)
         EntryPublication.new(entry,
                              entry_publication_params,
-                             published_entries_quota,
+                             published_entries_quota(entry),
                              current_user)
       end
 
@@ -42,8 +42,8 @@ module Pageflow
         params.fetch(:entry_publication, {}).permit(:published_until, :password, :password_protected)
       end
 
-      def published_entries_quota
-        Pageflow.config.quotas.get(:published_entries, current_user.account)
+      def published_entries_quota(entry)
+        Pageflow.config.quotas.get(:published_entries, entry.account)
       end
     end
   end

data/app/controllers/pageflow/editor/files_controller.rb

@@ -9,7 +9,7 @@ module Pageflow
         entry = DraftEntry.find(params[:entry_id])
 
         authorize!(:use_files, entry.to_model)
-        @files = entry.files(file_type.model)
+        @files = entry.find_files(file_type.model)
 
         respond_with(:editor, @files)
       end
@@ -19,47 +19,105 @@ module Pageflow
         authorize!(:edit, entry.to_model)
         verify_edit_lock!(entry)
 
-        @file = entry.create_file(file_type.model, file_params)
+        @file = entry.create_file(file_type.model, create_params)
         @file.publish!
 
         respond_with(:editor, @file)
       end
 
+      def reuse
+        entry = DraftEntry.find(params[:entry_id])
+        other_entry = DraftEntry.find(file_reuse_params[:other_entry_id])
+
+        file_reuse = FileReuse.new(entry, other_entry, file_type, file_reuse_params[:file_id])
+
+        authorize!(:edit, entry.to_model)
+        authorize!(:use, file_reuse.file.to_model)
+        verify_edit_lock!(entry)
+
+        file_reuse.save!
+
+        redirect_to(entry_url(entry))
+      end
+
       def retry
-        file = file_type.model.find(params[:id])
+        entry = DraftEntry.find(params[:entry_id])
+        file = entry.find_file(file_type.model, params[:id])
 
-        authorize!(:retry, file)
+        authorize!(:retry, file.to_model)
         file.retry!
 
-        respond_with(:editor, file, location: editor_file_url(file, collection_name: params[:collection_name]))
+        respond_with(:editor,
+                     file,
+                     location: editor_entry_file_url(file,
+                                                     entry,
+                                                     collection_name: params[:collection_name]))
       end
 
       def update
-        file = file_type.model.find(params[:id])
+        entry = DraftEntry.find(params[:entry_id])
+        file = entry.find_file(file_type.model, params[:id])
 
-        authorize!(:update, file)
+        authorize!(:update, file.to_model)
         file.update_attributes!(update_params)
 
         head(:no_content)
       end
 
+      def destroy
+        entry = DraftEntry.find(params[:entry_id])
+        file = entry.find_file(file_type.model, params[:id])
+
+        authorize!(:edit, entry.to_model)
+        verify_edit_lock!(entry)
+        entry.remove_file(file)
+
+        head(:no_content)
+      end
+
       private
 
-      def file_type
-        @file_type ||= Pageflow.config.file_types.find_by_collection_name!(params[:collection_name])
+      def create_params
+        file_attachment_params
+          .merge(file_configuration_params)
+          .merge(file_parent_file_params)
       end
 
-      helper_method :file_type
+      def file_reuse_params
+        params.require(:file_reuse).permit(:other_entry_id, :file_id)
+      end
+
+      def update_params
+        file_configuration_params
+      end
+
+      def file_attachment_params
+        file_params
+          .permit(attachment: [:tmp_path, :original_name, :content_type])
+          .merge(file_params.permit(:attachment))
+      end
+
+      def file_configuration_params
+        configuration = file_params[:configuration].try(:permit!)
+
+        file_params
+          .permit(:rights)
+          .merge(configuration: configuration)
+      end
+
+      def file_parent_file_params
+        file_params.permit(:parent_file_id, :parent_file_model_type)
+      end
 
       def file_params
         params.require(file_type.param_key)
-          .permit(:attachment => [:tmp_path, :original_name, :content_type])
-          .merge(params.require(file_type.param_key).permit(:attachment))
       end
 
-      def update_params
-        params.require(file_type.param_key).permit(:rights)
+      def file_type
+        @file_type ||= Pageflow.config.file_types.find_by_collection_name!(params[:collection_name])
       end
+
+      helper_method :file_type
     end
   end
 end

data/app/controllers/pageflow/editor/widgets_controller.rb

@@ -7,7 +7,7 @@ module Pageflow
 
       def index
         subject = find_subject
-        authorize!(:edit, subject.to_model)
+        authorize!(:index_widgets_for, subject.to_model)
 
         @widgets = subject.resolve_widgets(include_placeholders: true)
         respond_with(@widgets)

data/app/controllers/pageflow/entries_controller.rb

@@ -3,9 +3,13 @@ module Pageflow
     include PublicHttpsMode
     include EntryPasswordProtection
 
-    before_filter :authenticate_user!, :except => [:index, :show, :page]
+    before_filter :authenticate_user!, except: [:index, :show, :page]
 
-    before_filter :check_public_https_mode, only: [:index, :show], unless: lambda { |controller| controller.request.format.json? }
+    before_filter :check_public_https_mode,
+                  only: [:index, :show],
+                  unless: lambda { |controller| controller.request.format.json? }
+
+    after_action :allow_iframe_for_embed, only: :show
 
     helper_method :render_to_string
 
@@ -92,5 +96,11 @@ module Pageflow
     def entry_request_scope
       Pageflow.config.public_entry_request_scope.call(Entry, request)
     end
+
+    def allow_iframe_for_embed
+      if params[:embed]
+        response.headers.except! 'X-Frame-Options'
+      end
+    end
   end
 end

data/app/controllers/pageflow/files_controller.rb

@@ -9,7 +9,7 @@ module Pageflow
       respond_to do |format|
         format.html do
           entry = PublishedEntry.find(params[:entry_id], entry_request_scope)
-          @file = entry.files(file_type.model).find(params[:id])
+          @file = entry.find_file(file_type.model, params[:id])
 
           check_entry_password_protection(entry)
         end

data/app/helpers/pageflow/admin/entries_helper.rb

@@ -1,6 +1,14 @@
 module Pageflow
   module Admin
     module EntriesHelper
+      def admin_entry_title(entry)
+        if entry.title.blank?
+          I18n.t('pageflow.admin.entries.default_title', id: entry.id)
+        else
+          entry.title
+        end
+      end
+
       def collection_for_entry_publication_states
         [
           'published_without_password_protection',
@@ -10,6 +18,15 @@ module Pageflow
           I18n.t(state, scope: 'activerecord.values.pageflow/entry.publication_states')
         end
       end
+
+      def eligible_accounts
+        AccountPolicy::Scope.new(current_user, Account).entry_movable
+      end
+
+      def eligible_themings
+        ThemingPolicy::Scope.new(current_user, Pageflow::Theming)
+          .themings_allowed_for(resource.account)
+      end
     end
   end
 end

data/app/helpers/pageflow/admin/form_helper.rb

@@ -1,7 +1,7 @@
 module Pageflow
   module Admin
     module FormHelper
-      # Using semantic_for_for directly causes Formtastic deprecation
+      # Using semantic_form_for directly causes Formtastic deprecation
       # warnings regarding `input_class_finder` and
       # `action_class_finder`. `active_admin_form_for` causes issues
       # in `erb` templates (see

data/app/helpers/pageflow/admin/memberships_helper.rb

@@ -1,21 +1,75 @@
 module Pageflow
   module Admin
     module MembershipsHelper
-      def membership_entries_collection_for_parent(parent)
-        CollectionForParent.new(parent,
-                                collection_method: :entries,
-                                display_method: :title,
-                                order: 'title ASC').pairs
+      def membership_entries_collection(parent, resource)
+        if resource.new_record?
+          if parent.is_a?(User)
+            accounts = AccountPolicy::Scope.new(current_user, Pageflow::Account)
+                       .entry_creatable
+            MembershipFormCollection.new(parent,
+                                         resource: resource,
+                                         collection_method: :entries,
+                                         display_method: :title,
+                                         order: 'title ASC',
+                                         managed_accounts: accounts).collection_for_entries
+          else
+            MembershipFormCollection.new(parent,
+                                         resource: resource,
+                                         collection_method: :entries,
+                                         display_method: :title,
+                                         order: 'title ASC').pairs
+          end
+        else
+          [[resource.entity.title, resource.entity_id]]
+        end
+      end
+
+      def membership_accounts_collection(parent, resource)
+        if resource.new_record?
+          if parent.is_a?(User)
+            accounts = AccountPolicy::Scope
+                       .new(current_user, Account).member_addable.load
+            MembershipFormCollection.new(parent,
+                                         collection_method: :accounts,
+                                         display_method: :name,
+                                         order: 'name ASC',
+                                         managed_accounts: accounts).pairs
+          else
+            [[parent.name, parent.id]]
+          end
+        else
+          [[resource.entity.name, resource.entity_id]]
+        end
       end
 
-      def membership_users_collection_for_parent(parent)
-        CollectionForParent.new(parent,
-                                collection_method: :users,
-                                display_method: :formal_name,
-                                order: 'last_name ASC, first_name ASC').pairs
+      def membership_users_collection(parent, resource)
+        if resource.new_record?
+          accounts = AccountPolicy::Scope
+                     .new(current_user, Pageflow::Account).member_addable.load
+          MembershipFormCollection.new(parent,
+                                       collection_method: :users,
+                                       display_method: :formal_name,
+                                       order: 'last_name ASC, first_name ASC',
+                                       managed_accounts: accounts).pairs
+        else
+          [[resource.user.formal_name, resource.user.id]]
+        end
+      end
+
+      def membership_roles_collection(entity_type)
+        default_options = [[I18n.t('pageflow.admin.users.roles.previewer'), :previewer],
+                           [I18n.t('pageflow.admin.users.roles.editor'), :editor],
+                           [I18n.t('pageflow.admin.users.roles.publisher'), :publisher],
+                           [I18n.t('pageflow.admin.users.roles.manager'), :manager]]
+        if entity_type == 'Pageflow::Account'
+          [[I18n.t('pageflow.admin.users.roles.member'), :member]] + default_options
+        else
+          default_options
+        end
       end
 
-      class CollectionForParent
+      class MembershipFormCollection
+        include ActionView::Helpers::FormOptionsHelper
         attr_reader :parent, :options
 
         def initialize(parent, options)
@@ -29,10 +83,30 @@ module Pageflow
           end
         end
 
+        def collection_for_entries
+          accounts = options[:managed_accounts]
+                     .where(accounts_ids_in_parent_accounts_ids)
+                     .includes(:entries).where('pageflow_entries.id IS NOT NULL')
+                     .where(entries_ids_not_in_parent_entries_ids)
+                     .order(:name, 'pageflow_entries.title')
+
+          option_groups_from_collection_for_select(accounts, :entries, :name, :id, :title)
+        end
+
         private
 
         def items
-          items_in_account - items_in_parent
+          if parent.is_a?(User)
+            if options[:collection_method] == :users
+              [parent]
+            else
+              options[:managed_accounts] - items_in_parent
+            end
+          elsif parent.is_a?(Entry)
+            items_in_account - items_in_parent
+          else
+            Set.new(options[:managed_accounts].map(&:users).flatten) - items_in_parent
+          end
         end
 
         def display(item)
@@ -40,12 +114,42 @@ module Pageflow
         end
 
         def items_in_account
-          parent.account.send(options[:collection_method]).order(options[:order])
+          if options[:collection_method] == :users
+            parent.account.users.order(options[:order])
+          elsif parent.is_a?(User)
+            options[:resource].entity.send(options[:collection_method]).order(options[:order])
+          else
+            parent.account.send(options[:collection_method]).order(options[:order])
+          end
         end
 
         def items_in_parent
           parent.respond_to?(options[:collection_method]) ? parent.send(options[:collection_method]) : []
         end
+
+        def accounts_ids_in_parent_accounts_ids
+          parent_accounts_ids = parent.accounts.map(&:id)
+          if parent_accounts_ids.any?
+            sanitize_sql_array(['pageflow_accounts.id IN (:parent_accounts_ids)',
+                                parent_accounts_ids: parent_accounts_ids])
+          else
+            'FALSE'
+          end
+        end
+
+        def entries_ids_not_in_parent_entries_ids
+          parent_entries_ids = items_in_parent.map(&:id)
+          if parent_entries_ids.any?
+            sanitize_sql_array(['pageflow_entries.id NOT IN (:parent_entries_ids)',
+                                parent_entries_ids: parent_entries_ids])
+          else
+            'TRUE'
+          end
+        end
+
+        def sanitize_sql_array(array)
+          ActiveRecord::Base.send(:sanitize_sql_array, array)
+        end
       end
     end
   end