decidim-proposals 0.20.1 → 0.21.0

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

@@ -13,6 +13,8 @@ module Decidim
       include Decidim::Proposals::MapHelper
       include CollaborativeDraftHelper
       include ControlVersionHelper
+      include Decidim::RichTextEditorHelper
+      include Decidim::CheckBoxesTreeHelper
 
       delegate :minimum_votes_per_user, to: :component_settings
 
@@ -78,6 +80,40 @@ 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?)
+
+        safe_content? ? decidim_sanitize(body) : simple_format(body, {}, sanitize: false)
+      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?
 
@@ -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")],

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/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/proposals_helper.rb

@@ -37,6 +37,24 @@ module Decidim
 
         t(i18n_key, scope: "decidim.proposals.proposals.show")
       end
+
+      def filter_proposals_state_values
+        Decidim::CheckBoxesTreeHelper::TreeNode.new(
+          Decidim::CheckBoxesTreeHelper::TreePoint.new("", t("decidim.proposals.application_helper.filter_state_values.all")),
+          [
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("accepted", t("decidim.proposals.application_helper.filter_state_values.accepted")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("evaluating", t("decidim.proposals.application_helper.filter_state_values.evaluating")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("not_answered", t("decidim.proposals.application_helper.filter_state_values.not_answered")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("rejected", t("decidim.proposals.application_helper.filter_state_values.rejected"))
+          ]
+        )
+      end
+
+      def proposal_has_costs?
+        @proposal.cost.present? &&
+          translated_attribute(@proposal.cost_report).present? &&
+          translated_attribute(@proposal.execution_period).present?
+      end
     end
   end
 end

data/app/models/decidim/proposals/proposal.rb

@@ -24,6 +24,9 @@ module Decidim
       include Decidim::Amendable
       include Decidim::NewsletterParticipant
       include Decidim::Randomable
+      include Decidim::Proposals::Valuatable
+
+      POSSIBLE_STATES = %w(not_answered evaluating accepted rejected withdrawn).freeze
 
       fingerprint fields: [:title, :body]
 
@@ -49,15 +52,56 @@ module Decidim
 
       geocoded_by :address, http_headers: ->(proposal) { { "Referer" => proposal.component.organization.host } }
 
-      scope :accepted, -> { where(state: "accepted") }
-      scope :rejected, -> { where(state: "rejected") }
-      scope :evaluating, -> { where(state: "evaluating") }
+      scope :answered, -> { where.not(answered_at: nil) }
+      scope :not_answered, -> { where(answered_at: nil) }
+
+      scope :state_not_published, -> { where(state_published_at: nil) }
+      scope :state_published, -> { where.not(state_published_at: nil).where.not(state: nil) }
+
+      scope :accepted, -> { state_published.where(state: "accepted") }
+      scope :rejected, -> { state_published.where(state: "rejected") }
+      scope :evaluating, -> { state_published.where(state: "evaluating") }
       scope :withdrawn, -> { where(state: "withdrawn") }
-      scope :except_rejected, -> { where.not(state: "rejected").or(where(state: nil)) }
+      scope :except_rejected, -> { where.not(state: "rejected").or(state_not_published) }
       scope :except_withdrawn, -> { where.not(state: "withdrawn").or(where(state: nil)) }
       scope :drafts, -> { where(published_at: nil) }
       scope :except_drafts, -> { where.not(published_at: nil) }
       scope :published, -> { where.not(published_at: nil) }
+      scope :official_origin, lambda {
+        where.not(coauthorships_count: 0)
+             .joins(:coauthorships)
+             .where(decidim_coauthorships: { decidim_author_type: "Decidim::Organization" })
+      }
+      scope :citizens_origin, lambda {
+        where.not(coauthorships_count: 0)
+             .joins(:coauthorships)
+             .where.not(decidim_coauthorships: { decidim_author_type: "Decidim::Organization" })
+      }
+      scope :user_group_origin, lambda {
+        where.not(coauthorships_count: 0)
+             .joins(:coauthorships)
+             .where(decidim_coauthorships: { decidim_author_type: "Decidim::UserBaseEntity" })
+             .where.not(decidim_coauthorships: { decidim_user_group_id: nil })
+      }
+      scope :meeting_origin, lambda {
+        where.not(coauthorships_count: 0)
+             .joins(:coauthorships)
+             .where(decidim_coauthorships: { decidim_author_type: "Decidim::Meetings::Meeting" })
+      }
+      scope :sort_by_valuation_assignments_count_asc, lambda {
+        order(sort_by_valuation_assignments_count_nulls_last_query + "ASC NULLS FIRST")
+      }
+
+      scope :sort_by_valuation_assignments_count_desc, lambda {
+        order(sort_by_valuation_assignments_count_nulls_last_query + "DESC NULLS LAST")
+      }
+
+      def self.with_valuation_assigned_to(user, space)
+        valuator_roles = space.user_roles(:valuator).where(user: user)
+
+        includes(:valuation_assignments)
+          .where(decidim_proposals_valuation_assignments: { valuator_role_id: valuator_roles })
+      end
 
       acts_as_list scope: :decidim_component_id
 
@@ -140,39 +184,68 @@ module Decidim
         published_at.present?
       end
 
+      # Public: Returns the published state of the proposal.
+      #
+      # Returns Boolean.
+      def state
+        return amendment.state if emendation?
+        return nil unless published_state? || withdrawn?
+
+        super
+      end
+
+      # This is only used to define the setter, as the getter will be overriden below.
+      alias_attribute :internal_state, :state
+
+      # Public: Returns the internal state of the proposal.
+      #
+      # Returns Boolean.
+      def internal_state
+        return amendment.state if emendation?
+
+        self[:state]
+      end
+
+      # Public: Checks if the organization has published the state for the proposal.
+      #
+      # Returns Boolean.
+      def published_state?
+        emendation? || state_published_at.present?
+      end
+
       # Public: Checks if the organization has given an answer for the proposal.
       #
       # Returns Boolean.
       def answered?
-        answered_at.present? && state.present?
+        answered_at.present?
+      end
+
+      # Public: Checks if the author has withdrawn the proposal.
+      #
+      # Returns Boolean.
+      def withdrawn?
+        internal_state == "withdrawn"
       end
 
       # Public: Checks if the organization has accepted a proposal.
       #
       # Returns Boolean.
       def accepted?
-        answered? && state == "accepted"
+        state == "accepted"
       end
 
       # Public: Checks if the organization has rejected a proposal.
       #
       # Returns Boolean.
       def rejected?
-        answered? && state == "rejected"
+        state == "rejected"
       end
 
       # Public: Checks if the organization has marked the proposal as evaluating it.
       #
       # Returns Boolean.
       def evaluating?
-        answered? && state == "evaluating"
-      end
-
-      # Public: Checks if the author has withdrawn the proposal.
-      #
-      # Returns Boolean.
-      def withdrawn?
-        state == "withdrawn"
+        state == "evaluating"
       end
 
       # Public: Overrides the `reported_content_url` Reportable concern method.
@@ -222,7 +295,7 @@ module Decidim
       def editable_by?(user)
         return true if draft?
 
-        !answered? && within_edit_time_limit? && !copied_from_other_component? && created_by?(user)
+        !published_state? && within_edit_time_limit? && !copied_from_other_component? && created_by?(user)
       end
 
       # Checks whether the user can withdraw the given proposal.
@@ -250,6 +323,69 @@ module Decidim
         Arel.sql(query)
       end
 
+      # Defines the base query so that ransack can actually sort by this value
+      def self.sort_by_valuation_assignments_count_nulls_last_query
+        <<-SQL
+        (
+          SELECT COUNT(decidim_proposals_valuation_assignments.id)
+          FROM decidim_proposals_valuation_assignments
+          WHERE decidim_proposals_valuation_assignments.decidim_proposal_id = decidim_proposals_proposals.id
+          GROUP BY decidim_proposals_valuation_assignments.decidim_proposal_id
+        )
+        SQL
+      end
+
+      # method to filter by assigned valuator role ID
+      def self.valuator_role_ids_has(value)
+        query = <<-SQL
+        :value = any(
+          (SELECT decidim_proposals_valuation_assignments.valuator_role_id
+          FROM decidim_proposals_valuation_assignments
+          WHERE decidim_proposals_valuation_assignments.decidim_proposal_id = decidim_proposals_proposals.id
+          )
+        )
+        SQL
+        where(query, value: value)
+      end
+
+      def self.ransackable_scopes(_auth = nil)
+        [:valuator_role_ids_has]
+      end
+
+      ransacker :state_published do
+        Arel.sql("CASE
+          WHEN EXISTS (
+            SELECT 1 FROM decidim_amendments
+            WHERE decidim_amendments.decidim_emendation_type = 'Decidim::Proposals::Proposal'
+            AND decidim_amendments.decidim_emendation_id = decidim_proposals_proposals.id
+          ) THEN 0
+          WHEN state_published_at IS NULL AND answered_at IS NOT NULL THEN 2
+          WHEN state_published_at IS NOT NULL THEN 1
+          ELSE 0 END
+        ")
+      end
+
+      ransacker :state do
+        Arel.sql("CASE WHEN state = 'withdrawn' THEN 'withdrawn' WHEN state_published_at IS NULL THEN NULL ELSE state END")
+      end
+
+      ransacker :id_string do
+        Arel.sql(%{cast("decidim_proposals_proposals"."id" as text)})
+      end
+
+      ransacker :is_emendation do |_parent|
+        query = <<-SQL
+        (
+          SELECT EXISTS (
+            SELECT 1 FROM decidim_amendments
+            WHERE decidim_amendments.decidim_emendation_type = 'Decidim::Proposals::Proposal'
+            AND decidim_amendments.decidim_emendation_id = decidim_proposals_proposals.id
+          )
+        )
+        SQL
+        Arel.sql(query)
+      end
+
       def self.export_serializer
         Decidim::Proposals::ProposalSerializer
       end
@@ -271,6 +407,17 @@ module Decidim
         Time.current < limit
       end
 
+      def process_amendment_state_change!
+        return unless %w(accepted rejected evaluating withdrawn).member?(amendment.state)
+
+        PaperTrail.request(enabled: false) do
+          update!(
+            state: amendment.state,
+            state_published_at: Time.current
+          )
+        end
+      end
+
       private
 
       def copied_from_other_component?

data/app/models/decidim/proposals/valuation_assignment.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    # A valuation assignment links a proposal and a Valuator user role.
+    # Valuators will be users in charge of defining the monetary cost of a
+    # proposal.
+    class ValuationAssignment < ApplicationRecord
+      include Decidim::Traceable
+      include Decidim::Loggable
+
+      belongs_to :proposal, foreign_key: "decidim_proposal_id", class_name: "Decidim::Proposals::Proposal"
+      belongs_to :valuator_role, polymorphic: true
+
+      def self.log_presenter_class_for(_log)
+        Decidim::Proposals::AdminLog::ValuationAssignmentPresenter
+      end
+
+      def valuator
+        valuator_role.user
+      end
+    end
+  end
+end

data/app/permissions/decidim/proposals/admin/permissions.rb

@@ -8,18 +8,22 @@ module Decidim
           # The public part needs to be implemented yet
           return permission_action if permission_action.scope != :admin
 
-          if create_permission_action?
-            # There's no special condition to create proposal notes, only
-            # users with access to the admin section can do it.
-            allow! if permission_action.subject == :proposal_note
-
-            # Proposals can only be created from the admin when the
-            # corresponding setting is enabled.
-            toggle_allow(admin_creation_is_enabled?) if permission_action.subject == :proposal
+          # Valuators can only perform these actions
+          if user_is_valuator?
+            if valuator_assigned_to_proposal?
+              can_create_proposal_note?
+              can_create_proposal_answer?
+            end
+            can_export_proposals?
+            valuator_can_unassign_valuator_from_proposals?
+
+            return permission_action
+          end
 
-            # Proposals can only be answered from the admin when the
-            # corresponding setting is enabled.
-            toggle_allow(admin_proposal_answering_is_enabled?) if permission_action.subject == :proposal_answer
+          if create_permission_action?
+            can_create_proposal_note?
+            can_create_proposal_from_admin?
+            can_create_proposal_answer?
           end
 
           # Admins can only edit official proposals if they are within the
@@ -29,15 +33,30 @@ module Decidim
           # Every user allowed by the space can update the category of the proposal
           allow! if permission_action.subject == :proposal_category && permission_action.action == :update
 
+          # Every user allowed by the space can update the scope of the proposal
+          allow! if permission_action.subject == :proposal_scope && permission_action.action == :update
+
           # Every user allowed by the space can import proposals from another_component
           allow! if permission_action.subject == :proposals && permission_action.action == :import
 
+          # Every user allowed by the space can export proposals
+          can_export_proposals?
+
           # Every user allowed by the space can merge proposals to another component
           allow! if permission_action.subject == :proposals && permission_action.action == :merge
 
           # Every user allowed by the space can split proposals to another component
           allow! if permission_action.subject == :proposals && permission_action.action == :split
 
+          # Every user allowed by the space can assign proposals to a valuator
+          allow! if permission_action.subject == :proposals && permission_action.action == :assign_to_valuator
+
+          # Every user allowed by the space can unassign a valuator from proposals
+          can_unassign_valuator_from_proposals?
+
+          # Only admin users can publish many answers at once
+          toggle_allow(user.admin?) if permission_action.subject == :proposals && permission_action.action == :publish_answers
+
           if permission_action.subject == :participatory_texts && participatory_texts_are_enabled?
             # Every user allowed by the space can manage (import, update and publish) participatory texts to proposals
             allow! if permission_action.action == :manage
@@ -52,6 +71,23 @@ module Decidim
           @proposal ||= context.fetch(:proposal, nil)
         end
 
+        def user_valuator_role
+          @user_valuator_role ||= space.user_roles(:valuator).find_by(user: user)
+        end
+
+        def user_is_valuator?
+          return if user.admin?
+
+          user_valuator_role.present?
+        end
+
+        def valuator_assigned_to_proposal?
+          @valuator_assigned_to_proposal ||=
+            Decidim::Proposals::ValuationAssignment
+            .where(proposal: proposal, valuator_role: user_valuator_role)
+            .any?
+        end
+
         def admin_creation_is_enabled?
           current_settings.try(:creation_enabled?) &&
             component_settings.try(:official_proposals_enabled)
@@ -75,6 +111,36 @@ module Decidim
         def participatory_texts_are_enabled?
           component_settings.participatory_texts_enabled?
         end
+
+        # There's no special condition to create proposal notes, only
+        # users with access to the admin section can do it.
+        def can_create_proposal_note?
+          allow! if permission_action.subject == :proposal_note
+        end
+
+        # Proposals can only be created from the admin when the
+        # corresponding setting is enabled.
+        def can_create_proposal_from_admin?
+          toggle_allow(admin_creation_is_enabled?) if permission_action.subject == :proposal
+        end
+
+        # Proposals can only be answered from the admin when the
+        # corresponding setting is enabled.
+        def can_create_proposal_answer?
+          toggle_allow(admin_proposal_answering_is_enabled?) if permission_action.subject == :proposal_answer
+        end
+
+        def can_unassign_valuator_from_proposals?
+          allow! if permission_action.subject == :proposals && permission_action.action == :unassign_from_valuator
+        end
+
+        def valuator_can_unassign_valuator_from_proposals?
+          can_unassign_valuator_from_proposals? if user == context.fetch(:valuator, nil)
+        end
+
+        def can_export_proposals?
+          allow! if permission_action.subject == :proposals && permission_action.action == :export
+        end
       end
     end
   end