card-mod-history 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f748f6e48dcfe648aaa721a41135f026e064752ecf8cdb16f5a9bf2fdf7c845c
+  data.tar.gz: ab636c41792878cd5196ec6dd019d35b560d72c9ffe0d25e5a3e61b9d026229d
+SHA512:
+  metadata.gz: 42167bcf664c4de96c4966872df4211f5fbbb601ceee045e406b5445fed4ee73223c12712ad9aadd131af4382792702db7567703476559ab878b4bf6af15d092
+  data.tar.gz: 49a5f66ce214ccd87a86ffa99898267974c859563cf08d1fddb81dfe72422bec73d64694e8babd91ee6b9ced7ff0f33cae84668049519f4ea2cf8d20d3d3173f

data/lib/card/act.rb

@@ -0,0 +1,137 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  # An "act" is a group of recorded {Card::Action actions} on {Card cards}.
+  # Together, {Act acts}, {Action actions}, and {Change changes} comprise a
+  # comprehensive {Card card} history tracking system.
+  #
+  # For example, if a given web form submissions updates the contents of three cards,
+  # then the submission will result in the recording of three {Action actions}, each
+  # of which is tied to one {Act act}.
+  #
+  # Each act records:
+  #
+  # - the _actor_id_ (an id associated with the account responsible)
+  # - the _card_id_ of the act's primary card
+  # - _acted_at_, a timestamp of the action
+  # - the _ip_address_ of the actor where applicable.
+  #
+  class Act < ApplicationRecord
+    before_save :assign_actor
+    has_many :ar_actions, -> { order :id }, foreign_key: :card_act_id,
+                                            inverse_of: :act,
+                                            class_name: "Card::Action"
+    class << self
+      # remove all acts that have no card. (janitorial)
+      #
+      # CAREFUL - could still have actions even if act card is gone...
+      def delete_cardless
+        left_join = "LEFT JOIN cards ON card_acts.card_id = cards.id"
+        joins(left_join).where("cards.id IS NULL").delete_all
+      end
+
+      # remove all acts that have no action. (janitorial)
+      def delete_actionless
+        joins(
+          "LEFT JOIN card_actions ON card_acts.id = card_act_id"
+        ).where(
+          "card_actions.id is null"
+        ).delete_all
+      end
+
+      # all acts with actions on a given list of cards
+      # @param card_ids [Array of Integers]
+      # @param with_drafts [true, false] (only shows drafts of current user)
+      # @return [Array of Acts]
+      def all_with_actions_on card_ids, with_drafts=false
+        sql = "card_actions.card_id IN (:card_ids) AND (draft is not true"
+        sql << (with_drafts ? " OR actor_id = :user_id)" : ")")
+        all_viewable([sql, { card_ids: card_ids, user_id: Card::Auth.current_id }])
+      end
+
+      # all acts with actions that current user has permission to view
+      # @return [ActiveRecord Relation]
+      def all_viewable action_where=nil
+        relation = joins(ar_actions: :ar_card)
+        relation = relation.where(action_where) if action_where
+        relation.where(Query::CardQuery.viewable_sql).where.not(card_id: nil).distinct
+      end
+
+      def cache
+        Card::Cache[Card::Act]
+      end
+
+      # used by rails time_ago
+      # timestamp is set by rails on create
+      def timestamp_attributes_for_create
+        super << "acted_at"
+      end
+    end
+
+    def actor
+      Card.fetch actor_id
+    end
+
+    # the act's primary card
+    # @return [Card]
+    def card
+      Card.fetch card_id, look_in_trash: true # , skip_modules: true
+
+      # FIXME: if the following is necessary, we need to document why.
+      # generally it's a very bad idea to have type-specific code here.
+
+      # return res unless res&.type_id&.in?([Card::FileID, Card::ImageID])
+      # res.include_set_modules
+    end
+
+    # list of all actions that are part of the act
+    # @return [Array]
+    def actions cached=true
+      return ar_actions unless cached
+
+      self.class.cache.fetch("#{id}-actions") { ar_actions.find_all.to_a }
+    end
+
+    # act's action on the card in question
+    # @param card_id [Integer]
+    # @return [Card::Action]
+    def action_on card_id
+      actions.find do |action|
+        action.card_id == card_id && !action.draft
+      end
+    end
+
+    # act's action on primary card if it exists. otherwise act's first action
+    # @return [Card::Action]
+    def main_action
+      action_on(card_id) || actions.first
+    end
+
+    def draft?
+      main_action.draft
+    end
+
+    # time (in words) since act took place
+    # @return [String]
+    def elapsed_time
+      DateTime.new(acted_at).distance_of_time_in_words_to_now
+    end
+
+    # act's actions on either the card itself or another card that includes it
+    # @param card [Card]
+    # @return [Array of Actions]
+    def actions_affecting card
+      actions.select do |action|
+        (card.id == action.card_id) ||
+          card.nestee_ids.include?(action.card_id)
+      end
+    end
+
+    private
+
+    # used by before filter
+    def assign_actor
+      self.actor_id ||= Auth.current_id
+    end
+  end
+end

data/lib/card/act/act_renderer.rb

@@ -0,0 +1,217 @@
+class Card
+  class Act
+    class ActRenderer
+      def initialize format, act, args
+        @format = format
+        @act = act
+        @act_card = act.card
+        @args = args
+        @card = @format.card
+        @context = @args[:act_context]
+      end
+
+      include ::Bootstrapper
+
+      def method_missing method_name, *args, &block
+        if block_given?
+          @format.send(method_name, *args, &block)
+        else
+          @format.send(method_name, *args)
+        end
+      end
+
+      def respond_to_missing? method_name, _include_private=false
+        @format.respond_to? method_name
+      end
+
+      def render
+        return "" unless @act_card
+
+        act_accordion
+      end
+
+      def header
+        #::Bootstrap.new(self).render do
+        bs_layout do
+          row xs: [10, 2] do
+            column do
+              html title
+              tag(:span, "text-muted pl-1 badge") { summary }
+            end
+            column act_links, class: "text-right"
+          end
+        end
+        # end
+      end
+
+      def absolute_title
+        accordion_expand_link(@act_card.name)
+      end
+
+      def details
+        approved_actions[0..20].map do |action|
+          Action::ActionRenderer.new(@format, action, action_header?,
+                                     :summary).render
+        end.join
+      end
+
+      def summary
+        %i[create update delete draft].map do |type|
+          next unless count_types[type].positive?
+
+          "#{@format.action_icon type}<small> #{count_types[type]}</small>"
+        end.compact.join "<small class='text-muted'> | </small>"
+      end
+
+      def act_links
+        [
+          link_to_history,
+          (link_to_act_card unless @act_card.trash)
+        ].compact.join " "
+      end
+
+      def link_to_act_card
+        link_to_card @act_card, icon_tag(:new_window), class: "_stop_propagation"
+      end
+
+      def link_to_history
+        link_to_card @act_card, icon_tag(:history),
+                     path: { view: :history, look_in_trash: true },
+                     class: "_stop_propagation",
+                     rel: "nofollow"
+      end
+
+      def approved_actions
+        @approved_actions ||= actions.select { |a| a.card&.ok?(:read) }
+        # FIXME: should not need to test for presence of card here.
+      end
+
+      def action_header?
+        true
+        # @action_header ||= approved_actions.size != 1 ||
+        #                   approved_actions[0].card_id != @format.card.id
+      end
+
+      def count_types
+        @count_types ||=
+          approved_actions.each_with_object(
+            Hash.new { |h, k| h[k] = 0 }
+          ) do |action, type_cnt|
+            type_cnt[action.action_type] += 1
+          end
+      end
+
+      def edited_ago
+        return "" unless @act.acted_at
+
+        "#{time_ago_in_words(@act.acted_at)} ago"
+      end
+
+      def collapse_id
+        "act-id-#{@act.id}"
+      end
+
+      def accordion_expand_link text
+        <<-HTML
+          <a>
+            #{text}
+          </a>
+        HTML
+      end
+
+      # TODO: change accordion API in bootstrap/helper.rb so that it can be used
+      #   here. The problem is that here we have extra links in the title
+      #   that are not supposed to expand the accordion
+      def act_accordion
+        context = @act.main_action.draft ? :warning : :default
+        <<-HTML
+        <div class="card card-#{context} nodblclick">
+          #{act_accordion_panel}
+        </div>
+        HTML
+      end
+
+      def accordion_expand_options
+        {
+          "data-toggle" => "collapse",
+          "data-target" => ".#{collapse_id}",
+          "aria-expanded" => true,
+          "aria-controls" => collapse_id
+        }
+      end
+
+      def act_panel_options
+        { class: "card-header", role: "tab", id: "heading-#{collapse_id}" }
+      end
+
+      def act_accordion_panel
+        act_accordion_heading + act_accordion_body
+      end
+
+      def act_accordion_heading
+        wrap_with :div, act_panel_options.merge(accordion_expand_options) do
+          wrap_with(:h5, header, class: "mb-0") + subtitle
+        end
+      end
+
+      def act_accordion_body
+        wrap_with :div, id: collapse_id,
+                        class: "collapse #{collapse_id}",
+                        "data-parent": ".act-accordion-group" do
+          wrap_with :div, details, class: "card-body"
+        end
+      end
+
+      # Revert:
+      #   current update
+      # Restore:
+      #   current deletion
+      # Revert and Restore:
+      #   old deletions
+      # blank:
+      #   current create
+      # save as current:
+      #   not current, not deletion
+      def rollback_link
+        return unless card.ok? :update
+
+        wrap_with :div, class: "act-link collapse #{collapse_id} float-right" do
+          content_tag(:small, revert_link)
+
+          # link_to "Save as current",
+          #         class: "slotter", remote: true,
+          #         method: :post, rel: "nofollow",
+          #         "data-slot-selector" => ".card-slot.history-view",
+          #         path: { action: :update, action_ids: prior,
+          #                 view: :open, look_in_trash: true }
+        end
+      end
+
+      def deletion_act?
+        act_type == :delete
+      end
+
+      def act_type
+        @act.main_action.action_type
+      end
+
+      def show_or_hide_changes_link
+        wrap_with :div, class: "act-link" do
+          @format.link_to_view(
+            :act, "#{@args[:hide_diff] ? 'Show' : 'Hide'} changes",
+            path: { act_id: @args[:act].id, act_seq: @args[:act_seq],
+                    hide_diff: !@args[:hide_diff], action_view: :expanded,
+                    act_context: @args[:act_context], look_in_trash: true }
+          )
+        end
+      end
+
+      def autosaved_draft_link opts={}
+        text = opts.delete(:text) || "autosaved draft"
+        opts[:path] = { edit_draft: true }
+        add_class opts, "navbar-link"
+        link_to_view :edit, text, opts
+      end
+    end
+  end
+end

data/lib/card/act/act_renderer/absolute_act_renderer.rb

@@ -0,0 +1,34 @@
+class Card
+  class Act
+    class ActRenderer
+      # Used for recent changes.
+      # It shows all actions of an act
+      class AbsoluteActRenderer < ActRenderer
+        def title
+          absolute_title
+        end
+
+        def subtitle
+          wrap_with :small do
+            [
+              @format.link_to_card(@act.actor, nil, class: "_stop_propagation"),
+              edited_ago,
+              rollback_link
+            ]
+          end
+        end
+
+        # FIXME: how do we know we need main here??
+        def revert_link
+          revert_actions_link "revert to previous",
+                              { revert_to: :previous, revert_act: @act.id },
+                              "data-slot-selector": "#main > .card-slot"
+        end
+
+        def actions
+          @act.actions
+        end
+      end
+    end
+  end
+end

data/lib/card/act/act_renderer/bridge_act_renderer.rb

@@ -0,0 +1,53 @@
+class Card
+  class Act
+    class ActRenderer
+      # Used for the bridge
+      class BridgeActRenderer < RelativeActRenderer
+        def title
+          wrap_with(:div, left_title, class: "mr-2") +
+            wrap_with(:div, right_title, class: "ml-auto act-summary")
+        end
+
+        def left_title
+          ["##{@args[:act_seq]}", @act.actor.name, wrap_with(:small, edited_ago)].join " "
+        end
+
+        def right_title
+          summary
+        end
+
+        def render
+          return "" unless @act_card
+
+          details
+        end
+
+        def bridge_link
+          opts = @format.bridge_link_opts(
+            path: { act_id: @act.id, view: :bridge_act, act_seq: @args[:act_seq] },
+            "data-toggle": "pill"
+          )
+          add_class opts, "d-flex nav-link"
+          opts[:path].delete :layout
+          link_to_card @card, title, opts
+        end
+
+        def overlay_title
+          wrap_with :div do
+            [left_title, summary,
+             subtitle.present? ? subtitle : nil,
+             rollback_or_edit_link].compact.join " | "
+          end
+        end
+
+        def rollback_or_edit_link
+          if @act.draft?
+            autosaved_draft_link text: "continue editing"
+          elsif show_rollback_link?
+            revert_link
+          end
+        end
+      end
+    end
+  end
+end