decidim-enhanced_textwork 1.0.0

data/app/helpers/decidim/enhanced_textwork/paragraph_votes_helper.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Simple helpers to handle markup variations for paragraph votes partials
+    module ParagraphVotesHelper
+      # Returns the css classes used for paragraph votes count in both paragraphs list and show pages
+      #
+      # from_paragraphs_list - A boolean to indicate if the template is rendered from the paragraphs list page
+      #
+      # Returns a hash with the css classes for the count number and label
+      def votes_count_classes(from_paragraphs_list)
+        return { number: "card__support__number", label: "" } if from_paragraphs_list
+
+        { number: "extra__suport-number", label: "extra__suport-text" }
+      end
+
+      # Returns the css classes used for paragraph vote button in both paragraphs list and show pages
+      #
+      # from_paragraphs_list - A boolean to indicate if the template is rendered from the paragraphs list page
+      #
+      # Returns a string with the value of the css classes.
+      def vote_button_classes(from_paragraphs_list)
+        return "card__button" if from_paragraphs_list
+
+        "expanded"
+      end
+
+      # Public: Gets the vote limit for each user, if set.
+      #
+      # Returns an Integer if set, nil otherwise.
+      def vote_limit
+        return nil if component_settings.vote_limit.zero?
+
+        component_settings.vote_limit
+      end
+
+      # Check if the vote limit is enabled for the current component
+      #
+      # Returns true if the vote limit is enabled
+      def vote_limit_enabled?
+        vote_limit.present?
+      end
+
+      # Public: Checks if threshold per paragraph are set.
+      #
+      # Returns true if set, false otherwise.
+      def threshold_per_paragraph_enabled?
+        threshold_per_paragraph.present?
+      end
+
+      # Public: Fetches the maximum amount of votes per paragraph.
+      #
+      # Returns an Integer with the maximum amount of votes, nil otherwise.
+      def threshold_per_paragraph
+        return nil unless component_settings.threshold_per_paragraph.positive?
+
+        component_settings.threshold_per_paragraph
+      end
+
+      # Public: Checks if can accumulate more than maxium is enabled
+      #
+      # Returns true if enabled, false otherwise.
+      def can_accumulate_supports_beyond_threshold?
+        component_settings.can_accumulate_supports_beyond_threshold
+      end
+
+      # Public: Checks if voting is enabled in this step.
+      #
+      # Returns true if enabled, false otherwise.
+      def votes_enabled?
+        current_settings.votes_enabled
+      end
+
+      # Public: Checks if voting is blocked in this step.
+      #
+      # Returns true if blocked, false otherwise.
+      def votes_blocked?
+        current_settings.votes_blocked
+      end
+
+      # Public: Checks if the current user is allowed to vote in this step.
+      #
+      # Returns true if the current user can vote, false otherwise.
+      def current_user_can_vote?
+        current_user && votes_enabled? && vote_limit_enabled? && !votes_blocked?
+      end
+
+      # Return the remaining votes for a user if the current component has a vote limit
+      #
+      # user - A User object
+      #
+      # Returns a number with the remaining votes for that user
+      def remaining_votes_count_for(user)
+        return 0 unless vote_limit_enabled?
+
+        paragraphs = Paragraph.where(component: current_component)
+        votes_count = ParagraphVote.where(author: user, paragraph: paragraphs).size
+        component_settings.vote_limit - votes_count
+      end
+    end
+  end
+end

data/app/helpers/decidim/enhanced_textwork/paragraph_wizard_helper.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Simple helpers to handle markup variations for paragraph wizard partials
+    module ParagraphWizardHelper
+      # Returns the css classes used for the paragraph wizard for the desired step
+      #
+      # step - A symbol of the target step
+      # current_step - A symbol of the current step
+      #
+      # Returns a string with the css classes for the desired step
+      def paragraph_wizard_step_classes(step, current_step)
+        step_i = step.to_s.split("_").last.to_i
+        if step_i == paragraph_wizard_step_number(current_step)
+          %(step--active #{step} #{current_step})
+        elsif step_i < paragraph_wizard_step_number(current_step)
+          %(step--past #{step})
+        else
+          %()
+        end
+      end
+
+      # Returns the number of the step
+      #
+      # step - A symbol of the target step
+      def paragraph_wizard_step_number(step)
+        step.to_s.split("_").last.to_i
+      end
+
+      # Returns the name of the step, translated
+      #
+      # step - A symbol of the target step
+      def paragraph_wizard_step_name(step)
+        t("decidim.enhanced_textwork.paragraphs.wizard_steps.#{step}")
+      end
+
+      # Returns the page title of the given step, translated
+      #
+      # action_name - A string of the rendered action
+      def paragraph_wizard_step_title(action_name)
+        step_title = case action_name
+                     when "create"
+                       "new"
+                     when "update_draft"
+                       "edit_draft"
+                     else
+                       action_name
+                     end
+
+        t("decidim.enhanced_textwork.paragraphs.#{step_title}.title")
+      end
+
+      # Returns the list item of the given step, in html
+      #
+      # step - A symbol of the target step
+      # current_step - A symbol of the current step
+      def paragraph_wizard_stepper_step(step, current_step)
+        attributes = { class: paragraph_wizard_step_classes(step, current_step).to_s }
+        step_title = paragraph_wizard_step_name(step)
+        if step.to_s.split("_").last.to_i == paragraph_wizard_step_number(current_step)
+          current_step_title = paragraph_wizard_step_name("current_step")
+          step_title = content_tag(:span, "#{current_step_title}: ", class: "show-for-sr") + step_title
+          attributes["aria-current"] = "step"
+        end
+
+        content_tag(:li, step_title, attributes)
+      end
+
+      # Returns the list with all the steps, in html
+      #
+      # current_step - A symbol of the current step
+      def paragraph_wizard_stepper(current_step)
+        content_tag :ol, class: "wizard__steps" do
+          %(
+            #{paragraph_wizard_stepper_step(:step_1, current_step)}
+            #{paragraph_wizard_stepper_step(:step_2, current_step)}
+            #{paragraph_wizard_stepper_step(:step_3, current_step)}
+            #{paragraph_wizard_stepper_step(:step_4, current_step)}
+          ).html_safe
+        end
+      end
+
+      # Returns a string with the current step number and the total steps number
+      #
+      def paragraph_wizard_current_step_of(step)
+        current_step_num = paragraph_wizard_step_number(step)
+        see_steps = content_tag(:span, class: "hide-for-large") do
+          concat " ("
+          concat content_tag :a, t(:"decidim.enhanced_textwork.paragraphs.wizard_steps.see_steps"), "data-toggle": "steps"
+          concat ")"
+        end
+        content_tag :span, class: "text-small" do
+          concat t(:"decidim.enhanced_textwork.paragraphs.wizard_steps.step_of", current_step_num: current_step_num, total_steps: total_steps)
+          concat see_steps
+        end
+      end
+
+      def paragraph_wizard_steps_title
+        t("title", scope: "decidim.enhanced_textwork.paragraphs.wizard_steps")
+      end
+
+      # Returns a boolean if the step has a help text defined
+      #
+      # step - A symbol of the target step
+      def paragraph_wizard_step_help_text?(step)
+        translated_attribute(component_settings.try("paragraph_wizard_#{step}_help_text")).present?
+      end
+
+      private
+
+      def total_steps
+        4
+      end
+
+      def wizard_aside_info_text
+        t("info", scope: "decidim.enhanced_textwork.paragraphs.wizard_aside").html_safe
+      end
+
+      # Renders the back link except for step_2: compare
+      def paragraph_wizard_aside_link_to_back(step)
+        case step
+        when :step_1
+          paragraphs_path
+        when :step_3
+          compare_paragraph_path
+        when :step_4
+          edit_draft_paragraph_path
+        end
+      end
+
+      def wizard_aside_back_text(from = nil)
+        key = "back"
+        key = "back_from_#{from}" if from
+
+        t(key, scope: "decidim.enhanced_textwork.paragraphs.wizard_aside").html_safe
+      end
+    end
+  end
+end

data/app/helpers/decidim/enhanced_textwork/paragraphs_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Simple helpers to handle markup variations for paragraphs
+    module ParagraphsHelper
+      def paragraph_reason_callout_announcement
+        {
+          title: paragraph_reason_callout_title,
+          body: decidim_sanitize(translated_attribute(@paragraph.answer))
+        }
+      end
+
+      def paragraph_reason_callout_class
+        case @paragraph.state
+        when "accepted"
+          "success"
+        when "evaluating"
+          "warning"
+        when "rejected"
+          "alert"
+        else
+          ""
+        end
+      end
+
+      def paragraph_reason_callout_title
+        i18n_key = case @paragraph.state
+                   when "evaluating"
+                     "paragraph_in_evaluation_reason"
+                   else
+                     "paragraph_#{@paragraph.state}_reason"
+                   end
+
+        t(i18n_key, scope: "decidim.enhanced_textwork.paragraphs.show")
+      end
+
+      def filter_paragraphs_state_values
+        Decidim::CheckBoxesTreeHelper::TreeNode.new(
+          Decidim::CheckBoxesTreeHelper::TreePoint.new("", t("decidim.enhanced_textwork.application_helper.filter_state_values.all")),
+          [
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("accepted", t("decidim.enhanced_textwork.application_helper.filter_state_values.accepted")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("evaluating", t("decidim.enhanced_textwork.application_helper.filter_state_values.evaluating")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("state_not_published", t("decidim.enhanced_textwork.application_helper.filter_state_values.not_answered")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("rejected", t("decidim.enhanced_textwork.application_helper.filter_state_values.rejected"))
+          ]
+        )
+      end
+
+      def paragraph_has_costs?
+        @paragraph.cost.present? &&
+          translated_attribute(@paragraph.cost_report).present? &&
+          translated_attribute(@paragraph.execution_period).present?
+      end
+
+      def resource_version(resource, options = {})
+        return unless resource.respond_to?(:amendable?) && resource.amendable?
+
+        super
+      end
+    end
+  end
+end

data/app/helpers/decidim/enhanced_textwork/participatory_texts_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Simple helper to handle markup variations for participatory texts related partials
+    module ParticipatoryTextsHelper
+      # Returns the title for a given participatory text section.
+      #
+      # paragraph - The current paragraph item.
+      #
+      # Returns a string with the title of the section, subsection or article.
+      def preview_participatory_text_section_title(paragraph)
+        title = decidim_html_escape(present(paragraph).title)
+        translated = t(paragraph.participatory_text_level, scope: "decidim.enhanced_textwork.admin.participatory_texts.sections", title: title)
+        translated.html_safe
+      end
+
+      def render_participatory_text_title(participatory_text)
+        if participatory_text.nil?
+          t("alternative_title", scope: "decidim.enhanced_textwork.participatory_text_paragraph")
+        else
+          translated_attribute(participatory_text.title)
+        end
+      end
+
+      # Public: A formatted collection of mime_type to be used
+      # in forms.
+      def mime_types_with_document_examples
+        links = ""
+        accepted_mime_types = Decidim::EnhancedTextwork::DocToMarkdown::ACCEPTED_MIME_TYPES.keys
+        accepted_mime_types.each_with_index do |mime_type, index|
+          links += link_to t(".accepted_mime_types.#{mime_type}"),
+                           asset_pack_path("media/documents/participatory_text.#{mime_type}"),
+                           download: "participatory_text.#{mime_type}"
+          links += ", " unless accepted_mime_types.length == index + 1
+        end
+        links
+      end
+
+      def show_paragraph_title?(paragraph)
+        !hide_paragraph_title?(paragraph)
+      end
+
+      def hide_paragraph_title?(paragraph)
+        paragraph.component.settings.hide_participatory_text_titles_enabled? && translated_attribute(paragraph.title) !~ /\D/
+      end
+    end
+  end
+end

data/app/jobs/decidim/enhanced_textwork/notify_paragraphs_mentioned_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class NotifyParagraphsMentionedJob < ApplicationJob
+      def perform(comment_id, linked_paragraphs)
+        comment = Decidim::Comments::Comment.find(comment_id)
+
+        linked_paragraphs.each do |paragraph_id|
+          paragraph = Paragraph.find(paragraph_id)
+          affected_users = paragraph.notifiable_identities
+
+          Decidim::EventsManager.publish(
+            event: "decidim.events.enhanced_textwork.paragraph_mentioned",
+            event_class: Decidim::EnhancedTextwork::ParagraphMentionedEvent,
+            resource: comment.root_commentable,
+            affected_users: affected_users,
+            extra: {
+              comment_id: comment.id,
+              mentioned_paragraph_id: paragraph_id
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/app/jobs/decidim/enhanced_textwork/settings_change_job.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class SettingsChangeJob < ApplicationJob
+      def perform(component_id, previous_settings, current_settings)
+        component = Decidim::Component.find(component_id)
+
+        if creation_enabled?(previous_settings, current_settings)
+          event = "decidim.events.enhanced_textwork.creation_enabled"
+          event_class = Decidim::EnhancedTextwork::CreationEnabledEvent
+        elsif voting_enabled?(previous_settings, current_settings)
+          event = "decidim.events.enhanced_textwork.voting_enabled"
+          event_class = Decidim::EnhancedTextwork::VotingEnabledEvent
+        elsif endorsing_enabled?(previous_settings, current_settings)
+          event = "decidim.events.enhanced_textwork.endorsing_enabled"
+          event_class = Decidim::EnhancedTextwork::EndorsingEnabledEvent
+        end
+
+        return unless event && event_class
+
+        Decidim::EventsManager.publish(
+          event: event,
+          event_class: event_class,
+          resource: component,
+          followers: component.participatory_space.followers
+        )
+      end
+
+      private
+
+      # rubocop:disable Style/DoubleNegation
+      def creation_enabled?(previous_settings, current_settings)
+        current_settings[:creation_enabled] == true &&
+          !!previous_settings[:creation_enabled] == false
+      end
+
+      def voting_enabled?(previous_settings, current_settings)
+        (current_settings[:votes_enabled] == true && !!current_settings[:votes_blocked] == false) &&
+          (!!previous_settings[:votes_enabled] == false || previous_settings[:votes_blocked] == true)
+      end
+
+      def endorsing_enabled?(previous_settings, current_settings)
+        (current_settings[:endorsements_enabled] == true && !!current_settings[:endorsements_blocked] == false) &&
+          (!!previous_settings[:endorsements_enabled] == false || previous_settings[:endorsements_blocked] == true)
+      end
+      # rubocop:enable Style/DoubleNegation
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # 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/enhanced_textwork/collaborative_draft.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class CollaborativeDraft < EnhancedTextwork::ApplicationRecord
+      include Decidim::Resourceable
+      include Decidim::Coauthorable
+      include Decidim::HasComponent
+      include Decidim::ScopableResource
+      include Decidim::HasReference
+      include Decidim::HasCategory
+      include Decidim::Reportable
+      include Decidim::HasAttachments
+      include Decidim::Followable
+      include Decidim::EnhancedTextwork::CommentableCollaborativeDraft
+      include Decidim::Traceable
+      include Decidim::Loggable
+      include Decidim::Randomable
+
+      has_many :collaborator_requests,
+               class_name: "Decidim::EnhancedTextwork::CollaborativeDraftCollaboratorRequest",
+               foreign_key: :decidim_enhanced_textwork_collaborative_draft_id,
+               dependent: :destroy
+
+      has_many :requesters,
+               through: :collaborator_requests,
+               source: :user,
+               class_name: "Decidim::User",
+               foreign_key: :decidim_user_id
+
+      geocoded_by :address
+
+      scope :open, -> { where(state: "open") }
+      scope :withdrawn, -> { where(state: "withdrawn") }
+      scope :except_withdrawn, -> { where.not(state: "withdrawn").or(where(state: nil)) }
+      scope :published, -> { where(state: "published") }
+
+      # Checks whether the user can edit the given paragraph.
+      #
+      # user - the user to check for authorship
+      def editable_by?(user)
+        authored_by?(user)
+      end
+
+      def open?
+        state == "open"
+      end
+
+      def withdrawn?
+        state == "withdrawn"
+      end
+
+      def published?
+        state == "published"
+      end
+
+      # Public: Overrides the `reported_content_url` Reportable concern method.
+      def reported_content_url
+        ResourceLocatorPresenter.new(self).url
+      end
+
+      # Public: Overrides the `reported_attributes` Reportable concern method.
+      def reported_attributes
+        [:body]
+      end
+
+      # Public: Overrides the `reported_searchable_content_extras` Reportable concern method.
+      def reported_searchable_content_extras
+        [authors.map(&:name).join("\n")]
+      end
+    end
+  end
+end

data/app/models/decidim/enhanced_textwork/collaborative_draft_collaborator_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A collaborative_draft can accept requests to coauthor and contribute
+    class CollaborativeDraftCollaboratorRequest < EnhancedTextwork::ApplicationRecord
+      validates :collaborative_draft, :user, presence: true
+
+      belongs_to :collaborative_draft, class_name: "Decidim::EnhancedTextwork::CollaborativeDraft", foreign_key: :decidim_enhanced_textwork_collaborative_draft_id
+      belongs_to :user, class_name: "Decidim::User", foreign_key: :decidim_user_id
+    end
+  end
+end