decidim-enhanced_textwork 1.0.0

data/app/helpers/decidim/enhanced_textwork/admin/paragraph_bulk_actions_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      module ParagraphBulkActionsHelper
+        # Public: Generates a select field with the valuators of the given participatory space.
+        #
+        # participatory_space - A participatory space instance.
+        # prompt - An i18n string to show as prompt
+        #
+        # Returns a String.
+        def bulk_valuators_select(participatory_space, prompt)
+          options_for_select = find_valuators_for_select(participatory_space)
+          select(:valuator_role, :id, options_for_select, prompt: prompt)
+        end
+
+        # Internal: A method to cache to queries to find the valuators for the
+        # current space.
+        def find_valuators_for_select(participatory_space)
+          return @valuators_for_select if @valuators_for_select
+
+          valuator_roles = participatory_space.user_roles(:valuator)
+          valuators = Decidim::User.where(id: valuator_roles.pluck(:decidim_user_id)).to_a
+
+          @valuators_for_select = valuator_roles.map do |role|
+            valuator = valuators.find { |user| user.id == role.decidim_user_id }
+
+            [valuator.name, role.id]
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/enhanced_textwork/admin/paragraph_rankings_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # This class contains helpers needed to get rankings for a given paragraph
+      # ordered by some given criteria.
+      #
+      module ParagraphRankingsHelper
+        # Public: Gets the ranking for a given paragraph, ordered by some given
+        # criteria. Paragraph is sorted amongst its own siblings.
+        #
+        # Returns a Hash with two keys:
+        #   :ranking - an Integer representing the ranking for the given paragraph.
+        #     Ranking starts with 1.
+        #   :total - an Integer representing the total number of ranked paragraphs.
+        #
+        # Examples:
+        #   ranking_for(paragraph, paragraph_votes_count: :desc)
+        #   ranking_for(paragraph, endorsements_count: :desc)
+        def ranking_for(paragraph, order = {})
+          siblings = Decidim::EnhancedTextwork::Paragraph.where(component: paragraph.component)
+          ranked = siblings.order([order, { id: :asc }])
+          ranked_ids = ranked.pluck(:id)
+
+          { ranking: ranked_ids.index(paragraph.id) + 1, total: ranked_ids.count }
+        end
+
+        # Public: Gets the ranking for a given paragraph, ordered by endorsements.
+        def endorsements_ranking_for(paragraph)
+          ranking_for(paragraph, endorsements_count: :desc)
+        end
+
+        # Public: Gets the ranking for a given paragraph, ordered by votes.
+        def votes_ranking_for(paragraph)
+          ranking_for(paragraph, paragraph_votes_count: :desc)
+        end
+
+        def i18n_endorsements_ranking_for(paragraph)
+          rankings = endorsements_ranking_for(paragraph)
+
+          I18n.t(
+            "ranking",
+            scope: "decidim.enhanced_textwork.admin.paragraphs.show",
+            ranking: rankings[:ranking],
+            total: rankings[:total]
+          )
+        end
+
+        def i18n_votes_ranking_for(paragraph)
+          rankings = votes_ranking_for(paragraph)
+
+          I18n.t(
+            "ranking",
+            scope: "decidim.enhanced_textwork.admin.paragraphs.show",
+            ranking: rankings[:ranking],
+            total: rankings[:total]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # This class contains helpers needed to format Meetings
+      # in order to use them in select forms for Paragraphs.
+      #
+      module ParagraphsHelper
+        include Decidim::Admin::ResourceScopeHelper
+
+        # Public: A formatted collection of Meetings to be used
+        # in forms.
+        def meetings_as_authors_selected
+          return unless @paragraph.present? && @paragraph.official_meeting?
+
+          @meetings_as_authors_selected ||= @paragraph.authors.pluck(:id)
+        end
+
+        def coauthor_presenters_for(paragraph)
+          paragraph.authors.map do |identity|
+            if identity.is_a?(Decidim::Organization)
+              Decidim::EnhancedTextwork::OfficialAuthorPresenter.new
+            else
+              present(identity)
+            end
+          end
+        end
+
+        def endorsers_presenters_for(paragraph)
+          paragraph.endorsements.for_listing.map { |identity| present(identity.normalized_author) }
+        end
+
+        def paragraph_complete_state(paragraph)
+          return humanize_paragraph_state(paragraph.internal_state).html_safe if paragraph.answered? && !paragraph.published_state?
+
+          humanize_paragraph_state(paragraph.state).html_safe
+        end
+
+        def paragraphs_admin_filter_tree
+          {
+            t("paragraphs.filters.type", scope: "decidim.enhanced_textwork") => {
+              link_to(t("paragraphs", scope: "decidim.enhanced_textwork.application_helper.filter_type_values"), q: ransak_params_for_query(is_emendation_true: "0"),
+                                                                                                        per_page: per_page) => nil,
+              link_to(t("amendments", scope: "decidim.enhanced_textwork.application_helper.filter_type_values"), q: ransak_params_for_query(is_emendation_true: "1"),
+                                                                                                         per_page: per_page) => nil
+            },
+            t("models.paragraph.fields.state", scope: "decidim.enhanced_textwork") =>
+              Decidim::EnhancedTextwork::Paragraph::POSSIBLE_STATES.each_with_object({}) do |state, hash|
+                if state == "not_answered"
+                  hash[link_to((humanize_paragraph_state state), q: ransak_params_for_query(state_null: 1), per_page: per_page)] = nil
+                else
+                  hash[link_to((humanize_paragraph_state state), q: ransak_params_for_query(state_eq: state), per_page: per_page)] = nil
+                end
+              end,
+            t("models.paragraph.fields.category", scope: "decidim.enhanced_textwork") => admin_filter_categories_tree(categories.first_class),
+            t("paragraphs.filters.scope", scope: "decidim.enhanced_textwork") => admin_filter_scopes_tree(current_component.organization.id)
+          }
+        end
+
+        def paragraphs_admin_search_hidden_params
+          return unless params[:q]
+
+          tags = ""
+          tags += hidden_field_tag "per_page", params[:per_page] if params[:per_page]
+          tags += hidden_field_tag "q[is_emendation_true]", params[:q][:is_emendation_true] if params[:q][:is_emendation_true]
+          tags += hidden_field_tag "q[state_eq]", params[:q][:state_eq] if params[:q][:state_eq]
+          tags += hidden_field_tag "q[category_id_eq]", params[:q][:category_id_eq] if params[:q][:category_id_eq]
+          tags += hidden_field_tag "q[scope_id_eq]", params[:q][:scope_id_eq] if params[:q][:scope_id_eq]
+          tags.html_safe
+        end
+
+        def paragraphs_admin_filter_applied_filters
+          html = []
+          if params[:q][:is_emendation_true].present?
+            html << tag.span(class: "label secondary") do
+              tag = "#{t("filters.type", scope: "decidim.enhanced_textwork.paragraphs")}: "
+              tag += if params[:q][:is_emendation_true].to_s == "1"
+                       t("amendments", scope: "decidim.enhanced_textwork.application_helper.filter_type_values")
+                     else
+                       t("paragraphs", scope: "decidim.enhanced_textwork.application_helper.filter_type_values")
+                     end
+              tag += icon_link_to("circle-x", url_for(q: ransak_params_for_query_without(:is_emendation_true), per_page: per_page), t("decidim.admin.actions.cancel"),
+                                  class: "action-icon--remove")
+              tag.html_safe
+            end
+          end
+          if params[:q][:state_null]
+            html << tag.span(class: "label secondary") do
+              tag = "#{t("models.paragraph.fields.state", scope: "decidim.enhanced_textwork")}: "
+              tag += humanize_paragraph_state "not_answered"
+              tag += icon_link_to("circle-x", url_for(q: ransak_params_for_query_without(:state_null), per_page: per_page), t("decidim.admin.actions.cancel"),
+                                  class: "action-icon--remove")
+              tag.html_safe
+            end
+          end
+          if params[:q][:state_eq]
+            html << tag.span(class: "label secondary") do
+              tag = "#{t("models.paragraph.fields.state", scope: "decidim.enhanced_textwork")}: "
+              tag += humanize_paragraph_state params[:q][:state_eq]
+              tag += icon_link_to("circle-x", url_for(q: ransak_params_for_query_without(:state_eq), per_page: per_page), t("decidim.admin.actions.cancel"),
+                                  class: "action-icon--remove")
+              tag.html_safe
+            end
+          end
+          if params[:q][:category_id_eq]
+            html << tag.span(class: "label secondary") do
+              tag = "#{t("models.paragraph.fields.category", scope: "decidim.enhanced_textwork")}: "
+              tag += translated_attribute categories.find(params[:q][:category_id_eq]).name
+              tag += icon_link_to("circle-x", url_for(q: ransak_params_for_query_without(:category_id_eq), per_page: per_page), t("decidim.admin.actions.cancel"),
+                                  class: "action-icon--remove")
+              tag.html_safe
+            end
+          end
+          if params[:q][:scope_id_eq]
+            html << tag.span(class: "label secondary") do
+              tag = "#{t("models.paragraph.fields.scope", scope: "decidim.enhanced_textwork")}: "
+              tag += translated_attribute Decidim::Scope.where(decidim_organization_id: current_component.organization.id).find(params[:q][:scope_id_eq]).name
+              tag += icon_link_to("circle-x", url_for(q: ransak_params_for_query_without(:scope_id_eq), per_page: per_page), t("decidim.admin.actions.cancel"),
+                                  class: "action-icon--remove")
+              tag.html_safe
+            end
+          end
+          html.join(" ").html_safe
+        end
+
+        def icon_with_link_to_paragraph(paragraph)
+          icon, tooltip = if allowed_to?(:create, :paragraph_answer, paragraph: paragraph) && !paragraph.emendation?
+                            [
+                              "comment-square",
+                              t(:answer_paragraph, scope: "decidim.enhanced_textwork.actions")
+                            ]
+                          else
+                            [
+                              "info",
+                              t(:show, scope: "decidim.enhanced_textwork.actions")
+                            ]
+                          end
+          icon_link_to(icon, paragraph_path(paragraph), tooltip, class: "icon--small action-icon--show-paragraph")
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/enhanced_textwork/admin/paragraphs_picker_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # This class contains helpers needed to show the Paragraphs picker.
+      #
+      module EnhancedTextworkPickerHelper
+        def paragraphs_picker(form, field, url)
+          picker_options = {
+            id: sanitize_to_id(field),
+            class: "picker-multiple",
+            name: "#{form.object_name}[#{field.to_s.sub(/s$/, "_ids")}]",
+            multiple: true,
+            autosort: true
+          }
+
+          prompt_params = {
+            url: url,
+            text: t("paragraphs_picker.choose_paragraphs", scope: "decidim.enhanced_textwork")
+          }
+
+          form.data_picker(field, picker_options, prompt_params) do |item|
+            { url: url, text: present(item).id_and_title }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Custom helpers, scoped to the paragraphs engine.
+    #
+    module ApplicationHelper
+      include Decidim::Comments::CommentsHelper
+      include PaginateHelper
+      include ParagraphVotesHelper
+      include ::Decidim::EndorsableHelper
+      include ::Decidim::FollowableHelper
+      include Decidim::MapHelper
+      include Decidim::EnhancedTextwork::MapHelper
+      include CollaborativeDraftHelper
+      include ControlVersionHelper
+      include Decidim::RichTextEditorHelper
+      include Decidim::CheckBoxesTreeHelper
+
+      delegate :minimum_votes_per_user, to: :component_settings
+
+      # Public: The state of a paragraph in a way a human can understand.
+      #
+      # state - The String state of the paragraph.
+      #
+      # Returns a String.
+      def humanize_paragraph_state(state)
+        I18n.t(state, scope: "decidim.enhanced_textwork.answers", default: :not_answered)
+      end
+
+      # Public: The css class applied based on the paragraph state.
+      #
+      # paragraph - The paragraph to evaluate.
+      #
+      # Returns a String.
+      def paragraph_state_css_class(paragraph)
+        state = paragraph.state
+        state = paragraph.internal_state if paragraph.answered? && !paragraph.published_state?
+
+        case state
+        when "accepted"
+          "text-success"
+        when "rejected"
+          "text-alert"
+        when "evaluating"
+          "text-warning"
+        when "withdrawn"
+          "text-alert"
+        else
+          "text-info"
+        end
+      end
+
+      # Public: The state of a paragraph in a way a human can understand.
+      #
+      # state - The String state of the paragraph.
+      #
+      # Returns a String.
+      def humanize_collaborative_draft_state(state)
+        I18n.t("decidim.enhanced_textwork.collaborative_drafts.states.#{state}", default: :open)
+      end
+
+      # Public: The css class applied based on the collaborative draft state.
+      #
+      # state - The String state of the collaborative draft.
+      #
+      # Returns a String.
+      def collaborative_draft_state_badge_css_class(state)
+        case state
+        when "open"
+          "success"
+        when "withdrawn"
+          "alert"
+        when "published"
+          "secondary"
+        end
+      end
+
+      def paragraph_limit_enabled?
+        paragraph_limit.present?
+      end
+
+      def minimum_votes_per_user_enabled?
+        minimum_votes_per_user.positive?
+      end
+
+      def not_from_collaborative_draft(paragraph)
+        paragraph.linked_resources(:paragraphs, "created_from_collaborative_draft").empty?
+      end
+
+      def not_from_participatory_text(paragraph)
+        paragraph.participatory_text_level.nil?
+      end
+
+      # If the paragraph is official or the rich text editor is enabled on the
+      # frontend, the paragraph body is considered as safe content; that's unless
+      # the paragraph comes from a collaborative_draft or a participatory_text.
+      def safe_content?
+        rich_text_editor_in_public_views? && not_from_collaborative_draft(@paragraph) ||
+          (@paragraph.official? || @paragraph.official_meeting?) && not_from_participatory_text(@paragraph)
+      end
+
+      # If the content is safe, HTML tags are sanitized, otherwise, they are stripped.
+      def render_paragraph_body(paragraph)
+        body = present(paragraph).body(links: true, strip_tags: !safe_content?)
+        body = simple_format(body, {}, sanitize: false)
+
+        return body unless safe_content?
+
+        decidim_sanitize(body)
+      end
+
+      # Returns :text_area or :editor based on the organization' settings.
+      def text_editor_for_paragraph_body(form)
+        options = {
+          class: "js-hashtags",
+          hashtaggable: true,
+          value: form_presenter.body(extras: false).strip
+        }
+
+        text_editor_for(form, :body, options)
+      end
+
+      def paragraph_limit
+        return if component_settings.paragraph_limit.zero?
+
+        component_settings.paragraph_limit
+      end
+
+      def votes_given
+        @votes_given ||= ParagraphVote.where(
+          paragraph: Paragraph.where(component: current_component),
+          author: current_user
+        ).count
+      end
+
+      def votes_count_for(model, from_paragraphs_list)
+        render partial: "decidim/enhanced_textwork/paragraphs/participatory_texts/paragraph_votes_count.html", locals: { paragraph: model, from_paragraphs_list: from_paragraphs_list }
+      end
+
+      def vote_button_for(model, from_paragraphs_list)
+        render partial: "decidim/enhanced_textwork/paragraphs/participatory_texts/paragraph_vote_button.html", locals: { paragraph: model, from_paragraphs_list: from_paragraphs_list }
+      end
+
+      def form_has_address?
+        @form.address.present? || @form.has_address
+      end
+
+      def show_voting_rules?
+        return false unless votes_enabled?
+
+        return true if vote_limit_enabled?
+        return true if threshold_per_paragraph_enabled?
+        return true if paragraph_limit_enabled?
+        return true if can_accumulate_supports_beyond_threshold?
+        return true if minimum_votes_per_user_enabled?
+      end
+
+      def filter_type_values
+        [
+          ["all", t("decidim.enhanced_textwork.application_helper.filter_type_values.all")],
+          ["paragraphs", t("decidim.enhanced_textwork.application_helper.filter_type_values.paragraphs")],
+          ["amendments", t("decidim.enhanced_textwork.application_helper.filter_type_values.amendments")]
+        ]
+      end
+
+      # Options to filter Paragraphs by activity.
+      def activity_filter_values
+        base = [
+          ["all", t(".all")],
+          ["my_paragraphs", t(".my_paragraphs")]
+        ]
+        base += [["voted", t(".voted")]] if current_settings.votes_enabled?
+        base
+      end
+
+      def filter_origin_values
+        origin_values = []
+        origin_values << TreePoint.new("official", t("decidim.enhanced_textwork.application_helper.filter_origin_values.official")) if component_settings.official_paragraphs_enabled
+        origin_values << TreePoint.new("citizens", t("decidim.enhanced_textwork.application_helper.filter_origin_values.citizens"))
+        origin_values << TreePoint.new("user_group", t("decidim.enhanced_textwork.application_helper.filter_origin_values.user_groups")) if current_organization.user_groups_enabled?
+        origin_values << TreePoint.new("meeting", t("decidim.enhanced_textwork.application_helper.filter_origin_values.meetings"))
+
+        TreeNode.new(
+          TreePoint.new("", t("decidim.enhanced_textwork.application_helper.filter_origin_values.all")),
+          origin_values
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Custom helpers, scoped to the paragraphs engine.
+    #
+    module CollaborativeDraftCellsHelper
+      include Decidim::EnhancedTextwork::ApplicationHelper
+      include Decidim::EnhancedTextwork::Engine.routes.url_helpers
+      include Decidim::LayoutHelper
+      include Decidim::ApplicationHelper
+      include Decidim::TranslationsHelper
+      include Decidim::ResourceReferenceHelper
+      include Decidim::TranslatableAttributes
+      include Decidim::CardHelper
+
+      delegate :title, :state, to: :model
+
+      def has_actions?
+        false
+      end
+
+      def current_settings
+        model.component.current_settings
+      end
+
+      def component_settings
+        model.component.settings
+      end
+
+      def current_component
+        model.component
+      end
+
+      def from_context
+        @options[:from]
+      end
+
+      def badge_name
+        humanize_collaborative_draft_state state
+      end
+
+      def state_classes
+        [collaborative_draft_state_badge_css_class(state).to_s]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Custom helpers, scoped to the collaborative_draft resource.
+    #
+    module CollaborativeDraftHelper
+      def filter_collaborative_drafts_state_values
+        scope = "decidim.enhanced_textwork.collaborative_drafts.filters"
+        Decidim::CheckBoxesTreeHelper::TreeNode.new(
+          Decidim::CheckBoxesTreeHelper::TreePoint.new("", t("all", scope: scope)),
+          [
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("open", t("open", scope: scope)),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("withdrawn", t("withdrawn", scope: scope)),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("published", t("published", scope: scope))
+          ]
+        )
+      end
+
+      def accept_request_button_label
+        t("accept_request", scope: "decidim.enhanced_textwork.collaborative_drafts.requests.collaboration_requests")
+      end
+
+      def reject_request_button_label
+        t("reject_request", scope: "decidim.enhanced_textwork.collaborative_drafts.requests.collaboration_requests")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Custom helpers, scoped to the paragraphs engine.
+    module ControlVersionHelper
+      def item_name
+        versioned_resource.model_name.singular_route_key.to_sym
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # This helper include some methods for rendering paragraphs dynamic maps.
+    module MapHelper
+      include Decidim::ApplicationHelper
+      # Serialize a collection of geocoded paragraphs to be used by the dynamic map component
+      #
+      # geocoded_paragraphs - A collection of geocoded paragraphs
+      def paragraphs_data_for_map(geocoded_paragraphs)
+        geocoded_paragraphs.map do |paragraph|
+          paragraph_data_for_map(paragraph)
+        end
+      end
+
+      def paragraph_data_for_map(paragraph)
+        paragraph
+          .slice(:latitude, :longitude, :address)
+          .merge(
+            title: decidim_html_escape(present(paragraph).title),
+            body: html_truncate(decidim_sanitize(present(paragraph).body), length: 100),
+            icon: icon("paragraphs", width: 40, height: 70, remove_icon_class: true),
+            link: paragraph_path(paragraph)
+          )
+      end
+
+      def paragraph_preview_data_for_map(paragraph)
+        {
+          type: "drag-marker",
+          marker: paragraph.slice(
+            :latitude,
+            :longitude,
+            :address
+          ).merge(
+            icon: icon("paragraphs", width: 40, height: 70, remove_icon_class: true)
+          )
+        }
+      end
+
+      def has_position?(paragraph)
+        return if paragraph.address.blank?
+
+        paragraph.latitude.present? && paragraph.longitude.present?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Custom helpers, scoped to the paragraphs engine.
+    #
+    module ParagraphCellsHelper
+      include Decidim::EnhancedTextwork::ApplicationHelper
+      include Decidim::EnhancedTextwork::Engine.routes.url_helpers
+      include Decidim::LayoutHelper
+      include Decidim::ApplicationHelper
+      include Decidim::TranslationsHelper
+      include Decidim::ResourceReferenceHelper
+      include Decidim::TranslatableAttributes
+      include Decidim::CardHelper
+
+      delegate :title, :state, :published_state?, :withdrawn?, :amendable?, :emendation?, to: :model
+
+      def has_actions?
+        return context[:has_actions] if context[:has_actions].present?
+
+        paragraphs_controller? && index_action? && current_settings.votes_enabled? && !model.draft?
+      end
+
+      def has_footer?
+        return context[:has_footer] if context[:has_footer].present?
+
+        paragraphs_controller? && index_action? && current_settings.votes_enabled? && !model.draft?
+      end
+
+      def paragraphs_controller?
+        context[:controller].class.to_s == "Decidim::EnhancedTextwork::ParagraphsController"
+      end
+
+      def index_action?
+        context[:controller].action_name == "index"
+      end
+
+      def current_settings
+        model.component.current_settings
+      end
+
+      def component_settings
+        model.component.settings
+      end
+
+      def current_component
+        model.component
+      end
+
+      def from_context
+        @options[:from]
+      end
+
+      def badge_name
+        humanize_paragraph_state state
+      end
+
+      def state_classes
+        case state
+        when "accepted"
+          ["success"]
+        when "rejected"
+          ["alert"]
+        when "evaluating"
+          ["warning"]
+        when "withdrawn"
+          ["alert"]
+        else
+          ["muted"]
+        end
+      end
+    end
+  end
+end