decidim-collaborative_texts 0.31.0.rc1

data/app/controllers/decidim/collaborative_texts/suggestions_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    class SuggestionsController < Decidim::CollaborativeTexts::ApplicationController
+      include Decidim::FormFactory
+      include Decidim::AjaxPermissionHandler
+
+      helper_method :documents, :document
+
+      def index
+        render json: suggestions_for(document.consolidated_version)
+      end
+
+      def create
+        enforce_permission_to :suggest, :collaborative_text
+        @form = form(SuggestionForm).from_params(params)
+
+        CreateSuggestion.call(@form) do
+          on(:ok) do
+            render json: { message: I18n.t("suggestions.create.success", scope: "decidim.collaborative_texts") }
+          end
+
+          on(:invalid) do
+            message = [I18n.t("suggestions.create.invalid", scope: "decidim.collaborative_texts")]
+            message.push(@form.errors.full_messages.join(", ")) if @form.errors.any?
+            render json: { message: message.join(" ") }, status: :unprocessable_entity
+          end
+        end
+      end
+
+      private
+
+      def suggestions_for(version)
+        version.suggestions.map do |suggestion|
+          suggestion.presenter.safe_json.merge(
+            profileHtml: cell("decidim/author", suggestion.author.presenter).to_s.strip
+          )
+        end
+      end
+
+      def document
+        @document ||= documents.find(params[:document_id])
+      end
+
+      def documents
+        @documents ||= if current_user&.admin?
+                         Document.where(component: current_component)
+                       else
+                         Document.published.where(component: current_component)
+                       end
+      end
+    end
+  end
+end

data/app/events/decidim/collaborative_texts/suggestion_accepted_event.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Decidim::CollaborativeTexts
+  class SuggestionAcceptedEvent < Decidim::Events::SimpleEvent
+  end
+end

data/app/forms/decidim/collaborative_texts/admin/document_form.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      # This class holds a Form to create/update documents from Decidim's admin panel.
+      class DocumentForm < Decidim::Form
+        include Decidim::TranslatableAttributes
+        include Decidim::ApplicationHelper
+
+        mimic :document
+
+        attribute :title, String
+        attribute :body, Decidim::Attributes::RichText
+        attribute :accepting_suggestions, Boolean, default: false
+        attribute :draft, Boolean, default: false
+        translatable_attribute :announcement, Decidim::Attributes::RichText
+
+        validates :title, presence: true, etiquette: true, unless: ->(form) { form.title.nil? }
+        validates :body, presence: true, unless: ->(form) { form.body.nil? } # no etiquette validation for body as it might trigger false positives
+
+        def coauthorships
+          # ensures the first author is always the organization in case "official?" is ever used
+          [Decidim::Coauthorship.new(author: current_organization)]
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/collaborative_texts/rollout_form.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    class RolloutForm < Decidim::Form
+      attribute :body, Decidim::Attributes::RichText
+      attribute :draft, Boolean, default: true
+      attribute :accepted, Array[Integer], default: []
+      attribute :pending, Array[Integer], default: []
+
+      validates :body, presence: true
+
+      def document
+        @document ||= context[:document]
+      end
+
+      def accepted_suggestions
+        @accepted_suggestions ||= document.suggestions.where(id: accepted)
+      end
+
+      def pending_suggestions
+        @pending_suggestions ||= document.suggestions.where(id: pending)
+      end
+    end
+  end
+end

data/app/forms/decidim/collaborative_texts/suggestion_form.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    class SuggestionForm < Decidim::Form
+      include JsonbAttributes
+
+      mimic :document
+
+      jsonb_attribute :changeset, [
+        [:original, Array[String]],
+        [:replace, Array[String]],
+        [:firstNode, Integer],
+        [:lastNode, Integer]
+      ]
+      attribute :status, String, default: "pending"
+      attribute :document_id, Integer
+
+      validate :changes_exists
+
+      alias author current_user
+
+      def document
+        @document ||= ::Decidim::CollaborativeTexts::Document.find(document_id)
+      end
+
+      def document_version
+        @document_version ||= document.current_version
+      end
+
+      private
+
+      def changes_exists
+        errors.add(:base, I18n.t("errors.blank_changeset", scope: "decidim.collaborative_texts.suggestions")) if changeset.blank?
+        if changeset["firstNode"].to_i.zero? || changeset["lastNode"].to_i.zero?
+          errors.add(:base,
+                     I18n.t("errors.invalid_nodes", scope: "decidim.collaborative_texts.suggestions"))
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/collaborative_texts/application_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # Custom helpers, scoped to the collaborative texts engine.
+    module ApplicationHelper
+      def component_name
+        (defined?(current_component) && translated_attribute(current_component&.name).presence) || t("decidim.components.collaborative_texts.name")
+      end
+
+      def document_i18n
+        {
+          selectionActive: t("decidim.collaborative_texts.document.status.selection_active"),
+          rolloutConfirm: t("decidim.collaborative_texts.document.rollout.confirm"),
+          consolidateConfirm: t("decidim.collaborative_texts.document.consolidate.confirm")
+        }
+      end
+    end
+  end
+end

data/app/models/decidim/collaborative_texts/application_record.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # Abstract class from which all models in this engine inherit.
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/models/decidim/collaborative_texts/document.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # The data store for a document in the Decidim::CollaborativeTexts component. It stores a
+    # title, description and any other useful information to render a custom
+    # document.
+    class Document < CollaborativeTexts::ApplicationRecord
+      include Decidim::Resourceable
+      include Decidim::SoftDeletable
+      include Decidim::HasComponent
+      include Decidim::Publicable
+      include Decidim::Traceable
+      include Decidim::Loggable
+      include Decidim::Searchable
+      include Decidim::Coauthorable
+
+      component_manifest_name "collaborative_texts"
+
+      after_save :save_version
+
+      has_many :document_versions, class_name: "Decidim::CollaborativeTexts::Version", inverse_of: :document, dependent: :destroy
+      has_many :suggestions, through: :document_versions
+
+      validates :title, presence: true
+
+      scope :enabled_desc, -> { order(arel_table[:accepting_suggestions].desc, arel_table[:created_at].desc) }
+
+      delegate :organization, :participatory_space, to: :component
+      delegate :draft?, :draft, :draft=, :body, :body=, to: :current_version
+
+      searchable_fields(
+        participatory_space: { component: :participatory_space },
+        A: :title,
+        D: :consolidated_body,
+        datetime: :published_at
+      )
+
+      def self.log_presenter_class_for(_log)
+        Decidim::CollaborativeTexts::AdminLog::DocumentPresenter
+      end
+
+      # Returns the current version of the document. Currently, the last one
+      def current_version
+        document_versions.last || document_versions.build
+      end
+
+      def consolidated_version
+        document_versions.consolidated.last
+      end
+
+      def consolidated_body
+        consolidated_version&.body
+      end
+
+      # The paranoia gem (used in soft-delete) applies the removed status to the "document_versions" association
+      # but it does not recursively restore them by default.
+      # This model needs to have the document_versions synchronized always
+      def restore
+        super(recursive: true)
+      end
+
+      def has_suggestions?
+        current_version.suggestions.any?
+      end
+
+      def suggestions_enabled?
+        published? && accepting_suggestions? && !draft?
+      end
+
+      private
+
+      def save_version
+        current_version.save if current_version.changed?
+      end
+    end
+  end
+end

data/app/models/decidim/collaborative_texts/suggestion.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # The data store for a document in the Decidim::CollaborativeTexts component. It stores a
+    # title, description and any other useful information to render a custom
+    # document.
+    class Suggestion < CollaborativeTexts::ApplicationRecord
+      include Decidim::Traceable
+      include Decidim::Authorable
+
+      after_save :update_document_counters
+
+      enum :status, [:pending, :accepted, :rejected]
+      belongs_to :document_version, class_name: "Decidim::CollaborativeTexts::Version", counter_cache: true, inverse_of: :suggestions
+      has_one :document, class_name: "Decidim::CollaborativeTexts::Document", through: :document_version
+
+      delegate :participatory_space, :organization, to: :document_version
+
+      def self.log_presenter_class_for(_log)
+        Decidim::CollaborativeTexts::AdminLog::SuggestionPresenter
+      end
+
+      def presenter
+        @presenter ||= Decidim::CollaborativeTexts::SuggestionPresenter.new(self)
+      end
+
+      private
+
+      def update_document_counters
+        # Increment the counter cache for the document
+        document.update_column(:suggestions_count, document.suggestions.count) # rubocop:disable Rails/SkipsModelValidations
+      end
+    end
+  end
+end

data/app/models/decidim/collaborative_texts/version.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # The data store for a document in the Decidim::CollaborativeTexts component. It stores a
+    # title, description and any other useful information to render a custom
+    # document.
+    class Version < CollaborativeTexts::ApplicationRecord
+      include Decidim::Resourceable
+      include Decidim::SoftDeletable
+      include Decidim::Traceable
+      include Decidim::Loggable
+
+      belongs_to :document, class_name: "Decidim::CollaborativeTexts::Document", counter_cache: :document_versions_count, inverse_of: :document_versions
+      has_many :suggestions, class_name: "Decidim::CollaborativeTexts::Suggestion", foreign_key: "document_version_id", dependent: :destroy
+
+      validates :body, presence: true
+      validates :draft, presence: true, uniqueness: { scope: :document_id }, if: :draft
+
+      default_scope { order(created_at: :asc) }
+      scope :consolidated, -> { where(draft: false) }
+      scope :draft, -> { where(draft: true) }
+
+      delegate :participatory_space, :organization, to: :document
+
+      def self.log_presenter_class_for(_log)
+        Decidim::CollaborativeTexts::AdminLog::VersionPresenter
+      end
+
+      def version_number
+        @version_number ||= document.document_versions.where(created_at: ..created_at).count
+      end
+    end
+  end
+end

data/app/packs/entrypoints/decidim_collaborative_texts.js

@@ -0,0 +1,7 @@
+import "src/decidim/collaborative_texts/init_documents"
+
+// Images
+require.context("../images", true)
+
+// CSS
+import "stylesheets/decidim/collaborative_texts/collaborative_texts.scss"

data/app/packs/images/decidim/collaborative_texts/decidim_collaborative_texts.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M20 2C20.5523 2 21 2.44772 21 3V6.757L19 8.757V4H5V20H19V17.242L21 15.242V21C21 21.5523 20.5523 22 20 22H4C3.44772 22 3 21.5523 3 21V3C3 2.44772 3.44772 2 4 2H20ZM21.7782 8.80761L23.1924 10.2218L15.4142 18L13.9979 17.9979L14 16.5858L21.7782 8.80761ZM13 12V14H8V12H13ZM16 8V10H8V8H16Z"></path></svg>

data/app/packs/src/decidim/collaborative_texts/document.js

@@ -0,0 +1,168 @@
+import Selection from "src/decidim/collaborative_texts/selection";
+import SuggestionsList from "src/decidim/collaborative_texts/suggestions_list";
+import Manager from "src/decidim/collaborative_texts/manager";
+
+export default class Document {
+  constructor(doc) {
+    this.doc = doc;
+    this.selecting = false;
+    this.applying = false;
+    this.active = false;
+    this.suggestionsList = null;
+    this.templates = {
+      suggestionsEditor: window.document.querySelector(this.doc.dataset.collaborativeTextsSuggestionsEditorTemplate),
+      suggestionsBox: window.document.querySelector(this.doc.dataset.collaborativeTextsSuggestionsBoxTemplate),
+      suggestionsBoxItem: window.document.querySelector(this.doc.dataset.collaborativeTextsSuggestionsBoxItemTemplate)
+    }
+    try  {
+      this.active = JSON.parse(this.doc.dataset.collaborativeTextsDocument);
+    } catch (_e) {
+      console.error("Error parsing collaborativeTextsDocument", this.doc.dataset.collaborativeTextsDocument);
+    }
+    this.i18n = {};
+    try {
+      this.i18n = JSON.parse(this.doc.dataset.collaborativeTextsI18n);
+    } catch (_e) {
+      console.error("Error parsing collaborativeTextsI18n", this.doc.dataset.collaborativeTextsI18n);
+    }
+    this.csrfToken = document.querySelector("meta[name=csrf-token]") && document.querySelector('meta[name="csrf-token"]').getAttribute("content");
+    this.alertWrapper = window.document.querySelector(".collaborative-texts-alert");
+    this.alertDiv = this.alertWrapper.querySelector("div");
+    this._prepareNodes();
+    this._bindManager();
+  }
+
+  // listen to new selections and allows the user to participate in the collaborative text
+  enableSuggestions() {
+    window.document.addEventListener("selectstart", this._onSelectionStart.bind(this));
+    window.document.addEventListener("mouseup", this._onSelectionEnd.bind(this));
+    return this;
+  }
+
+  // fetches suggestions from the server and updates the UI with the wraps
+  fetchSuggestions() {
+    this.suggestionsList = new SuggestionsList(this);
+    return this;
+  }
+
+  // show an alert message for 5 seconds
+  alert(message) {
+    this.alertDiv.textContent = message;
+    this.alertWrapper.classList.remove("hidden");
+    setTimeout(() => {
+      this.alertWrapper.classList.add("hidden");
+    }, 5000);
+  }
+
+  // bind the manager to the document
+  _bindManager() {
+    this.doc.addEventListener("collaborative-texts:applied", this._onApply.bind(this));
+    this.doc.addEventListener("collaborative-texts:restored", this._onRestore.bind(this));
+    this.doc.addEventListener("collaborative-texts:suggest", this._onSuggest.bind(this));
+  }
+
+  // For all first level nodes of type ELEMENT_NODE, ensure they have a unique id if they do not have one starting with "ct-node-"
+  _prepareNodes() {
+    this.nodes = [];
+    [...this.doc.childNodes].forEach((node) => {
+      if (node.nodeType !== Node.ELEMENT_NODE) {
+        return;
+      }
+      if (!node.id || !node.id.startsWith("ct-node-")) {
+        node.id = `ct-node-${this.nodes.length + 1}`;
+      }
+      this.nodes.push(node);
+    });
+  }
+
+  _onSelectionStart() {
+    this.selecting = true;
+  }
+
+  _onSelectionEnd() {
+    if (window.document.getSelection().toString() === "") {
+      this.selecting = false;
+      return;
+    }
+    if (!this.selecting) {
+      return;
+    }
+    this.selecting = false;
+    this._showEditable();
+  }
+
+  _showEditable() {
+    this.selection = this.selection || new Selection(this);
+    if (this.applying) {
+      return;
+    }
+    if (this.selection.isEditing()) {
+      this.alert(this.i18n.selectionActive);
+      this.selection.scrollIntoView();
+      return;
+    }
+    if (this.selection.isValid()) {
+      this.selection.clear().wrap().showEditor();
+    }
+  }
+
+  _onApply() {
+    if (!this.doc.dataset.collaborativeTextsRolloutUrl) {
+      return;
+    }
+    this.applying = true;
+    this.manager = this.manager || new Manager(this);
+    this.manager.show();
+    this.manager.updateCounters(this.suggestionsList.getApplied().length, this.suggestionsList.getPending().length);
+  }
+
+  _onRestore() {
+    if (!this.suggestionsList.suggestions.find((suggestion) => suggestion.applied)) {
+      this.applying = false;
+      this.manager.hide();
+    }
+  }
+
+  _sanitizeNodes(nodes) {
+    return [...nodes].filter((node) => node).map((node) => (node.nodeType === Node.TEXT_NODE
+      ? node.textContent
+      : node.outerHTML));
+  }
+
+  _onSuggest(event) {
+    let original = this._sanitizeNodes(event.detail.nodes);
+    let replace = this._sanitizeNodes(event.detail.replaceNodes);
+    fetch(this.doc.dataset.collaborativeTextsSuggestionsUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Requested-With": "XMLHttpRequest",
+        "X-CSRF-Token": this.csrfToken
+      },
+      body: JSON.stringify({
+        firstNode: event.detail.firstNode.id.replace(/^ct-node-/, ""),
+        lastNode: event.detail.lastNode.id.replace(/^ct-node-/, ""),
+        original: original,
+        replace: replace
+      })
+    }).
+      then(async (response) => {
+        const data = await response.json();
+        if (!response.ok) {
+          throw new Error(data.message
+            ? data.message
+            : data);
+        }
+
+        if (this.suggestionsList) {
+          this.suggestionsList.destroy();
+        }
+        this.fetchSuggestions();
+      }).
+      catch((error) => {
+        console.error("Error sending suggestion:", error);
+        this.alert(error);
+      });
+  }
+}
+

data/app/packs/src/decidim/collaborative_texts/editor.js

@@ -0,0 +1,80 @@
+export default class Editor {
+  constructor(selection) {
+    this.selection = selection;
+    this.templates = selection.doc.templates;
+    this.doc = selection.doc.doc;
+    this.wrapper = selection.wrapper;
+    this.nodes = selection.nodes;
+    this.firstNode = selection.firstNode;
+    this.lastNode = selection.lastNode;
+    this.editor = null;
+    this.container = null;
+    this._createEditor();
+    this._setupContainer();
+  }
+
+  destroy() {
+    if (!this.editor) {
+      return;
+    }
+    this.editor.remove();
+    this.editor = null;
+  }
+
+  _createEditor() {
+    this.editor = window.document.createElement("div");
+    this.editor.classList.add("collaborative-texts-editor");
+    this.editor.innerHTML = this.templates.suggestionsEditor.innerHTML;
+    this.saveButton = this.editor.querySelector(".collaborative-texts-button-save");
+    this.cancelButton = this.editor.querySelector(".collaborative-texts-button-cancel");
+    this.editor.addEventListener("keydown", (event) => {
+      if (event.ctrlKey && event.key === "Enter") {
+        event.preventDefault();
+        this._save();
+      }
+    });
+    this.saveButton.addEventListener("click", this._save.bind(this));
+    this.cancelButton.addEventListener("click", this._cancel.bind(this));
+    this.wrapper.after(this.editor);
+  }
+
+  _setupContainer() {
+    // This in the future should be the tiptap editor
+    this.container = this.editor.querySelector(".collaborative-texts-editor-container");
+    this.container.innerHTML = this.nodes.map((node) => node.outerHTML).join("");
+    this.originalHtml = this.container.innerHTML;
+    this.container.contentEditable = true;
+    this.container.addEventListener("input", this._change.bind(this));
+    this.container.addEventListener("focusout", this._change.bind(this));
+    this.container.focus();
+  }
+
+  _change() {
+    const newHtml = this.container.innerHTML;
+    if (newHtml === this.originalHtml) {
+      this.saveButton.classList.add("disabled");
+      this.saveButton.disabled = true;
+    } else {
+      this.saveButton.classList.remove("disabled");
+      this.saveButton.disabled = false;
+    }
+  }
+
+  _save() {
+    const event = new CustomEvent("collaborative-texts:suggest", {
+      detail: {
+        nodes: this.nodes,
+        firstNode: this.firstNode,
+        lastNode: this.lastNode,
+        replaceNodes: this.container.childNodes
+      }
+    });
+    this.doc.dispatchEvent(event);
+    this.selection.clear();
+  }
+
+  _cancel() {
+    this.selection.clear();
+  }
+}
+

data/app/packs/src/decidim/collaborative_texts/init_documents.js

@@ -0,0 +1,27 @@
+import Document from "src/decidim/collaborative_texts/document";
+import Toc from "src/decidim/collaborative_texts/toc";
+
+window.CollaborativeTextsDocuments = window.CollaborativeTextsDocuments || {};
+window.CollaborativeTextsToc = window.CollaborativeTextsToc || {};
+document.addEventListener("turbo:load", () => {
+  const documents = window.document.querySelectorAll("[data-collaborative-texts-document]");
+  const tableOfContents = window.document.querySelectorAll("[data-collaborative-texts-toc]");
+  documents.forEach((doc) => {
+    let document = new Document(doc);
+    document.fetchSuggestions();
+    if (document.active) {
+      document.enableSuggestions();
+    }
+
+    window.CollaborativeTextsDocuments[doc.id] = document;
+  });
+
+  tableOfContents.forEach((tocEl) => {
+    let document = window.CollaborativeTextsDocuments[tocEl.dataset.collaborativeTextsToc];
+    if (document) {
+      let toc = new Toc(tocEl, document.doc);
+      toc.render();
+      window.CollaborativeTextsToc[tocEl.id] = toc;
+    }
+  });
+});