decidim-enhanced_textwork 1.0.0

data/lib/decidim/enhanced_textwork/engine.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "decidim/core"
+
+module Decidim
+  module EnhancedTextwork
+    # This is the engine that runs on the public interface of `decidim-paragraphs`.
+    # It mostly handles rendering the created page associated to a participatory
+    # process.
+    class Engine < ::Rails::Engine
+      isolate_namespace Decidim::EnhancedTextwork
+
+      routes do
+        resources :paragraphs, except: [:destroy] do
+          member do
+            get :compare
+            get :complete
+            get :edit_draft
+            patch :update_draft
+            get :preview
+            get :overview
+            post :publish
+            delete :destroy_draft
+            put :withdraw
+          end
+          resource :paragraph_vote, only: [:create, :destroy]
+          resource :widget, only: :show, path: "embed"
+          resources :versions, only: [:show, :index]
+        end
+        resources :collaborative_drafts, except: [:destroy] do
+          member do
+            post :request_access, controller: "collaborative_draft_collaborator_requests"
+            post :request_accept, controller: "collaborative_draft_collaborator_requests"
+            post :request_reject, controller: "collaborative_draft_collaborator_requests"
+            post :withdraw
+            post :publish
+          end
+          resources :versions, only: [:show, :index]
+        end
+        root to: "paragraphs#index"
+      end
+
+      initializer "decidim.content_processors" do |_app|
+        Decidim.configure do |config|
+          config.content_processors += [:paragraph]
+        end
+      end
+
+      initializer "decidim_enhanced_textwork.view_hooks" do
+        Decidim.view_hooks.register(:participatory_space_highlighted_elements, priority: Decidim::ViewHooks::MEDIUM_PRIORITY) do |view_context|
+          view_context.cell("decidim/enhanced_textwork/highlighted_paragraphs", view_context.current_participatory_space)
+        end
+      end
+
+      initializer "decidim_changes" do
+        config.to_prepare do
+          Decidim::SettingsChange.subscribe "surveys" do |changes|
+            Decidim::EnhancedTextwork::SettingsChangeJob.perform_later(
+              changes[:component_id],
+              changes[:previous_settings],
+              changes[:current_settings]
+            )
+          end
+        end
+      end
+
+      initializer "decidim_enhanced_textwork.mentions_listener" do
+        config.to_prepare do
+          Decidim::Comments::CommentCreation.subscribe do |data|
+            paragraphs = data.dig(:metadatas, :paragraph).try(:linked_paragraphs)
+            Decidim::EnhancedTextwork::NotifyParagraphsMentionedJob.perform_later(data[:comment_id], paragraphs) if paragraphs
+          end
+        end
+      end
+
+      # Subscribes to ActiveSupport::Notifications that may affect a Paragraph.
+      initializer "decidim_enhanced_textwork.subscribe_to_events" do
+        # when a paragraph is linked from a result
+        event_name = "decidim.resourceable.included_paragraphs.created"
+        ActiveSupport::Notifications.subscribe event_name do |_name, _started, _finished, _unique_id, data|
+          payload = data[:this]
+          if payload[:from_type] == Decidim::Accountability::Result.name && payload[:to_type] == Paragraph.name
+            paragraph = Paragraph.find(payload[:to_id])
+            paragraph.update(state: "accepted", state_published_at: Time.current)
+          end
+        end
+      end
+
+      initializer "decidim_enhanced_textwork.add_cells_view_paths" do
+        Cell::ViewModel.view_paths << File.expand_path("#{Decidim::EnhancedTextwork::Engine.root}/app/cells")
+        Cell::ViewModel.view_paths << File.expand_path("#{Decidim::EnhancedTextwork::Engine.root}/app/views") # for paragraph partials
+      end
+
+      initializer "decidim_enhanced_textwork.add_badges" do
+        Decidim::Gamification.register_badge(:paragraphs) do |badge|
+          badge.levels = [1, 5, 10, 30, 60]
+
+          badge.valid_for = [:user, :user_group]
+
+          badge.reset = lambda { |model|
+            case model
+            when User
+              Decidim::Coauthorship.where(
+                coauthorable_type: "Decidim::EnhancedTextwork::Paragraph",
+                author: model,
+                user_group: nil
+              ).count
+            when UserGroup
+              Decidim::Coauthorship.where(
+                coauthorable_type: "Decidim::EnhancedTextwork::Paragraph",
+                user_group: model
+              ).count
+            end
+          }
+        end
+
+        Decidim::Gamification.register_badge(:accepted_paragraphs) do |badge|
+          badge.levels = [1, 5, 15, 30, 50]
+
+          badge.valid_for = [:user, :user_group]
+
+          badge.reset = lambda { |model|
+            paragraph_ids = case model
+                           when User
+                             Decidim::Coauthorship.where(
+                               coauthorable_type: "Decidim::EnhancedTextwork::Paragraph",
+                               author: model,
+                               user_group: nil
+                             ).select(:coauthorable_id)
+                           when UserGroup
+                             Decidim::Coauthorship.where(
+                               coauthorable_type: "Decidim::EnhancedTextwork::Paragraph",
+                               user_group: model
+                             ).select(:coauthorable_id)
+                           end
+
+            Decidim::EnhancedTextwork::Paragraph.where(id: paragraph_ids).accepted.count
+          }
+        end
+
+        Decidim::Gamification.register_badge(:paragraph_votes) do |badge|
+          badge.levels = [5, 15, 50, 100, 500]
+
+          badge.reset = lambda { |user|
+            Decidim::EnhancedTextwork::ParagraphVote.where(author: user).select(:decidim_paragraph_id).distinct.count
+          }
+        end
+      end
+
+      initializer "decidim_enhanced_textwork.register_metrics" do
+        Decidim.metrics_registry.register(:paragraphs) do |metric_registry|
+          metric_registry.manager_class = "Decidim::EnhancedTextwork::Metrics::ParagraphsMetricManage"
+
+          metric_registry.settings do |settings|
+            settings.attribute :highlighted, type: :boolean, default: true
+            settings.attribute :scopes, type: :array, default: %w(home participatory_process)
+            settings.attribute :weight, type: :integer, default: 2
+            settings.attribute :stat_block, type: :string, default: "medium"
+          end
+        end
+
+        Decidim.metrics_registry.register(:accepted_paragraphs) do |metric_registry|
+          metric_registry.manager_class = "Decidim::EnhancedTextwork::Metrics::AcceptedParagraphsMetricManage"
+
+          metric_registry.settings do |settings|
+            settings.attribute :highlighted, type: :boolean, default: false
+            settings.attribute :scopes, type: :array, default: %w(home participatory_process)
+            settings.attribute :weight, type: :integer, default: 3
+            settings.attribute :stat_block, type: :string, default: "small"
+          end
+        end
+
+        Decidim.metrics_registry.register(:enhanced_textwork_votes) do |metric_registry|
+          metric_registry.manager_class = "Decidim::EnhancedTextwork::Metrics::VotesMetricManage"
+
+          metric_registry.settings do |settings|
+            settings.attribute :highlighted, type: :boolean, default: true
+            settings.attribute :scopes, type: :array, default: %w(home participatory_process)
+            settings.attribute :weight, type: :integer, default: 3
+            settings.attribute :stat_block, type: :string, default: "medium"
+          end
+        end
+
+        Decidim.metrics_registry.register(:enhanced_textwork_endorsements) do |metric_registry|
+          metric_registry.manager_class = "Decidim::EnhancedTextwork::Metrics::EndorsementsMetricManage"
+
+          metric_registry.settings do |settings|
+            settings.attribute :highlighted, type: :boolean, default: false
+            settings.attribute :scopes, type: :array, default: %w(participatory_process)
+            settings.attribute :weight, type: :integer, default: 4
+            settings.attribute :stat_block, type: :string, default: "medium"
+          end
+        end
+
+        Decidim.metrics_operation.register(:participants, :paragraphs) do |metric_operation|
+          metric_operation.manager_class = "Decidim::EnhancedTextwork::Metrics::ParagraphParticipantsMetricMeasure"
+        end
+        Decidim.metrics_operation.register(:followers, :paragraphs) do |metric_operation|
+          metric_operation.manager_class = "Decidim::EnhancedTextwork::Metrics::ParagraphFollowersMetricMeasure"
+        end
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/html_to_markdown.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "kramdown"
+
+module Decidim
+  module EnhancedTextwork
+    # This class parses a participatory text document from quill editor in markdown
+    #
+    # This implementation uses Kramdown Base renderer.
+    #
+    class HtmlToMarkdown
+      # Public: Initializes the serializer with a paragraph.
+      def initialize(html)
+        @html = html
+      end
+
+      def to_md
+        ::Kramdown::Document.new(@html, input: "html").to_kramdown
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/markdown_to_paragraphs.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "redcarpet"
+
+module Decidim
+  module EnhancedTextwork
+    # This class parses a participatory text document in markdown and
+    # produces Paragraphs in the form of sections and articles.
+    #
+    # This implementation uses Redcarpet Base renderer.
+    # Redcarpet::Render::Base performs a callback for every block it finds, what MarkdownToParagraphs
+    # does is to implement callbacks for the blocks which it is interested in performing some actions.
+    #
+    class MarkdownToParagraphs < ::Redcarpet::Render::Base
+      # Public: Initializes the serializer with a paragraph.
+      def initialize(component, current_user)
+        super()
+        @component = component
+        @current_user = current_user
+        @last_position = 0
+        @num_sections = 0
+        @list_items = []
+      end
+
+      def parse(document)
+        renderer = self
+        extensions = {
+          # no lax_spacing so that it is easier to group paragraphs in articles.
+          lax_spacing: false,
+          fenced_code_blocks: true,
+          autolink: true,
+          underline: true
+        }
+        parser = ::Redcarpet::Markdown.new(renderer, extensions)
+        parser.render(document)
+      end
+
+      ##########################################
+      # Redcarpet callbacks
+      ##########################################
+
+      # Block-level calls ######################
+
+      # Recarpet callback to process headers.
+      # Creates Paricipatory Text Paragraphs at Section and Subsection levels.
+      def header(title, level)
+        participatory_text_level = if level > 1
+                                     Decidim::EnhancedTextwork::ParticipatoryTextSection::LEVELS[:sub_section]
+                                   else
+                                     Decidim::EnhancedTextwork::ParticipatoryTextSection::LEVELS[:section]
+                                   end
+
+        create_paragraph(title, title, participatory_text_level)
+
+        @num_sections += 1
+        title
+      end
+
+      # Recarpet callback to process paragraphs.
+      # Creates Paricipatory Text Paragraphs at Article level.
+      def paragraph(text)
+        return if text.blank?
+
+        create_paragraph(
+          (@last_position + 1 - @num_sections).to_s,
+          text,
+          Decidim::EnhancedTextwork::ParticipatoryTextSection::LEVELS[:article]
+        )
+
+        text
+      end
+
+      # Render the list as a whole
+      def list(_contents, list_type)
+        return if @list_items.empty?
+
+        body = case list_type
+               when :ordered
+                 @list_items.collect.with_index { |item, idx| "#{idx + 1}. #{item}\n" }.join
+               else
+                 @list_items.collect { |item| "- #{item}\n" }.join
+               end
+        # reset items for the next list
+        @list_items = []
+        create_paragraph(
+          (@last_position + 1 - @num_sections).to_s,
+          body,
+          Decidim::EnhancedTextwork::ParticipatoryTextSection::LEVELS[:article]
+        )
+
+        body
+      end
+
+      # do not render list items, save them for rendering with the whole list
+      def list_item(text, _list_type)
+        @list_items << text.strip
+        nil
+      end
+
+      # Span-level calls #######################
+
+      def link(link, title, content)
+        attrs = %(href="#{link}")
+        attrs += %( title="#{title}") if title.present?
+        "<a #{attrs}>#{content}</a>"
+      end
+
+      def image(link, title, alt_text)
+        attrs = %(src="#{link}")
+        attrs += %( alt="#{alt_text}") if alt_text.present?
+        attrs += %( title="#{title}") if title.present?
+        "<img #{attrs}/>"
+      end
+
+      def emphasis(text)
+        "<em>#{text}</em>"
+      end
+
+      def double_emphasis(text)
+        "<strong>#{text}</strong>"
+      end
+
+      def underline(text)
+        "<u>#{text}</u>"
+      end
+
+      private
+
+      # Prevents PaperTrail from creating versions while producing paragraphs from a document.
+      # A first version will be created when publishing the Participatory Text.
+      def create_paragraph(title, body, participatory_text_level)
+        attributes = {
+          component: @component,
+          title: { I18n.locale => title },
+          body: { I18n.locale => body },
+          participatory_text_level: participatory_text_level
+        }
+
+        PaperTrail.request(enabled: false) do
+          paragraph = Decidim::EnhancedTextwork::ParagraphBuilder.create(
+            attributes: attributes,
+            author: @component.organization,
+            action_user: @current_user
+          )
+
+          @last_position = paragraph.position
+
+          paragraph
+        end
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/odt_to_markdown.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "doc2text"
+require "tempfile"
+
+module Decidim
+  module EnhancedTextwork
+    # This class parses a participatory text document in markdown and
+    # produces Paragraphs in the form of sections and articles.
+    #
+    # This implementation uses Redcarpet Base renderer.
+    # Redcarpet::Render::Base performs a callback for every block it finds, what MarkdownToParagraphs
+    # does is to implement callbacks for the blocks which it is interested in performing some actions.
+    #
+    class OdtToMarkdown
+      # Public: Initializes the serializer with a paragraph.
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def to_md
+        doc_file = doc_to_tmp_file
+        md_file = transform_to_md_file(doc_file)
+        md_file.read
+      end
+
+      #-----------------------------------------------------
+
+      private
+
+      #-----------------------------------------------------
+
+      def doc_to_tmp_file
+        file = Tempfile.new("doc-to-markdown-odt", encoding: "ascii-8bit")
+        file.write(@doc)
+        file
+      end
+
+      def transform_to_md_file(doc_file)
+        md_file = Tempfile.new
+        Doc2Text::Odt::Document.parse_and_save doc_file, md_file
+        md_file
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/paragraph_creator.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # This class is responsible for creating the imported paragraphs
+    # and must be included in paragraphs component's import manifest.
+    class ParagraphCreator < Decidim::Admin::Import::Creator
+      # Retuns the resource class to be created with the provided data.
+      def self.resource_klass
+        Decidim::EnhancedTextwork::Paragraph
+      end
+
+      # Produces a paragraph from parsed data
+      #
+      # Returns a paragraph
+      def produce
+        resource.add_coauthor(context[:current_user], user_group: context[:user_group])
+
+        resource
+      end
+
+      # Saves the paragraph
+      def finish!
+        super # resource.save!
+        notify(resource)
+        publish(resource)
+      end
+
+      private
+
+      attr_reader :context
+
+      def resource
+        @resource ||= Decidim::EnhancedTextwork::Paragraph.new(
+          category: category,
+          scope: scope,
+          title: title,
+          body: body,
+          component: component,
+          published_at: Time.current
+        )
+      end
+
+      def category
+        id = data.has_key?(:category) ? data[:category]["id"] : data[:"category/id"].to_i
+        Decidim::Category.find_by(id: id)
+      end
+
+      def scope
+        id = data.has_key?(:scope) ? data[:scope]["id"] : data[:"scope/id"].to_i
+        Decidim::Scope.find_by(id: id)
+      end
+
+      def title
+        locale_hasher("title", available_locales)
+      end
+
+      def body
+        locale_hasher("body", available_locales)
+      end
+
+      def available_locales
+        @available_locales ||= component.participatory_space.organization.available_locales
+      end
+
+      def component
+        context[:current_component]
+      end
+
+      def notify(paragraph)
+        return if paragraph.coauthorships.empty?
+
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.paragraph_published",
+          event_class: Decidim::EnhancedTextwork::PublishParagraphEvent,
+          resource: paragraph,
+          followers: coauthors_followers(paragraph)
+        )
+      end
+
+      def publish(paragraph)
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.paragraph_published",
+          event_class: Decidim::EnhancedTextwork::PublishParagraphEvent,
+          resource: paragraph,
+          followers: paragraph.participatory_space.followers - coauthors_followers(paragraph),
+          extra: {
+            participatory_space: true
+          }
+        )
+      end
+
+      def coauthors_followers(paragraph)
+        @coauthors_followers ||= paragraph.authors.flat_map(&:followers)
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/paragraph_serializer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # This class serializes a Paragraph so can be exported to CSV, JSON or other
+    # formats.
+    class ParagraphSerializer < Decidim::Exporters::Serializer
+      include Decidim::ApplicationHelper
+      include Decidim::ResourceHelper
+      include Decidim::TranslationsHelper
+
+      # Public: Initializes the serializer with a paragraph.
+      def initialize(paragraph)
+        @paragraph = paragraph
+      end
+
+      # Public: Exports a hash with the serialized data for this paragraph.
+      def serialize
+        {
+          id: paragraph.id,
+          category: {
+            id: paragraph.category.try(:id),
+            name: paragraph.category.try(:name) || empty_translatable
+          },
+          scope: {
+            id: paragraph.scope.try(:id),
+            name: paragraph.scope.try(:name) || empty_translatable
+          },
+          participatory_space: {
+            id: paragraph.participatory_space.id,
+            url: Decidim::ResourceLocatorPresenter.new(paragraph.participatory_space).url
+          },
+          component: { id: component.id },
+          title: paragraph.title,
+          body: paragraph.body,
+          state: paragraph.state.to_s,
+          reference: paragraph.reference,
+          answer: ensure_translatable(paragraph.answer),
+          supports: paragraph.paragraph_votes_count,
+          endorsements: {
+            total_count: paragraph.endorsements.count,
+            user_endorsements: user_endorsements
+          },
+          comments: paragraph.comments_count,
+          attachments: paragraph.attachments.count,
+          followers: paragraph.followers.count,
+          published_at: paragraph.published_at,
+          url: url,
+          meeting_urls: meetings,
+          related_paragraphs: related_paragraphs,
+          is_amend: paragraph.emendation?,
+          original_paragraph: {
+            title: paragraph&.amendable&.title,
+            url: original_paragraph_url
+          }
+        }
+      end
+
+      private
+
+      attr_reader :paragraph
+      alias resource paragraph
+
+      def component
+        paragraph.component
+      end
+
+      def meetings
+        paragraph.linked_resources(:meetings, "paragraphs_from_meeting").map do |meeting|
+          Decidim::ResourceLocatorPresenter.new(meeting).url
+        end
+      end
+
+      def related_paragraphs
+        paragraph.linked_resources(:paragraphs, "copied_from_component").map do |paragraph|
+          Decidim::ResourceLocatorPresenter.new(paragraph).url
+        end
+      end
+
+      def url
+        Decidim::ResourceLocatorPresenter.new(paragraph).url
+      end
+
+      def user_endorsements
+        paragraph.endorsements.for_listing.map { |identity| identity.normalized_author&.name }
+      end
+
+      def original_paragraph_url
+        return unless paragraph.emendation? && paragraph.amendable.present?
+
+        Decidim::ResourceLocatorPresenter.new(paragraph.amendable).url
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/participatory_text_section.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # The data store for a Paragraph in the Decidim::EnhancedTextwork component.
+    module ParticipatoryTextSection
+      extend ActiveSupport::Concern
+
+      LEVELS = {
+        section: "section", sub_section: "sub-section", article: "article"
+      }.freeze
+
+      included do
+        # Public: is this section an :article?
+        def article?
+          participatory_text_level == LEVELS[:article]
+        end
+      end
+    end
+  end
+end

data/lib/decidim/enhanced_textwork/test/capybara_paragraphs_picker.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "decidim/dev/test/rspec_support/capybara_data_picker"
+
+module Capybara
+  module EnhancedTextworkPicker
+    include DataPicker
+
+    RSpec::Matchers.define :have_paragraphs_picked do |expected|
+      match do |paragraphs_picker|
+        data_picker = paragraphs_picker.data_picker
+
+        expected.each do |paragraph|
+          expect(data_picker).to have_selector(".picker-values div input[value='#{paragraph.id}']", visible: :all)
+          expect(data_picker).to have_selector(:xpath, "//div[contains(@class,'picker-values')]/div/a[text()[contains(.,\"#{translated(paragraph.title)}\")]]")
+        end
+      end
+    end
+
+    RSpec::Matchers.define :have_paragraphs_not_picked do |expected|
+      match do |paragraphs_picker|
+        data_picker = paragraphs_picker.data_picker
+
+        expected.each do |paragraph|
+          expect(data_picker).not_to have_selector(".picker-values div input[value='#{paragraph.id}']", visible: :all)
+          expect(data_picker).not_to have_selector(:xpath, "//div[contains(@class,'picker-values')]/div/a[text()[contains(.,\"#{translated(paragraph.title)}\")]]")
+        end
+      end
+    end
+
+    def paragraphs_pick(paragraphs_picker, paragraphs)
+      data_picker = paragraphs_picker.data_picker
+
+      expect(data_picker).to have_selector(".picker-prompt")
+      data_picker.find(".picker-prompt").click
+
+      paragraphs.each do |paragraph|
+        data_picker_choose_value(paragraph.id)
+      end
+      data_picker_close
+
+      expect(paragraphs_picker).to have_paragraphs_picked(paragraphs)
+    end
+
+    def paragraphs_remove(paragraphs_picker, paragraphs)
+      data_picker = paragraphs_picker.data_picker
+
+      paragraphs.each do |paragraph|
+        data_picker.find("a", text: paragraph.title["en"]).find("span").click
+      end
+
+      expect(paragraphs_picker).to have_paragraphs_not_picked(paragraphs)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Capybara::ParagraphsPicker, type: :system
+end