decidim-proposals 0.19.1 → 0.23.0

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    # Simple helpers to handle markup variations for proposals
+    module ProposalsHelper
+      def proposal_reason_callout_args
+        {
+          announcement: {
+            title: proposal_reason_callout_title,
+            body: decidim_sanitize(translated_attribute(@proposal.answer))
+          },
+          callout_class: proposal_reason_callout_class
+        }
+      end
+
+      def proposal_reason_callout_class
+        case @proposal.state
+        when "accepted"
+          "success"
+        when "evaluating"
+          "warning"
+        when "rejected"
+          "alert"
+        else
+          ""
+        end
+      end
+
+      def proposal_reason_callout_title
+        i18n_key = case @proposal.state
+                   when "evaluating"
+                     "proposal_in_evaluation_reason"
+                   else
+                     "proposal_#{@proposal.state}_reason"
+                   end
+
+        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("state_not_published", 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
+
+      def resource_version(resource, options = {})
+        return unless resource.respond_to?(:amendable?) && resource.amendable?
+
+        super
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Decidim
       include Decidim::Resourceable
       include Decidim::Coauthorable
       include Decidim::HasComponent
-      include Decidim::ScopableComponent
+      include Decidim::ScopableResource
       include Decidim::HasReference
       include Decidim::HasCategory
       include Decidim::Reportable
@@ -28,7 +28,7 @@ module Decidim
                class_name: "Decidim::User",
                foreign_key: :decidim_user_id
 
-      geocoded_by :address, http_headers: ->(collaborative_draft) { { "Referer" => collaborative_draft.component.organization.host } }
+      geocoded_by :address
 
       scope :open, -> { where(state: "open") }
       scope :withdrawn, -> { where(state: "withdrawn") }

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

@@ -8,6 +8,9 @@ module Decidim
       include Decidim::HasComponent
       include Decidim::Traceable
       include Decidim::Loggable
+      include Decidim::TranslatableResource
+
+      translatable_fields :title, :description
     end
   end
 end

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

@@ -7,7 +7,7 @@ module Decidim
       include Decidim::Resourceable
       include Decidim::Coauthorable
       include Decidim::HasComponent
-      include Decidim::ScopableComponent
+      include Decidim::ScopableResource
       include Decidim::HasReference
       include Decidim::HasCategory
       include Decidim::Reportable
@@ -19,11 +19,18 @@ module Decidim
       include Decidim::Loggable
       include Decidim::Fingerprintable
       include Decidim::DataPortability
-      include Decidim::Hashtaggable
       include Decidim::Proposals::ParticipatoryTextSection
       include Decidim::Amendable
       include Decidim::NewsletterParticipant
       include Decidim::Randomable
+      include Decidim::Endorsable
+      include Decidim::Proposals::Valuatable
+      include Decidim::TranslatableResource
+      include Decidim::TranslatableAttributes
+
+      translatable_fields :title, :body
+
+      POSSIBLE_STATES = %w(not_answered evaluating accepted rejected withdrawn).freeze
 
       fingerprint fields: [:title, :body]
 
@@ -34,8 +41,6 @@ module Decidim
 
       component_manifest_name "proposals"
 
-      has_many :endorsements, foreign_key: "decidim_proposal_id", class_name: "ProposalEndorsement", dependent: :destroy, counter_cache: "proposal_endorsements_count"
-
       has_many :votes,
                -> { final },
                foreign_key: "decidim_proposal_id",
@@ -47,24 +52,45 @@ module Decidim
 
       validates :title, :body, presence: true
 
-      geocoded_by :address, http_headers: ->(proposal) { { "Referer" => proposal.component.organization.host } }
+      geocoded_by :address
+
+      scope :answered, -> { where.not(answered_at: nil) }
+      scope :not_answered, -> { where(answered_at: nil) }
 
-      scope :accepted, -> { where(state: "accepted") }
-      scope :rejected, -> { where(state: "rejected") }
-      scope :evaluating, -> { where(state: "evaluating") }
+      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 :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
 
       searchable_fields({
                           scope_id: :decidim_scope_id,
                           participatory_space: { component: :participatory_space },
-                          D: :search_body,
-                          A: :search_title,
+                          D: :body,
+                          A: :title,
                           datetime: :published_at
                         },
                         index_on_create: ->(proposal) { proposal.official? },
@@ -100,10 +126,9 @@ module Decidim
 
         participants_has_voted_ids = Decidim::Proposals::ProposalVote.joins(:proposal).where(proposal: proposals).joins(:author).map(&:decidim_author_id).flatten.compact.uniq
 
-        endorsements_participants_ids = Decidim::Proposals::ProposalEndorsement.joins(:proposal)
-                                                                               .where(proposal: proposals)
-                                                                               .where(decidim_author_type: "Decidim::UserBaseEntity")
-                                                                               .map(&:decidim_author_id).flatten.compact.uniq
+        endorsements_participants_ids = Decidim::Endorsement.where(resource: proposals)
+                                                            .where(decidim_author_type: "Decidim::UserBaseEntity")
+                                                            .pluck(:decidim_author_id).to_a.compact.uniq
 
         (endorsements_participants_ids + participants_has_voted_ids + coauthors_recipients_ids).flatten.compact.uniq
       end
@@ -124,54 +149,75 @@ module Decidim
         ProposalVote.where(proposal: self, author: user).any?
       end
 
-      # Public: Check if the user has endorsed the proposal.
-      # - user_group: may be nil if user is not representing any user_group.
+      # Public: Checks if the proposal has been published or not.
       #
       # Returns Boolean.
-      def endorsed_by?(user, user_group = nil)
-        endorsements.where(author: user, user_group: user_group).any?
+      def published?
+        published_at.present?
       end
 
-      # Public: Checks if the proposal has been published or not.
+      # Public: Returns the published state of the proposal.
       #
       # Returns Boolean.
-      def published?
-        published_at.present?
+      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.
@@ -221,7 +267,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.
@@ -236,15 +282,69 @@ module Decidim
         published_at.nil?
       end
 
-      # method for sort_link by number of comments
-      ransacker :commentable_comments_count do
+      # 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
-        (SELECT COUNT(decidim_comments_comments.id)
-         FROM decidim_comments_comments
-         WHERE decidim_comments_comments.decidim_commentable_id = decidim_proposals_proposals.id
-         AND decidim_comments_comments.decidim_commentable_type = 'Decidim::Proposals::Proposal'
-         GROUP BY decidim_comments_comments.decidim_commentable_id
-         )
+        :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 :title do
+        Arel.sql(%{("decidim_proposals_proposals"."title")::text})
+      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
@@ -270,6 +370,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