decidim-proposals 0.19.1 → 0.23.0

data/app/forms/decidim/proposals/admin/proposal_form.rb

@@ -4,126 +4,15 @@ module Decidim
   module Proposals
     module Admin
       # A form object to be used when admin users want to create a proposal.
-      class ProposalForm < Decidim::Form
-        include Decidim::ApplicationHelper
-        mimic :proposal
-
-        attribute :title, String
-        attribute :body, String
-        attribute :address, String
-        attribute :latitude, Float
-        attribute :longitude, Float
-        attribute :category_id, Integer
-        attribute :scope_id, Integer
-        attribute :attachment, AttachmentForm
-        attribute :position, Integer
-        attribute :created_in_meeting, Boolean
-        attribute :meeting_id, Integer
-        attribute :suggested_hashtags, Array[String]
-        attribute :photos, Array[String]
-        attribute :add_photos, Array
-
-        validates :title, :body, presence: true
-        validates :title, length: { maximum: 150 }
-        validates :address, geocoding: true, if: -> { current_component.settings.geocoding_enabled? }
-        validates :category, presence: true, if: ->(form) { form.category_id.present? }
-        validates :scope, presence: true, if: ->(form) { form.scope_id.present? }
-        validates :meeting_as_author, presence: true, if: ->(form) { form.created_in_meeting? }
-
-        validate :scope_belongs_to_participatory_space_scope
-
-        validate :notify_missing_attachment_if_errored
-
-        delegate :categories, to: :current_component
-
-        def map_model(model)
-          return unless model.categorization
-
-          self.category_id = model.categorization.decidim_category_id
-          self.scope_id = model.decidim_scope_id
-
-          @suggested_hashtags = Decidim::ContentRenderers::HashtagRenderer.new(model.body).extra_hashtags.map(&:name).map(&:downcase)
-        end
-
-        alias component current_component
-
-        # Finds the Category from the category_id.
-        #
-        # Returns a Decidim::Category
-        def category
-          @category ||= categories.find_by(id: category_id)
-        end
-
-        # Finds the Scope from the given decidim_scope_id, uses participatory space scope if missing.
-        #
-        # Returns a Decidim::Scope
-        def scope
-          @scope ||= @scope_id ? current_participatory_space.scopes.find_by(id: @scope_id) : current_participatory_space.scope
-        end
-
-        # Scope identifier
-        #
-        # Returns the scope identifier related to the proposal
-        def scope_id
-          @scope_id || scope&.id
-        end
-
-        # Finds the Meetings of the current participatory space
-        def meetings
-          @meetings ||= Decidim.find_resource_manifest(:meetings).try(:resource_scope, current_component)
-                               &.order(title: :asc)
-        end
-
-        # Return the meeting as author
-        def meeting_as_author
-          @meeting_as_author ||= meetings.find_by(id: meeting_id)
+      class ProposalForm < Decidim::Proposals::Admin::ProposalBaseForm
+        translatable_attribute :title, String do |field, _locale|
+          validates field, length: { in: 15..150 }, if: proc { |resource| resource.send(field).present? }
         end
+        translatable_attribute :body, String
 
-        def author
-          return current_organization unless created_in_meeting?
+        validates :title, :body, translatable_presence: true
 
-          meeting_as_author
-        end
-
-        def extra_hashtags
-          @extra_hashtags ||= (component_automatic_hashtags + suggested_hashtags).uniq
-        end
-
-        def suggested_hashtags
-          downcased_suggested_hashtags = Array(@suggested_hashtags&.map(&:downcase)).to_set
-          component_suggested_hashtags.select { |hashtag| downcased_suggested_hashtags.member?(hashtag.downcase) }
-        end
-
-        def suggested_hashtag_checked?(hashtag)
-          suggested_hashtags.member?(hashtag)
-        end
-
-        def component_automatic_hashtags
-          @component_automatic_hashtags ||= ordered_hashtag_list(current_component.current_settings.automatic_hashtags)
-        end
-
-        def component_suggested_hashtags
-          @component_suggested_hashtags ||= ordered_hashtag_list(current_component.current_settings.suggested_hashtags)
-        end
-
-        private
-
-        def scope_belongs_to_participatory_space_scope
-          errors.add(:scope_id, :invalid) if current_participatory_space.out_of_scope?(scope)
-        end
-
-        # This method will add an error to the `attachment` field only if there's
-        # any error in any other field. This is needed because when the form has
-        # an error, the attachment is lost, so we need a way to inform the user of
-        # this problem.
-        def notify_missing_attachment_if_errored
-          errors.add(:attachment, :needs_to_be_reattached) if errors.any? && attachment.present?
-          errors.add(:add_photos, :needs_to_be_reattached) if errors.any? && add_photos.present?
-        end
-
-        def ordered_hashtag_list(string)
-          string.to_s.split.reject(&:blank?).uniq.sort_by(&:parameterize)
-        end
+        validate :notify_missing_attachment_if_errored
       end
     end
   end

data/app/forms/decidim/proposals/admin/valuation_assignment_form.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      class ValuationAssignmentForm < Decidim::Form
+        mimic :valuator_role
+
+        attribute :id, Integer
+        attribute :proposal_ids, Array
+
+        validates :valuator_role, :proposals, :current_component, presence: true
+        validate :same_participatory_space
+
+        def proposals
+          @proposals ||= Decidim::Proposals::Proposal.where(component: current_component, id: proposal_ids).uniq
+        end
+
+        def valuator_role
+          @valuator_role ||= current_component.participatory_space.user_roles(:valuator).find_by(id: id)
+        end
+
+        def valuator_user
+          return unless valuator_role
+
+          @valuator_user ||= valuator_role.user
+        end
+
+        def same_participatory_space
+          return if !valuator_role || !current_component
+
+          errors.add(:id, :invalid) if current_component.participatory_space != valuator_role.participatory_space
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/proposals/proposal_form.rb

@@ -4,6 +4,8 @@ module Decidim
   module Proposals
     # A form object to be used when public users want to create a proposal.
     class ProposalForm < Decidim::Proposals::ProposalWizardCreateStepForm
+      include Decidim::TranslatableAttributes
+
       mimic :proposal
 
       attribute :address, String
@@ -14,14 +16,16 @@ module Decidim
       attribute :has_address, Boolean
       attribute :attachment, AttachmentForm
       attribute :suggested_hashtags, Array[String]
+      attribute :photos, Array[String]
+      attribute :add_photos, Array
+      attribute :documents, Array[String]
+      attribute :add_documents, Array
 
-      validates :address, geocoding: true, if: ->(form) { Decidim.geocoder.present? && form.has_address? }
+      validates :address, geocoding: true, if: ->(form) { form.has_address? && !form.geocoded? }
       validates :address, presence: true, if: ->(form) { form.has_address? }
       validates :category, presence: true, if: ->(form) { form.category_id.present? }
       validates :scope, presence: true, if: ->(form) { form.scope_id.present? }
-
-      validate :scope_belongs_to_participatory_space_scope
-
+      validates :scope_id, scope_belongs_to_component: true, if: ->(form) { form.scope_id.present? }
       validate :notify_missing_attachment_if_errored
 
       delegate :categories, to: :current_component
@@ -29,7 +33,12 @@ module Decidim
       def map_model(model)
         super
 
-        @suggested_hashtags = Decidim::ContentRenderers::HashtagRenderer.new(model.body).extra_hashtags.map(&:name).map(&:downcase)
+        body = translated_attribute(model.body)
+        @suggested_hashtags = Decidim::ContentRenderers::HashtagRenderer.new(body).extra_hashtags.map(&:name).map(&:downcase)
+
+        # The scope attribute is with different key (decidim_scope_id), so it
+        # has to be manually mapped.
+        self.scope_id = model.scope.id if model.scope
       end
 
       # Finds the Category from the category_id.
@@ -39,11 +48,11 @@ module Decidim
         @category ||= categories.find_by(id: category_id)
       end
 
-      # Finds the Scope from the given decidim_scope_id, uses participatory space scope if missing.
+      # Finds the Scope from the given scope_id, uses participatory space scope if missing.
       #
       # Returns a Decidim::Scope
       def scope
-        @scope ||= @scope_id ? current_participatory_space.scopes.find_by(id: @scope_id) : current_participatory_space.scope
+        @scope ||= @scope_id ? current_component.scopes.find_by(id: @scope_id) : current_component.scope
       end
 
       # Scope identifier
@@ -53,8 +62,16 @@ module Decidim
         @scope_id || scope&.id
       end
 
+      def geocoding_enabled?
+        Decidim::Map.available?(:geocoding) && current_component.settings.geocoding_enabled?
+      end
+
       def has_address?
-        current_component.settings.geocoding_enabled? && has_address
+        geocoding_enabled? && has_address
+      end
+
+      def geocoded?
+        latitude.present? && longitude.present?
       end
 
       def extra_hashtags
@@ -80,10 +97,6 @@ module Decidim
 
       private
 
-      def scope_belongs_to_participatory_space_scope
-        errors.add(:scope_id, :invalid) if current_participatory_space.out_of_scope?(scope)
-      end
-
       # This method will add an error to the `attachment` field only if there's
       # any error in any other field. This is needed because when the form has
       # an error, the attachment is lost, so we need a way to inform the user of

data/app/forms/decidim/proposals/proposal_wizard_create_step_form.rb

@@ -8,12 +8,18 @@ module Decidim
 
       attribute :title, String
       attribute :body, String
+      attribute :body_template, String
       attribute :user_group_id, Integer
 
       validates :title, :body, presence: true, etiquette: true
-      validates :title, length: { maximum: 150 }
+      validates :title, length: { in: 15..150 }
+      validates :body, proposal_length: {
+        minimum: 15,
+        maximum: ->(record) { record.component.settings.proposal_length }
+      }
 
       validate :proposal_length
+      validate :body_is_not_bare_template
 
       alias component current_component
 
@@ -32,6 +38,12 @@ module Decidim
         length = current_component.settings.proposal_length
         errors.add(:body, :too_long, count: length) if body.length > length
       end
+
+      def body_is_not_bare_template
+        return if body_template.blank?
+
+        errors.add(:body, :cant_be_equal_to_template) if body.presence == body_template.presence
+      end
     end
   end
 end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      module FilterableHelper
+        def extra_dropdown_submenu_options_items(filter, i18n_scope)
+          options = case filter
+                    when :state_eq
+                      content_tag(:li, filter_link_value(:state_null, true, i18n_scope))
+                    end
+          [options].compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      module ProposalBulkActionsHelper
+        # 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/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

@@ -7,6 +7,8 @@ module Decidim
       # in order to use them in select forms for Proposals.
       #
       module ProposalsHelper
+        include Decidim::Admin::ResourceScopeHelper
+
         # Public: A formatted collection of Meetings to be used
         # in forms.
         def meetings_as_authors_selected
@@ -14,6 +16,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