decidim-proposals 0.19.0 → 0.22.0

data/app/helpers/decidim/proposals/admin/proposal_rankings_helper.rb

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

data/app/helpers/decidim/proposals/admin/proposals_helper.rb

@@ -14,6 +14,128 @@ module Decidim
 
           @meetings_as_authors_selected ||= @proposal.authors.pluck(:id)
         end
+
+        def coauthor_presenters_for(proposal)
+          proposal.authors.map do |identity|
+            if identity.is_a?(Decidim::Organization)
+              Decidim::Proposals::OfficialAuthorPresenter.new
+            else
+              present(identity)
+            end
+          end
+        end
+
+        def endorsers_presenters_for(proposal)
+          proposal.endorsements.for_listing.map { |identity| present(identity.normalized_author) }
+        end
+
+        def proposal_complete_state(proposal)
+          state = humanize_proposal_state(proposal.state)
+          state += " (#{humanize_proposal_state(proposal.internal_state)})" if proposal.answered? && !proposal.published_state?
+          state.html_safe
+        end
+
+        def proposals_admin_filter_tree
+          {
+            t("proposals.filters.type", scope: "decidim.proposals") => {
+              link_to(t("proposals", scope: "decidim.proposals.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.proposals.application_helper.filter_type_values"), q: ransak_params_for_query(is_emendation_true: "1"),
+                                                                                                         per_page: per_page) => nil
+            },
+            t("models.proposal.fields.state", scope: "decidim.proposals") =>
+              Decidim::Proposals::Proposal::POSSIBLE_STATES.each_with_object({}) do |state, hash|
+                if state == "not_answered"
+                  hash[link_to((humanize_proposal_state state), q: ransak_params_for_query(state_null: 1), per_page: per_page)] = nil
+                else
+                  hash[link_to((humanize_proposal_state state), q: ransak_params_for_query(state_eq: state), per_page: per_page)] = nil
+                end
+              end,
+            t("models.proposal.fields.category", scope: "decidim.proposals") => admin_filter_categories_tree(categories.first_class),
+            t("proposals.filters.scope", scope: "decidim.proposals") => admin_filter_scopes_tree(current_component.organization.id)
+          }
+        end
+
+        def proposals_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 proposals_admin_filter_applied_filters
+          html = []
+          if params[:q][:is_emendation_true].present?
+            html << content_tag(:span, class: "label secondary") do
+              tag = "#{t("filters.type", scope: "decidim.proposals.proposals")}: "
+              tag += if params[:q][:is_emendation_true].to_s == "1"
+                       t("amendments", scope: "decidim.proposals.application_helper.filter_type_values")
+                     else
+                       t("proposals", scope: "decidim.proposals.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 << content_tag(:span, class: "label secondary") do
+              tag = "#{t("models.proposal.fields.state", scope: "decidim.proposals")}: "
+              tag += humanize_proposal_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 << content_tag(:span, class: "label secondary") do
+              tag = "#{t("models.proposal.fields.state", scope: "decidim.proposals")}: "
+              tag += humanize_proposal_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 << content_tag(:span, class: "label secondary") do
+              tag = "#{t("models.proposal.fields.category", scope: "decidim.proposals")}: "
+              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 << content_tag(:span, class: "label secondary") do
+              tag = "#{t("models.proposal.fields.scope", scope: "decidim.proposals")}: "
+              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_proposal(proposal)
+          icon, tooltip = if allowed_to?(:create, :proposal_answer, proposal: proposal) && !proposal.emendation?
+                            [
+                              "comment-square",
+                              t(:answer_proposal, scope: "decidim.proposals.actions")
+                            ]
+                          else
+                            [
+                              "info",
+                              t(:show, scope: "decidim.proposals.actions")
+                            ]
+                          end
+          icon_link_to(icon, proposal_path(proposal), tooltip, class: "icon--small action-icon--show-proposal")
+        end
       end
     end
   end

data/app/helpers/decidim/proposals/admin/proposals_picker_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      # This class contains helpers needed to show the Proposals picker.
+      #
+      module ProposalsPickerHelper
+        def proposals_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("proposals_picker.choose_proposals", scope: "decidim.proposals")
+          }
+
+          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/proposals/application_helper.rb

@@ -8,11 +8,14 @@ module Decidim
       include Decidim::Comments::CommentsHelper
       include PaginateHelper
       include ProposalVotesHelper
-      include ProposalEndorsementsHelper
+      include ::Decidim::EndorsableHelper
+      include ::Decidim::FollowableHelper
       include Decidim::MapHelper
       include Decidim::Proposals::MapHelper
       include CollaborativeDraftHelper
       include ControlVersionHelper
+      include Decidim::RichTextEditorHelper
+      include Decidim::CheckBoxesTreeHelper
 
       delegate :minimum_votes_per_user, to: :component_settings
 
@@ -78,6 +81,43 @@ module Decidim
         minimum_votes_per_user.positive?
       end
 
+      def not_from_collaborative_draft(proposal)
+        proposal.linked_resources(:proposals, "created_from_collaborative_draft").empty?
+      end
+
+      def not_from_participatory_text(proposal)
+        proposal.participatory_text_level.nil?
+      end
+
+      # If the proposal is official or the rich text editor is enabled on the
+      # frontend, the proposal body is considered as safe content; that's unless
+      # the proposal comes from a collaborative_draft or a participatory_text.
+      def safe_content?
+        rich_text_editor_in_public_views? && not_from_collaborative_draft(@proposal) ||
+          (@proposal.official? || @proposal.official_meeting?) && not_from_participatory_text(@proposal)
+      end
+
+      # If the content is safe, HTML tags are sanitized, otherwise, they are stripped.
+      def render_proposal_body(proposal)
+        body = present(proposal).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_proposal_body(form)
+        options = {
+          class: "js-hashtags",
+          hashtaggable: true,
+          value: form_presenter.body(extras: false).strip
+        }
+
+        text_editor_for(form, :body, options)
+      end
+
       def proposal_limit
         return if component_settings.proposal_limit.zero?
 
@@ -91,10 +131,6 @@ module Decidim
         ).count
       end
 
-      def follow_button_for(model, large = nil)
-        render partial: "decidim/shared/follow_button.html", locals: { followable: model, large: large }
-      end
-
       def votes_count_for(model, from_proposals_list)
         render partial: "decidim/proposals/proposals/participatory_texts/proposal_votes_count.html", locals: { proposal: model, from_proposals_list: from_proposals_list }
       end
@@ -125,31 +161,6 @@ module Decidim
         return true if minimum_votes_per_user_enabled?
       end
 
-      def filter_origin_values
-        base = if component_settings.official_proposals_enabled
-                 [
-                   ["all", t("decidim.proposals.application_helper.filter_origin_values.all")],
-                   ["official", t("decidim.proposals.application_helper.filter_origin_values.official")]
-                 ]
-               else
-                 [["all", t("decidim.proposals.application_helper.filter_origin_values.all")]]
-               end
-
-        base += [["citizens", t("decidim.proposals.application_helper.filter_origin_values.citizens")]]
-        base += [["user_group", t("decidim.proposals.application_helper.filter_origin_values.user_groups")]] if current_organization.user_groups_enabled?
-        base + [["meeting", t("decidim.proposals.application_helper.filter_origin_values.meetings")]]
-      end
-
-      def filter_state_values
-        [
-          ["except_rejected", t("decidim.proposals.application_helper.filter_state_values.except_rejected")],
-          ["accepted", t("decidim.proposals.application_helper.filter_state_values.accepted")],
-          ["evaluating", t("decidim.proposals.application_helper.filter_state_values.evaluating")],
-          ["rejected", t("decidim.proposals.application_helper.filter_state_values.rejected")],
-          ["all", t("decidim.proposals.application_helper.filter_state_values.all")]
-        ]
-      end
-
       def filter_type_values
         [
           ["all", t("decidim.proposals.application_helper.filter_type_values.all")],
@@ -157,6 +168,16 @@ module Decidim
           ["amendments", t("decidim.proposals.application_helper.filter_type_values.amendments")]
         ]
       end
+
+      # Options to filter Proposals by activity.
+      def activity_filter_values
+        base = [
+          ["all", t(".all")],
+          ["my_proposals", t(".my_proposals")]
+        ]
+        base += [["voted", t(".voted")]] if current_settings.votes_enabled?
+        base
+      end
     end
   end
 end

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

@@ -5,16 +5,16 @@ module Decidim
     # Custom helpers, scoped to the collaborative_draft resource.
     #
     module CollaborativeDraftHelper
-      def collaborative_drafts_states_collection
+      def filter_collaborative_drafts_state_values
         scope = "decidim.proposals.collaborative_drafts.filters"
-        @collaborative_drafts_states_collection ||= begin
-          collection = []
-          collection << ["all", t("all", scope: scope)]
-          collection << ["open", t("open", scope: scope)]
-          collection << ["withdrawn", t("withdrawn", scope: scope)]
-          collection << ["published", t("published", scope: scope)]
-          collection
-        end
+        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

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

@@ -5,43 +5,7 @@ module Decidim
     # Custom helpers, scoped to the proposals engine.
     module ControlVersionHelper
       def item_name
-        item.model_name.singular_route_key.to_sym
-      end
-
-      def back_to_resource_path_text
-        case item_name
-        when :proposal
-          t("back_to_proposal", scope: "decidim.proposals.versions.stats")
-        when :collaborative_draft
-          t("back_to_collaborative_draft", scope: "decidim.proposals.versions.stats")
-        end
-      end
-
-      def back_to_resource_path
-        case item_name
-        when :proposal
-          proposal_path(item)
-        when :collaborative_draft
-          collaborative_draft_path(item)
-        end
-      end
-
-      def resource_version_path(index)
-        case item_name
-        when :proposal
-          proposal_version_path(item, index + 1)
-        when :collaborative_draft
-          collaborative_draft_version_path(item, index + 1)
-        end
-      end
-
-      def resource_all_versions_path
-        case item_name
-        when :proposal
-          proposal_versions_path(item)
-        when :collaborative_draft
-          collaborative_draft_versions_path(item)
-        end
+        versioned_resource.model_name.singular_route_key.to_sym
       end
     end
   end

data/app/helpers/decidim/proposals/proposal_cells_helper.rb

@@ -14,7 +14,7 @@ module Decidim
       include Decidim::TranslatableAttributes
       include Decidim::CardHelper
 
-      delegate :title, :state, :answered?, :withdrawn?, :amendable?, :emendation?, to: :model
+      delegate :title, :state, :published_state?, :withdrawn?, :amendable?, :emendation?, to: :model
 
       def has_actions?
         return context[:has_actions] if context[:has_actions].present?

data/app/helpers/decidim/proposals/proposal_endorsements_helper.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  module Proposals
-    # Simple helper to handle markup variations for proposal endorsements partials
-    module ProposalEndorsementsHelper
-      # Returns the css classes used for proposal endorsement button in both proposals list and show pages
-      #
-      # from_proposals_list - A boolean to indicate if the template is rendered from the proposals list page
-      #
-      # Returns a string with the value of the css classes.
-      def endorsement_button_classes(from_proposals_list)
-        return "small" if from_proposals_list
-
-        "small compact light button--sc expanded"
-      end
-
-      # Public: Checks if endorsement are enabled in this step.
-      #
-      # Returns true if enabled, false otherwise.
-      def endorsements_enabled?
-        current_settings.endorsements_enabled
-      end
-
-      # Public: Checks if endorsements are blocked in this step.
-      #
-      # Returns true if blocked, false otherwise.
-      def endorsements_blocked?
-        current_settings.endorsements_blocked
-      end
-
-      # Public: Checks if the current user is allowed to endorse in this step.
-      #
-      # Returns true if the current user can endorse, false otherwise.
-      def current_user_can_endorse?
-        current_user && endorsements_enabled? && !endorsements_blocked?
-      end
-
-      # Public: Checks if the card for endorsements should be rendered.
-      #
-      # Returns true if the endorsements card should be rendered, false otherwise.
-      def show_endorsements_card?
-        endorsements_enabled?
-      end
-
-      def endorsement_identity_presenter(endorsement)
-        if endorsement.user_group
-          Decidim::UserGroupPresenter.new(endorsement.user_group)
-        else
-          Decidim::UserPresenter.new(endorsement.author)
-        end
-      end
-
-      # Public: Renders a button to endorse the given proposal.
-      # To override the translation for both buttons: endorse and unendorse (use to be the name of the user/user_group).
-      #
-      # @params (mandatory): proposal, from_proposals_list
-      # @params (optional) : user_group, btn_label
-      def endorsement_button(proposal, from_proposals_list, btn_label = nil, user_group = nil)
-        current_endorsement_url = proposal_proposal_endorsement_path(
-          proposal_id: proposal,
-          from_proposals_list: from_proposals_list,
-          user_group_id: user_group&.id
-        )
-        endorse_label = btn_label || t("decidim.proposals.proposal_endorsements_helper.endorsement_button.endorse")
-        unendorse_label = btn_label || t("decidim.proposals.proposal_endorsements_helper.endorsement_button.already_endorsed")
-
-        render partial: "decidim/proposals/proposals/endorsement_button", locals: { proposal: proposal,
-                                                                                    from_proposals_list: from_proposals_list, user_group: user_group,
-                                                                                    current_endorsement_url: current_endorsement_url,
-                                                                                    endorse_label: endorse_label, unendorse_label: unendorse_label }
-      end
-
-      #
-      # Public: Checks if the given Proposal has been endorsed by all identities of the user.
-      #
-      # @param proposal: The Proposal from which endorsements will be checked against.
-      # @param user:     The user whose identities and endorsements  will be checked against.
-      #
-      def fully_endorsed?(proposal, user)
-        return false unless user
-
-        user_group_endorsements = Decidim::UserGroups::ManageableUserGroups.for(user).verified.all? { |user_group| proposal.endorsed_by?(user, user_group) }
-
-        user_group_endorsements && proposal.endorsed_by?(user)
-      end
-
-      # Public: Renders an identity for endorsement.
-      #
-      # @params (mandatory): proposal, from_proposals_list
-      # @params (mandatory): user, the user that is endorsing at the end.
-      # @params (optional) : user_group, the user_group on behalf of which the endorsement is being done
-      def render_endorsement_identity(proposal, user, user_group = nil)
-        current_endorsement_url = proposal_proposal_endorsement_path(
-          proposal_id: proposal,
-          from_proposals_list: false,
-          user_group_id: user_group&.id,
-          authenticity_token: form_authenticity_token
-        )
-        presenter = if user_group
-                      Decidim::UserGroupPresenter.new(user_group)
-                    else
-                      Decidim::UserPresenter.new(user)
-                    end
-        selected = proposal.endorsed_by?(user, user_group)
-        http_method = selected ? :delete : :post
-        render partial: "decidim/proposals/proposal_endorsements/identity", locals:
-        { identity: presenter, selected: selected, current_endorsement_url: current_endorsement_url, http_method: http_method }
-      end
-
-      # Renders the counter of endorsements that appears in card at show Propoal.
-      def render_endorsements_count_card_part(proposal, fully_endorsed, html_class = nil)
-        content = icon("bullhorn", class: "icon--small", aria_label: "Endorsements", role: "img")
-        content += proposal.proposal_endorsements_count.to_s
-        html_class = "button small compact light button--sc button--shadow" if html_class.blank?
-        tag_params = { id: "proposal-#{proposal.id}-endorsements-count", class: "#{html_class} #{fully_endorsed ? "success" : "secondary"}" }
-        if proposal.proposal_endorsements_count.positive?
-          link_to "#list-of-endorsements", tag_params do
-            content
-          end
-        else
-          content_tag("div", tag_params) do
-            content
-          end
-        end
-      end
-
-      def render_endorsements_button_card_part(proposal, fully_endorsed, html_class = nil)
-        endorse_translated = t("decidim.proposals.proposal_endorsements_helper.render_endorsements_button_card_part.endorse")
-        html_class = "card__button button" if html_class.blank?
-        if current_settings.endorsements_blocked? || !current_component.participatory_space.can_participate?(current_user)
-          content_tag :span, endorse_translated, class: "#{html_class} #{endorsement_button_classes(false)} disabled", disabled: true, title: endorse_translated
-        elsif current_user && allowed_to?(:endorse, :proposal, proposal: proposal)
-          render partial: "endorsement_identities_cabin", locals: { proposal: proposal, fully_endorsed: fully_endorsed }
-        elsif current_user
-          button_to(endorse_translated, proposal_path(proposal),
-                    data: { open: "authorizationModal", "open-url": modal_path(:endorse, proposal) },
-                    class: "#{html_class} #{endorsement_button_classes(false)} secondary")
-        else
-          action_authorized_button_to :endorse, endorse_translated, "", resource: proposal, class: "#{html_class} #{endorsement_button_classes(false)} secondary"
-        end
-      end
-    end
-  end
-end