Implement StandardEdition Parent/Child relationships with semi-independent publishing workflows [WHIT-3341]

app/components/admin/editions/show/sidebar_actions_component.rb

@@ -23,9 +23,11 @@ def actions
       add_create_action
       add_edit_action
       add_submit_action
-      add_unschedule_action
-      add_schedule_action
-      add_publish_action
+      unless @edition.is_child_document? && !@edition.parent_allows_publishing?
+        add_unschedule_action
+        add_schedule_action
+        add_publish_action
+      end
       add_reject_action
       add_destroy_action
       add_unwithdraw_action

app/controllers/admin/child_documents_controller.rb

@@ -0,0 +1,24 @@
+class Admin::ChildDocumentsController < Admin::EditionsController
+  rescue_from ConfigurableDocumentType::NotFoundError, with: :render_not_found
+
+  def choose_type
+    @permitted_child_document_types = ConfigurableDocumentType.allowed_child_document_types_of(StandardEdition.find(params[:parent_edition_id])).select { |type| can?(current_user, type) }
+
+    render_not_found if @permitted_child_document_types.empty?
+  end
+
+private
+
+  def edition_class
+    StandardEdition
+  end
+
+  def new_edition_params
+    # Set the configurable document type for new editions based on the value from the query parameter submitted with the 'choose_type' form
+    super[:configurable_document_type].blank? ? super.merge(configurable_document_type: params[:configurable_document_type]) : super
+  end
+
+  def render_not_found
+    render "admin/errors/not_found", status: :not_found
+  end
+end

app/controllers/admin/edition_workflow_controller.rb

@@ -77,6 +77,8 @@ def publish
     else
       redirect_to admin_edition_path(@edition), alert: edition_publisher.failure_reason
     end
+  rescue WhitehallError => e
+    redirect_to admin_edition_path(@edition), alert: e.message
   end
 
   def confirm_force_publish
@@ -94,6 +96,8 @@ def force_publish
     else
       redirect_to admin_edition_path(@edition), alert: edition_publisher.failure_reason
     end
+  rescue WhitehallError => e
+    redirect_to admin_edition_path(@edition), alert: e.message
   end
 
   def confirm_unpublish
@@ -110,6 +114,8 @@ def unpublish
       flash.now[:alert] = message if @unpublishing.errors.blank?
       render :confirm_unpublish
     end
+  rescue WhitehallError => e
+    redirect_to admin_edition_path(@edition), alert: e.message
   end
 
   def confirm_unwithdraw; end

app/controllers/admin/editions_controller.rb

@@ -181,6 +181,8 @@ def destroy
     else
       redirect_to admin_edition_path(@edition), alert: edition_deleter.failure_reason
     end
+  rescue WhitehallError => e
+    redirect_to admin_edition_path(@edition), alert: e.message
   end
 
   def update_bypass_id

app/controllers/admin/standard_editions_controller.rb

@@ -37,6 +37,32 @@ def apply_change_type
     end
   end
 
+  # TODO: should this transaction complexity be encapsulated in an EditionService call?
+  # That seems to be how we handle this sort of thing elsewhere.
+  def create
+    success =
+      if updater.can_perform?
+        begin
+          ActiveRecord::Base.transaction do
+            @edition.save!
+            attach_to_parent_if_this_is_a_child!
+            updater.perform!
+          end
+          true
+        rescue ActiveRecord::RecordInvalid => e
+          @edition.errors.merge!(e.record.errors)
+          false
+        end
+      end
+
+    if success
+      redirect_to show_or_edit_path, saved_confirmation_notice
+    else
+      build_edition_dependencies
+      render :new
+    end
+  end
+
   def update
     @edition.current_tab_context = @current_tab_context
     super
@@ -92,4 +118,19 @@ def show_or_edit_path
   def render_not_found
     render "admin/errors/not_found", status: :not_found
   end
+
+  def attach_to_parent_if_this_is_a_child!
+    parent_id = params[:parent_edition_id].presence
+    return unless parent_id
+
+    parent = Edition.find(parent_id)
+    enforce_permission!(:update, parent)
+
+    parent.with_lock do
+      ParentChildRelationship.create!(
+        parent_edition: parent,
+        child_document: @edition.document,
+      )
+    end
+  end
 end

app/models/concerns/standard_edition/child_document.rb

@@ -0,0 +1,41 @@
+module StandardEdition::ChildDocument
+  extend ActiveSupport::Concern
+
+  class IncompatibleParentState < ::WhitehallError; end
+
+  included do
+    has_one :parent_relationship,
+            class_name: "ParentChildRelationship",
+            foreign_key: :child_document_id,
+            primary_key: :document_id,
+            inverse_of: :child_document
+
+    has_one :parent_edition,
+            through: :parent_relationship,
+            source: :parent_edition
+
+    before_update :ensure_publishing_is_allowed!, if: :publishing?
+  end
+
+  def is_child_document?
+    parent_edition.present?
+  end
+
+  def parent_allows_publishing?
+    return true unless is_child_document?
+
+    parent_edition.document.live_edition&.state == "published" && !parent_edition.pre_publication?
+  end
+
+private
+
+  def publishing?
+    will_save_change_to_state? && state == "published"
+  end
+
+  def ensure_publishing_is_allowed!
+    return if parent_allows_publishing?
+
+    raise IncompatibleParentState, "Unable to publish child document"
+  end
+end

app/models/concerns/standard_edition/parent_document.rb

@@ -0,0 +1,80 @@
+module StandardEdition::ParentDocument
+  extend ActiveSupport::Concern
+
+  class UnableToDelete < ::WhitehallError; end
+  class UnableToWithdraw < ::WhitehallError; end
+  class UnableToUnpublish < ::WhitehallError; end
+
+  class Trait < Edition::Traits::Trait
+    def process_associations_after_save(new_edition)
+      ParentChildRelationship
+        .where(parent_edition_id: @edition.id)
+        .find_each do |relationship|
+        ParentChildRelationship.create!(
+          parent_edition_id: new_edition.id,
+          child_document_id: relationship.child_document_id,
+        )
+      end
+    end
+  end
+
+  included do
+    has_many :child_relationships,
+             class_name: "ParentChildRelationship",
+             foreign_key: :parent_edition_id,
+             inverse_of: :parent_edition,
+             dependent: :destroy
+
+    has_many :child_documents,
+             lambda {
+               joins(:editions)
+                 .merge(Edition.all) # applies default scope (i.e. excludes deleted)
+                 .distinct
+             },
+             through: :child_relationships,
+             source: :child_document
+
+    before_update :ensure_no_new_child_documents!, if: :deleting?
+    before_update :ensure_no_children_more_visible_than_parent!, if: :will_save_change_to_state?
+
+    add_trait Trait
+  end
+
+  def allows_child_documents?
+    (type_instance.settings["allowed_child_document_types"] || []).count.positive?
+  end
+
+  def is_parent_document?
+    child_documents.any?
+  end
+
+  def child_editions
+    Edition.where(id: child_documents.select(:latest_edition_id))
+  end
+
+  def new_child_documents
+    child_documents.where(live_edition_id: nil)
+  end
+
+private
+
+  def deleting?
+    will_save_change_to_state? && state == "deleted"
+  end
+
+  def ensure_no_new_child_documents!
+    if allows_child_documents? && new_child_documents.any?
+      raise UnableToDelete, "This document cannot be deleted while it has child documents that have never been published. Delete the draft child documents first."
+    end
+  end
+
+  def ensure_no_children_more_visible_than_parent!
+    if state == "unpublished" && child_editions.any? { |child| child.state.in?(%w[published withdrawn]) }
+      raise UnableToUnpublish, "This document cannot be unpublished while it has child documents that are published or withdrawn. Unpublish the child documents first."
+    end
+
+    if state == "withdrawn" && child_editions.any? { |child| child.state == "published" }
+      raise UnableToWithdraw, "This document cannot be withdrawn while it has child documents that are published. Withdraw the child documents first."
+    end
+  end
+end

app/models/configurable_document_type.rb

@@ -59,6 +59,11 @@ def self.where_group(group)
     all.filter { |t| t.settings["configurable_document_group"] == group }
   end
 
+  def self.allowed_child_document_types_of(parent_edition)
+    allowed_child_document_types = find(parent_edition.configurable_document_type).settings["allowed_child_document_types"]
+    allowed_child_document_types.map { |config| find(config["document_type"]) }
+  end
+
   def self.convertible_from(current_type_key)
     available_types = []
     if (group = ConfigurableDocumentType.find(current_type_key).settings["configurable_document_group"])

app/models/configurable_document_types/topical_event.json

@@ -177,6 +177,11 @@
     "publishing_api_schema_name": "topical_event",
     "publishing_api_document_type": "topical_event",
     "rendering_app": "frontend",
+    "allowed_child_document_types": [
+      {
+        "document_type": "topical_event_about_page"
+      }
+    ],
     "images": {
       "enabled": true,
       "usages": {

app/models/configurable_document_types/topical_event_about_page.json

@@ -0,0 +1,70 @@
+{
+  "key": "topical_event_about_page",
+  "title": "Topical event 'About' page",
+  "description": "???",
+  "forms": {
+    "documents": {
+      "fields": {
+        "body": {
+          "title": "Body",
+          "description": "The main content of the page",
+          "required": true,
+          "block": "govspeak",
+          "attribute_path": ["block_content", "body"],
+          "translatable": true
+        }
+      }
+    }
+  },
+  "schema": {
+    "attributes": {
+      "body": {
+        "type": "string"
+      }
+    },
+    "validations": {
+      "presence": {
+        "attributes": ["body"]
+      },
+      "length": {
+        "attributes": ["body"],
+        "maximum": 16777215
+      },
+      "safe_html": {
+        "attributes": ["body"]
+      },
+      "no_footnotes_allowed": {
+        "attributes": ["body"]
+      },
+      "embedded_contacts_exist": {
+        "attributes": ["body"]
+      }
+    }
+  },
+  "presenters": {
+    "publishing_api": {
+      "details": {
+        "body": "govspeak"
+      },
+      "links": [
+        "parent"
+      ]
+    }
+  },
+  "settings": {
+    "is_child_document": true,
+    "publishing_api_schema_name": "topical_event_about_page",
+    "publishing_api_document_type": "topical_event_about_page",
+    "rendering_app": "frontend",
+    "images": {
+      "enabled": false
+    },
+    "send_change_history": false,
+    "file_attachments_enabled": false,
+    "organisations": null,
+    "backdating_enabled": false,
+    "history_mode_enabled": false,
+    "taxon_required": false,
+    "translations_enabled": true
+  }
+}

app/models/edition.rb

@@ -161,6 +161,10 @@ def path_name
     to_model.class.name.underscore
   end
 
+  def allows_child_documents?
+    false
+  end
+
   def has_been_tagged?
     api_response = Services.publishing_api.get_expanded_links(content_id, with_drafts: false)
 
@@ -249,6 +253,14 @@ def is_latest_edition?
     document.latest_edition == self
   end
 
+  def is_child_document?
+    false
+  end
+
+  def is_parent_document?
+    false
+  end
+
   def all_nation_applicability_selected?
     true
   end