1 files changed, 74 insertions, 15 deletions

diff --git a/app/models/node.rb b/app/models/node.rb
index a440c2f..7a93e79 100644
--- a/app/models/node.rb
+++ b/app/models/node.rb
@@ -4,7 +4,14 @@ class Node < ApplicationRecord
 
   # Associations
   has_many    :pages, -> { order("revision ASC") }, :dependent => :destroy
+
+  # Entries where this node is the primary subject (fast-path column).
+  # For a *complete* history -- including subtree trash/destroy entries
+  # recorded at an ancestor -- use participated_actions instead.
   has_many    :node_actions, :dependent => :nullify
+  has_many    :action_participations, :class_name => "ActionParticipant", :as => :subject
+  has_many    :participated_actions, :through => :action_participations, :source => :node_action
+
   belongs_to  :head,  :class_name => "Page",  :foreign_key => :head_id, optional: true
   belongs_to  :draft, :class_name => "Page",  :foreign_key => :draft_id, optional: true
   # Autosave pages carry no node_id, so has_many :pages does not cover
@@ -312,14 +319,14 @@ class Node < ApplicationRecord
       was_published      = head_id.present?
       final_published_at = head&.published_at
 
-      demoted = 0
-      ([self] + descendants.to_a).each do |node|
-        next unless node.head_id
+      subtree = [self] + descendants.to_a
+      demoted_nodes = subtree.select do |node|
+        next false unless node.head_id
         former        = node.head
         node.head     = nil
         node.draft_id = former.id if node.draft_id.nil?
         node.save!
-        demoted += 1
+        true
       end
 
       self.reload
@@ -332,9 +339,10 @@ class Node < ApplicationRecord
       metadata = { :path => { "from" => path_before, "to" => unique_name } }
       metadata[:was_published]      = true if was_published
       metadata[:final_published_at] = final_published_at.iso8601 if final_published_at
-      metadata[:demoted_heads]      = demoted if demoted > 0
+      metadata[:demoted_heads]      = demoted_nodes.size if demoted_nodes.any?
 
-      NodeAction.record!(:node => self, :user => current_user, :action => "trash", **metadata)
+      NodeAction.record!(:participants => subtree, :user => current_user,
+                          :action => "trash", **metadata)
       self
     end
   end
@@ -382,7 +390,8 @@ class Node < ApplicationRecord
       metadata = { :path => unique_name }
       metadata[:destroyed_descendants] = doomed.size - 1 if doomed.size > 1
 
-      NodeAction.record!(:node => self, :user => current_user, :action => "destroy", **metadata)
+      NodeAction.record!(:participants => doomed, :user => current_user,
+                          :action => "destroy", **metadata)
       doomed.each(&:destroy!)
     end
   end
@@ -442,8 +451,65 @@ class Node < ApplicationRecord
     end
   end
 
+  # Attaches an asset to every current lifecycle row -- head, draft and
+  # autosave -- that does not already carry it. Attachments are page-
+  # scoped content (RelatedAsset belongs_to :page; drafts and autosaves
+  # are wholesale clones), so attaching to a single layer is how an
+  # attachment gets silently lost when another layer replaces it at
+  # publish or save. This is the out-of-band counterpart to the
+  # in-editor attach UI; it refuses when someone else holds the editing
+  # lock. Attaching to a head row changes the public page immediately,
+  # by design -- same reasoning as formalizing an already-existing
+  # editorial link.
+  #
+  # headline is a node-level decision: the flag is set on the newly
+  # created joins only when no current row has a headline yet and the
+  # asset is eligible; otherwise the asset is attached plain and the
+  # result says why, so the caller can point the editor at the star in
+  # the editor instead.
+  #
+  # Returns { :attached => n, :already => n,
+  #           :headline => nil | :set | :kept_existing | :not_eligible }
+  def attach_asset! asset, user:, headline: false
+    if in_trash? || trash_node?
+      raise ActiveRecord::RecordInvalid.new(self), "Cannot attach assets to a node in the Trash"
+    end
+
+    if lock_owner && lock_owner != user
+      raise(
+        LockedByAnotherUser,
+        "Page is locked by another user who is working on it! " \
+        "Last modification: #{(self.autosave || self.draft || self.head).updated_at.to_fs(:db)}"
+      )
+    end
+
+    rows      = [head, draft, autosave].compact
+    to_attach = rows.reject { |row| row.related_assets.exists?(:asset_id => asset.id) }
+
+    headline_state =
+      if headline && to_attach.any?
+        if !(asset.image? || asset.pdf?)
+          :not_eligible
+        elsif rows.any? { |row| row.headline_asset.present? }
+          :kept_existing
+        else
+          :set
+        end
+      end
+
+    ActiveRecord::Base.transaction do
+      to_attach.each do |row|
+        row.related_assets.create!(:asset => asset, :headline => headline_state == :set)
+      end
+    end
+
+    { :attached => to_attach.size,
+      :already  => rows.size - to_attach.size,
+      :headline => headline_state }
+  end
+
   def title
-    head ? head.title : draft.title
+    editable_page&.title
   end
 
   def update_unique_names?
@@ -533,13 +599,6 @@ class Node < ApplicationRecord
     throw :abort
   end
 
-  def self.recently_changed
-    includes(:head).where(
-      "pages.updated_at < ? AND pages.updated_at > ? AND nodes.parent_id IS NOT NULL",
-      Time.now, Time.now - 14.days
-    ).order("pages.updated_at desc").references(:head)
-  end
-
   protected
     def lock_for! current_user
       self.lock_owner = current_user