Make entry templates editable

Before this change, only one entry template for paged entry type was
editable through the account form, and a scrolled entry template would
be initialized on creation of the first scrolled entry, but not
persisted to the database.

We add an entry template admin for new/create and edit/update
actions. It is accessible only from an entry template tab on account
show page of accounts that have already been created.

We need to customize breadcrumbs and redirects, since there isn't an
index page or a show page for entry templates. To make it clear to the
user what they are currently editing, we customize the form's page
title, as well.

The account now has a list of existing and potential entry templates
that is used to populate the entry templates tab on its show
page. This'll probably change at some point when we allow multiple
entry templates per account/entry type.

Entry template provides translated entry type name as a virtual
attribute for use in several places in the admin.

Even though account publishers cannot access the account show page,
they would be able to edit entry templates using a link, if they have
it.

The account form hints where the form fields have gone. There isn't a
link to the entry templates tab, because for account create, this link
wouldn't work yet.

For now, the entry templates form hard-codes the fact that currently
available config and widget inputs are for the paged entry type. When
we make the analytics widget available for scrolled entry type, this
is likely to change.

Entry templates tab contains entries for all existing entry templates
and all those that could be created according to enabled entry
types. If an entry type is disabled, its corresponding entry template
is not displayed here anymore.

`config_for` can now deal with an entry template argument, which is
used in the entry templates form to retrieve an account config for the
entry template's account.

REDMINE-17306

Author: aviav

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 @@ def permitted_params
         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 @@ def with_permitted_feature_states(result)
         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 @@ def permitted_account_attributes
           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 @@ def permitted_theming_attributes
           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)

admins/pageflow/entry_templates.rb

@@ -0,0 +1,127 @@
+module Pageflow
+  ActiveAdmin.register EntryTemplate, as: 'EntryTemplate' do
+    menu false
+    config.batch_actions = false
+    actions :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 new
+        @page_title = page_title('new', params[:entry_type])
+        super
+      end
+
+      def create
+        @entry_template = EntryTemplate.new(entry_template_params.merge(
+          account_id: permitted_params[:account_id]
+        ))
+        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)
+        super
+      end
+
+      def update
+        @entry_template = EntryTemplate.find(params[:id])
+        @entry_template.assign_attributes(entry_template_params)
+        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,
+          :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

app/models/pageflow/account.rb

@@ -30,6 +30,26 @@ def first_paged_entry_template
       EntryTemplate.find_or_initialize_by(account: self, entry_type: 'paged')
     end
 
+    def existing_and_potential_entry_templates
+      entry_type_names = Pageflow.config_for(self).entry_types.map(&:name)
+      existing_entry_templates = EntryTemplate.where(account_id: id).load
+      allowed_existing_entry_templates =
+        existing_entry_templates.select do |template|
+          entry_type_names.include?(template.entry_type)
+        end
+      free_type_names =
+        entry_type_names - allowed_existing_entry_templates.map(&:entry_type)
+
+      potential_entry_templates = free_type_names.map do |type_name|
+        EntryTemplate.new(
+          account_id: id,
+          entry_type: type_name
+        )
+      end
+
+      allowed_existing_entry_templates + potential_entry_templates
+    end
+
     def blacklist_for_serialization
       [:features_configuration]
     end

app/models/pageflow/entry_template.rb

@@ -16,6 +16,10 @@ class EntryTemplate < ApplicationRecord
                 )
               }
 
+    def translated_entry_type
+      I18n.t("activerecord.values.pageflow/entry.type_names.#{entry_type}")
+    end
+
     def resolve_widgets(options = {})
       widgets.resolve(Pageflow.config_for(account), options)
     end

app/policies/pageflow/entry_template_policy.rb

@@ -5,7 +5,11 @@ def initialize(user, entry_template)
       @entry_template = entry_template
     end
 
-    def edit?
+    def create?
+      update?
+    end
+
+    def update?
       allows?(%w(publisher manager))
     end
 

app/views/admin/accounts/_entry_template_details.html.arb

@@ -1,17 +1,19 @@
-extensible_attributes_table_for(account.first_paged_entry_template,
-                                Pageflow.config_for(account)
+h5(entry_template.translated_entry_type)
+
+extensible_attributes_table_for(entry_template,
+                                Pageflow.config_for(entry_template.account)
                                   .admin_attributes_table_rows.for(:entry_template)) do
   row :theme, class: 'theme' do
-    account.first_paged_entry_template.theme_name
+    entry_template.theme_name
   end
   row :default_locale, class: 'default_locale' do
-    t('pageflow.public._language', locale: account.first_paged_entry_template.default_locale)
+    t('pageflow.public._language', locale: entry_template.default_locale)
   end
   row :default_author, class: 'default_author'
   row :default_publisher, class: 'default_publisher'
   row :default_keywords, class: 'default_keywords'
   row :default_share_providers, class: 'default_share_providers' do
-    account.first_paged_entry_template.default_share_providers
+    entry_template.default_share_providers
            .select { |_k, v| v == true }.keys.map(&:camelize).join(', ')
   end
 end