decidim-proposals 0.19.0 → 0.22.0

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

@@ -21,9 +21,9 @@ module Decidim
       #
       # Returns a string with the value of the css classes.
       def vote_button_classes(from_proposals_list)
-        return "card__button button--sc" if from_proposals_list
+        return "card__button" if from_proposals_list
 
-        "expanded button--sc"
+        "expanded"
       end
 
       # Public: Gets the vote limit for each user, if set.

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

@@ -58,7 +58,15 @@ module Decidim
       def proposal_wizard_stepper_step(step, current_step)
         return if step == :step_4 && type_of == :collaborative_drafts
 
-        content_tag(:li, proposal_wizard_step_name(step), class: proposal_wizard_step_classes(step, current_step).to_s)
+        attributes = { class: proposal_wizard_step_classes(step, current_step).to_s }
+        step_title = proposal_wizard_step_name(step)
+        if step.to_s.split("_").last.to_i == proposal_wizard_step_number(current_step)
+          current_step_title = proposal_wizard_step_name("current_step")
+          step_title = content_tag(:span, "#{current_step_title}: ", class: "show-for-sr") + step_title
+          attributes["aria-current"] = "step"
+        end
+
+        content_tag(:li, step_title, attributes)
       end
 
       # Returns the list with all the steps, in html
@@ -77,15 +85,21 @@ module Decidim
 
       # Returns a string with the current step number and the total steps number
       #
-      # step - A symbol of the target step
       def proposal_wizard_current_step_of(step)
         current_step_num = proposal_wizard_step_number(step)
-        content_tag :span, class: "text-small" do
-          concat t(:"decidim.proposals.proposals.wizard_steps.step_of", current_step_num: current_step_num, total_steps: total_steps)
+        see_steps = content_tag(:span, class: "hide-for-large") do
           concat " ("
           concat content_tag :a, t(:"decidim.proposals.proposals.wizard_steps.see_steps"), "data-toggle": "steps"
           concat ")"
         end
+        content_tag :span, class: "text-small" do
+          concat t(:"decidim.proposals.proposals.wizard_steps.step_of", current_step_num: current_step_num, total_steps: total_steps)
+          concat see_steps
+        end
+      end
+
+      def proposal_wizard_steps_title
+        t("title", scope: "decidim.proposals.#{type_of}.wizard_steps")
       end
 
       # Returns a boolean if the step has a help text defined
@@ -146,12 +160,15 @@ module Decidim
         url
       end
 
-      def wizard_aside_back_text
+      def wizard_aside_back_text(from = nil)
+        key = "back"
+        key = "back_from_#{from}" if from
+
         case type_of
         when :collaborative_drafts
-          t("back", scope: "decidim.proposals.collaborative_drafts.wizard_aside").html_safe
+          t(key, scope: "decidim.proposals.collaborative_drafts.wizard_aside").html_safe
         else
-          t("back", scope: "decidim.proposals.proposals.wizard_aside").html_safe
+          t(key, scope: "decidim.proposals.proposals.wizard_aside").html_safe
         end
       end
 

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("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
+
+      def resource_version(resource, options = {})
+        return unless resource.respond_to?(:amendable?) && resource.amendable?
+
+        super
+      end
+    end
+  end
+end

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

@@ -24,6 +24,10 @@ module Decidim
       include Decidim::Amendable
       include Decidim::NewsletterParticipant
       include Decidim::Randomable
+      include Decidim::Endorsable
+      include Decidim::Proposals::Valuatable
+
+      POSSIBLE_STATES = %w(not_answered evaluating accepted rejected withdrawn).freeze
 
       fingerprint fields: [:title, :body]
 
@@ -34,8 +38,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",
@@ -49,14 +51,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
 
@@ -100,10 +144,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")
+                                                            .map(&:decidim_author_id).flatten.compact.uniq
 
         (endorsements_participants_ids + participants_has_voted_ids + coauthors_recipients_ids).flatten.compact.uniq
       end
@@ -124,54 +167,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 +285,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.
@@ -249,6 +313,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
@@ -270,6 +397,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