pageflow 15.2.2 → 15.3.0

data/admins/pageflow/accounts.rb

@@ -30,9 +30,6 @@ module Pageflow
           membership_role_with_tooltip(own_role, scope: 'own_account_role')
         end
       end
-      column :default_theming do |account|
-        account.first_paged_entry_template.theme_name if authorized?(:read, account)
-      end
     end
 
     csv do
@@ -63,7 +60,6 @@ module Pageflow
     show :title => :name do |account|
       render 'account_details', :account => account
       render 'theming_details', :account => account
-      render 'entry_template_details', account: account
 
       tabs_view(Pageflow.config.admin_resource_tabs.find_by_resource(account.default_theming),
                 i18n: 'pageflow.admin.resource_tabs',
@@ -76,76 +72,25 @@ module Pageflow
       helper Pageflow::Admin::FormHelper
       helper Pageflow::Admin::LocalesHelper
       helper Pageflow::Admin::MembershipsHelper
-      helper Pageflow::Admin::WidgetsHelper
       helper ThemesHelper
 
       def new
         @account = Account.new
         @account.build_default_theming
-        @entry_template = @account.entry_templates.build(
-          default_locale: current_user.locale,
-          share_providers: Pageflow.config.default_share_providers,
-          entry_type: 'paged'
-        )
       end
 
       def create
-        account_params = (permitted_params[:account] || {})
-                         .except(:paged_entry_template_attributes)
+        account_params = permitted_params[:account] || {}
         @account = Account.new(account_params)
         @account.build_default_theming(permitted_params.fetch(:account, {})[
                                          :default_theming_attributes])
-        @entry_template = @account.entry_templates.build({entry_type: 'paged'}
-                                                  .merge(entry_template_params))
-
-        super
-        update_widgets('paged')
-      end
-
-      def edit
-        @entry_template = resource.first_paged_entry_template
         super
       end
 
       def update
-        @entry_template = resource.entry_templates.find_or_initialize_by(
-          entry_type: 'paged'
-        )
-        @entry_template.assign_attributes(entry_template_params)
-        @entry_template.save
         update! do |success, failure|
           success.html { redirect_to(admin_account_path(resource, params.permit(:tab))) }
         end
-        update_widgets('paged')
-      end
-
-      def entry_template_params
-        current_params = permitted_params_with_entry_template_attributes.fetch(:account, {})[
-          :paged_entry_template_attributes]&.to_hash
-        if current_params
-          config = true_false_strings_to_booleans_or_numbers(
-            current_params['configuration']
-          )
-          share_providers = true_false_strings_to_booleans_or_numbers(
-            current_params['share_providers']
-          )
-          current_params.merge('configuration' => config, 'share_providers' => share_providers)
-        else
-          {}
-        end
-      end
-
-      def update_widgets(entry_type)
-        if @account.valid?
-          EntryTemplate.find_by(account_id: @account.id, entry_type: entry_type)
-            &.widgets&.batch_update!(widgets_params)
-        end
-      end
-
-      def widgets_params
-        (params[:widgets].try(:permit!).to_h || {}).map do |role, type_name|
-          {role: role, type_name: type_name}
-        end
       end
 
       def permitted_params
@@ -154,12 +99,6 @@ module Pageflow
         with_permitted_feature_states(result)
       end
 
-      def permitted_params_with_entry_template_attributes
-        result = params.permit(account: permitted_account_attributes_plus_entry_template)
-
-        with_permitted_feature_states(result)
-      end
-
       def scoped_collection
         super.includes(:default_theming)
       end
@@ -172,25 +111,6 @@ module Pageflow
         result
       end
 
-      def true_false_strings_to_booleans_or_numbers(hash)
-        hash&.map { |k, v| [k, to_boolean_or_number(v)] }&.to_h
-      end
-
-      def to_boolean_or_number(value)
-        case value
-        when 'false'
-          false
-        when 'true'
-          true
-        when '0'
-          0
-        when '1'
-          1
-        else
-          value
-        end
-      end
-
       def permitted_account_attributes
         [
           :name,
@@ -200,11 +120,6 @@ module Pageflow
           permitted_attributes_for(:account)
       end
 
-      def permitted_account_attributes_plus_entry_template
-        permitted_account_attributes +
-          [paged_entry_template_attributes: permitted_entry_template_attributes]
-      end
-
       def permitted_theming_attributes
         [
           :cname,
@@ -219,18 +134,6 @@ module Pageflow
           permitted_attributes_for(:theming)
       end
 
-      def permitted_entry_template_attributes
-        [
-          :theme_name,
-          :default_author,
-          :default_publisher,
-          :default_keywords,
-          :default_locale,
-          share_providers: {},
-          configuration: {}
-        ]
-      end
-
       def permitted_attributes_for(resource_name)
         if params[:id]
           Pageflow.config_for(resource).admin_form_inputs.permitted_attributes_for(resource_name)

data/admins/pageflow/entry.rb

@@ -130,6 +130,14 @@ module Pageflow
                   input_html: {style: 'width: 200px'})
         end
 
+        if f.object.new_record?
+          f.input :type_name,
+                  as: :select,
+                  include_blank: false,
+                  collection: entry_type_collection,
+                  wrapper_html: {style: 'display: none'}
+        end
+
         if authorized?(:configure_folder_for, resource)
           folder_collection = collection_for_folders(resource.account, resource.folder)
           f.input(:folder,
@@ -168,6 +176,18 @@ module Pageflow
       end
     end
 
+    collection_action :entry_types do
+      account = Pageflow::Account.find(params[:account_id])
+
+      if authorized?(:see_entry_types, account)
+        @entry_types = helpers.entry_type_collection_for_account(account)
+
+        render(layout: false)
+      else
+        render(partial: 'not_allowed_to_see_entry_types', status: 403)
+      end
+    end
+
     member_action :duplicate, method: :post do
       entry = Entry.find(params[:id])
       authorize!(:duplicate, entry)
@@ -251,7 +271,7 @@ module Pageflow
       end
 
       def permitted_attributes
-        result = [:title]
+        result = [:title, :type_name]
         target = if !params[:id] && current_user.admin?
                    Account.first
                  elsif params[:id]

data/admins/pageflow/entry_templates.rb

@@ -0,0 +1,140 @@
+module Pageflow
+  ActiveAdmin.register EntryTemplate, as: 'EntryTemplate' do
+    menu false
+    config.batch_actions = false
+    actions :index, :new, :create, :edit, :update
+    form partial: 'form'
+
+    belongs_to :account, parent_class: Pageflow::Account
+
+    breadcrumb do
+      breadcrumb_links.first 3
+    end
+
+    controller do
+      helper Pageflow::Admin::FormHelper
+      helper Pageflow::Admin::WidgetsHelper
+
+      def index
+        redirect_to redirect_path
+      end
+
+      def new
+        account = Account.find(params[:account_id])
+        @entry_template = EntryTemplate.new(
+          account: account,
+          entry_type_name: params[:entry_type_name]
+        )
+
+        @page_title = page_title('new', params[:entry_type_name])
+
+        super
+      end
+
+      def create
+        @entry_template = EntryTemplate.new(
+          entry_template_params.merge(account_id: permitted_params[:account_id])
+        )
+        @page_title = page_title('new', @entry_template.entry_type_name)
+        authorize!(:create, @entry_template)
+        create! { redirect_path }
+        update_widgets if @entry_template.errors.empty?
+      end
+
+      def edit
+        @page_title = page_title('edit', resource.entry_type_name)
+        super
+      end
+
+      def update
+        @entry_template = EntryTemplate.find(params[:id])
+        @entry_template.assign_attributes(entry_template_params)
+        @page_title = page_title('edit', @entry_template.entry_type_name)
+        params[:entry_template].delete('share_providers')
+        params[:entry_template].delete('configuration')
+        authorize!(:update, @entry_template)
+        update! { redirect_path }
+        update_widgets if @entry_template.errors.empty?
+      end
+
+      private
+
+      def page_title(rest_verb, entry_type_name)
+        "#{I18n.t('pageflow.admin.entry_templates.page_title.' + rest_verb)} "\
+        "#{I18n.t('activerecord.values.pageflow/entry.type_names.' + entry_type_name)}"
+      end
+
+      def permitted_params
+        params.permit(
+          :account_id,
+          entry_template: permitted_entry_template_attributes
+        )
+      end
+
+      def permitted_entry_template_attributes
+        [
+          :id,
+          :account_id,
+          :entry_type_name,
+          :theme_name,
+          :default_author,
+          :default_publisher,
+          :default_keywords,
+          :default_locale,
+          share_providers: {},
+          configuration: {}
+        ]
+      end
+
+      def redirect_path
+        admin_account_path(params[:account_id], tab: 'entry_templates')
+      end
+
+      def entry_template_params
+        current_params = permitted_params[:entry_template]&.to_hash
+
+        if current_params
+          config = true_false_strings_to_booleans_or_numbers(
+            current_params['configuration']
+          )
+          share_providers = true_false_strings_to_booleans_or_numbers(
+            current_params['share_providers']
+          )
+          current_params.merge('configuration' => config,
+                               'share_providers' => share_providers)
+        else
+          {}
+        end
+      end
+
+      def true_false_strings_to_booleans_or_numbers(hash)
+        hash&.map { |k, v| [k, to_boolean_or_number(v)] }&.to_h
+      end
+
+      def to_boolean_or_number(value)
+        case value
+        when 'false'
+          false
+        when 'true'
+          true
+        when '0'
+          0
+        when '1'
+          1
+        else
+          value
+        end
+      end
+
+      def update_widgets
+        resource.widgets&.batch_update!(widgets_params)
+      end
+
+      def widgets_params
+        (params[:widgets].try(:permit!).to_h || {}).map do |role, type_name|
+          {role: role, type_name: type_name}
+        end
+      end
+    end
+  end
+end

data/admins/pageflow/membership.rb

@@ -64,6 +64,18 @@ module Pageflow
                               end)
 
     controller do
+      # We put the `belongs_to` call in the controller block to work
+      # around the issue that ActiveAdmin does not yet support
+      # polymorphic nested resources [1]. This works since the
+      # underlying InheritedResources library does support polymorphic
+      # nesting [2]. As mentioned in the ActiveAdmin issue, we need to
+      # set up routes manually then, though. This is done in
+      # `Pageflow.routes` [3].
+      #
+      # [1] activeadmin/activeadmin#221
+      # [2] https://github.com/activeadmin/inherited_resources#polymorphic-belongs-to
+      # [3] https://github.com/codevise/pageflow/blob/023fdb7c5b3b917bb94f4adafa18a31f8bd9c753/lib/pageflow.rb#L10
+
       belongs_to :entry, parent_class: Pageflow::Entry, polymorphic: true
       belongs_to :account, parent_class: Pageflow::Account, polymorphic: true
       belongs_to :user, parent_class: User, polymorphic: true

data/admins/pageflow/user.rb

@@ -122,9 +122,11 @@ module Pageflow
 
     collection_action :quota_state do
       @account = Pageflow::Account.find(params[:account_id])
-      authorize!(:add_member_to, @account)
-
-      render(layout: false)
+      if authorized?(:see_user_quota, @account)
+        render(layout: false)
+      else
+        render(partial: 'not_allowed_to_see_user_quota')
+      end
     end
 
     collection_action 'me', title: I18n.t('pageflow.admin.users.account'), method: [:get, :patch] do

data/app/assets/javascripts/pageflow/admin/entries.js

@@ -85,4 +85,69 @@ jQuery(function($) {
       return $(folder).data('role') === 'all';
     }
   });
+
+  $('.admin_entries form.entry').each(function() {
+    var accountSelect = $('#entry_account_id', this);
+    var entryTypeInput = $('#entry_type_name_input', this);
+    var entryTypeSelect = $('#entry_type_name', this);
+    var entryTypeOptions = $('#entry_type_name option', this);
+
+    function updateEntryTypeOptions() {
+      var selectedAccountId = accountSelect.val();
+      hideAllOptions();
+
+      $.get('/admin/entries/entry_types?account_id=' + selectedAccountId)
+        .done(function(response) {
+          var typeNames = response.map(function(item) {
+            return item.type_name;
+          });
+          updateForm(typeNames);
+          if (currentSelectedUnavailable(typeNames)) {
+            updateSelected(typeNames[0]);
+          }
+          if (response.length < 2) {
+            hideInput();
+          } else {
+            showInput();
+          }
+        });
+    }
+
+    function updateForm(entryTypes) {
+      entryTypes.forEach(showOption);
+    }
+
+    function currentSelectedUnavailable(entryTypes) {
+      var selectedEntryType = entryTypeSelect.children('option:selected').val();
+
+      return !entryTypes.includes(selectedEntryType);
+    }
+
+    function updateSelected(firstAvailable) {
+      entryTypeSelect.val(firstAvailable);
+    }
+
+    function hideInput() {
+      entryTypeInput.hide();
+    }
+
+    function showInput() {
+      entryTypeInput.show();
+    }
+
+    function hideAllOptions() {
+      entryTypeOptions.each(function() {
+        $(this).hide();
+      });
+    }
+
+    function showOption(entryType) {
+      $('#entry_type_name option[value=' + entryType + ']').show();
+    }
+
+    if (entryTypeOptions.length > 1) {
+      accountSelect.on('change', updateEntryTypeOptions);
+      updateEntryTypeOptions();
+    }
+  });
 });