decidim-initiatives 0.20.0 → 0.23.1.rc1

data/app/helpers/decidim/initiatives/initiative_helper.rb

@@ -5,6 +5,7 @@ module Decidim
     # Helper method related to initiative object and its internal state.
     module InitiativeHelper
       include Decidim::SanitizeHelper
+      include Decidim::ResourceVersionsHelper
 
       # Public: The css class applied based on the initiative state to
       #         the initiative badge.
@@ -99,6 +100,18 @@ module Decidim
 
         send("#{tag}_to", "", html_options, &block)
       end
+
+      def can_edit_custom_signature_end_date?(initiative)
+        return false unless initiative.custom_signature_end_date_enabled?
+
+        initiative.created? || initiative.validating?
+      end
+
+      def can_edit_area?(initiative)
+        return false unless initiative.area_enabled?
+
+        initiative.created? || initiative.validating?
+      end
     end
   end
 end

data/app/helpers/decidim/initiatives/initiatives_helper.rb

@@ -7,6 +7,7 @@ module Decidim
       def initiatives_filter_form_for(filter)
         content_tag :div, class: "filters" do
           form_for filter,
+                   namespace: filter_form_namespace,
                    builder: Decidim::Initiatives::InitiativesFilterFormBuilder,
                    url: url_for,
                    as: :filter,
@@ -17,6 +18,15 @@ module Decidim
           end
         end
       end
+
+      private
+
+      # Creates a unique namespace for a filter form to prevent dupliacte IDs in
+      # the DOM when multiple filter forms are rendered with the same fields (e.g.
+      # for desktop and mobile).
+      def filter_form_namespace
+        "filters_#{SecureRandom.uuid}"
+      end
     end
   end
 end

data/app/jobs/decidim/initiatives/export_initiatives_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Initiatives
+    class ExportInitiativesJob < ApplicationJob
+      queue_as :default
+
+      def perform(user, format)
+        export_data = Decidim::Exporters.find_exporter(format).new(collection, serializer).export
+
+        ExportMailer.export(user, "initiatives", export_data).deliver_now
+      end
+
+      private
+
+      def collection
+        Decidim::Initiative.all
+      end
+
+      def serializer
+        Decidim::Initiatives::InitiativeSerializer
+      end
+    end
+  end
+end

data/app/mailers/decidim/initiatives/initiatives_mailer.rb

@@ -51,27 +51,6 @@ module Decidim
         end
       end
 
-      # Notify an initiative requesting technical validation
-      def notify_validating_request(initiative, user)
-        return if user.email.blank?
-
-        @organization = initiative.organization
-        @link = decidim_admin_initiatives.edit_initiative_url(initiative, host: @organization.host)
-
-        with_user(user) do
-          @subject = I18n.t(
-            "decidim.initiatives.initiatives_mailer.technical_validation_for",
-            title: translated_attribute(initiative.title)
-          )
-          @body = I18n.t(
-            "decidim.initiatives.initiatives_mailer.technical_validation_body_for",
-            title: translated_attribute(initiative.title)
-          )
-
-          mail(to: "#{user.name} <#{user.email}>", subject: @subject)
-        end
-      end
-
       # Notify progress to all initiative subscribers.
       def notify_progress(initiative, user)
         return if user.email.blank?

data/app/models/concerns/decidim/initiatives/has_area.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Initiatives
+    module HasArea
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :area,
+                   foreign_key: "decidim_area_id",
+                   class_name: "Decidim::Area",
+                   optional: true
+
+        delegate :areas, to: :organization
+
+        validate :area_belongs_to_organization
+      end
+
+      private
+
+      def area_belongs_to_organization
+        return unless area && organization
+
+        errors.add(:area, :invalid) unless areas.where(id: area.id).exists?
+      end
+    end
+  end
+end

data/app/models/decidim/initiative.rb

@@ -7,7 +7,7 @@ module Decidim
     include Decidim::Authorable
     include Decidim::Participable
     include Decidim::Publicable
-    include Decidim::Scopable
+    include Decidim::ScopableParticipatorySpace
     include Decidim::Comments::Commentable
     include Decidim::Followable
     include Decidim::HasAttachments
@@ -19,6 +19,10 @@ module Decidim
     include Decidim::HasReference
     include Decidim::Randomable
     include Decidim::Searchable
+    include Decidim::Initiatives::HasArea
+    include Decidim::TranslatableResource
+
+    translatable_fields :title, :description, :answer
 
     belongs_to :organization,
                foreign_key: "decidim_organization_id",
@@ -29,8 +33,9 @@ module Decidim
                class_name: "Decidim::InitiativesTypeScope",
                inverse_of: :initiatives
 
-    delegate :type, :scope, :scope_name, to: :scoped_type, allow_nil: true
-    delegate :promoting_committee_enabled?, to: :type
+    delegate :type, :scope, :scope_name, :supports_required, to: :scoped_type, allow_nil: true
+    delegate :attachments_enabled?, :promoting_committee_enabled?, :custom_signature_end_date_enabled?, :area_enabled?, to: :type
+    delegate :name, to: :area, prefix: true, allow_nil: true
 
     has_many :votes,
              foreign_key: "decidim_initiative_id",
@@ -59,41 +64,51 @@ module Decidim
 
     validates :title, :description, :state, presence: true
     validates :signature_type, presence: true
-    validate :signature_type_allowed
-
     validates :hashtag,
               uniqueness: true,
               allow_blank: true,
               case_sensitive: false
+    validate :signature_type_allowed
 
     scope :open, lambda {
-      published
-        .where.not(state: [:discarded, :rejected, :accepted])
-        .where("signature_start_date <= ?", Date.current)
-        .where("signature_end_date >= ?", Date.current)
+      where.not(state: [:discarded, :rejected, :accepted, :created])
+           .currently_signable
     }
     scope :closed, lambda {
-      published
-        .where(state: [:discarded, :rejected, :accepted])
-        .or(where("signature_start_date > ?", Date.current))
-        .or(where("signature_end_date < ?", Date.current))
+      where(state: [:discarded, :rejected, :accepted])
+        .or(currently_unsignable)
     }
     scope :published, -> { where.not(published_at: nil) }
     scope :with_state, ->(state) { where(state: state) if state.present? }
 
+    scope :currently_signable, lambda {
+      where("signature_start_date <= ?", Date.current)
+        .where("signature_end_date >= ?", Date.current)
+    }
+    scope :currently_unsignable, lambda {
+      where("signature_start_date > ?", Date.current)
+        .or(where("signature_end_date < ?", Date.current))
+    }
+
+    scope :answered, -> { where.not(answered_at: nil) }
+
     scope :public_spaces, -> { published }
     scope :signature_type_updatable, -> { created }
 
     scope :order_by_most_recent, -> { order(created_at: :desc) }
-    scope :order_by_supports, -> { order(Arel.sql("initiative_votes_count + coalesce(offline_votes, 0) desc")) }
+    scope :order_by_supports, -> { order(Arel.sql("(coalesce((online_votes->>'total')::int,0) + coalesce((offline_votes->>'total')::int,0)) DESC")) }
+    scope :order_by_most_recently_published, -> { order(published_at: :desc) }
     scope :order_by_most_commented, lambda {
       select("decidim_initiatives.*")
         .left_joins(:comments)
         .group("decidim_initiatives.id")
         .order(Arel.sql("count(decidim_comments_comments.id) desc"))
     }
+    scope :future_spaces, -> { none }
+    scope :past_spaces, -> { closed }
 
-    after_save :notify_state_change
+    before_update :set_offline_votes_total
+    after_commit :notify_state_change
     after_create :notify_creation
 
     searchable_fields({
@@ -106,18 +121,20 @@ module Decidim
                       # is Resourceable instead of ParticipatorySpaceResourceable so we can't use `visible?`
                       index_on_update: ->(initiative) { initiative.published? })
 
-    def self.future_spaces
-      none
-    end
-
-    def self.past_spaces
-      closed
-    end
-
     def self.log_presenter_class_for(_log)
       Decidim::Initiatives::AdminLog::InitiativePresenter
     end
 
+    # PUBLIC banner image
+    #
+    # Overrides participatory space's banner image with the banner image defined
+    # for the initiative type.
+    #
+    # RETURNS string
+    delegate :banner_image, to: :type
+    delegate :document_number_authorization_handler, :promoting_committee_enabled?, to: :type
+    delegate :type, :scope, :scope_name, to: :scoped_type, allow_nil: true
+
     # PUBLIC
     #
     # Returns true when an initiative has been created by an individual person.
@@ -172,17 +189,6 @@ module Decidim
         ActionController::Base.helpers.asset_path("decidim/default-avatar.svg")
     end
 
-    # PUBLIC banner image
-    #
-    # Overrides participatory space's banner image with the banner image defined
-    # for the initiative type.
-    #
-    # RETURNS string
-    delegate :banner_image, to: :type
-
-    delegate :document_number_authorization_handler, to: :type
-    delegate :supports_required, to: :scoped_type
-
     def votes_enabled?
       published? &&
         signature_start_date <= Date.current &&
@@ -227,11 +233,10 @@ module Decidim
         published_at: Time.current,
         state: "published",
         signature_start_date: Date.current,
-        signature_end_date: Date.current + Decidim::Initiatives.default_signature_time_period_length
+        signature_end_date: signature_end_date || Date.current + Decidim::Initiatives.default_signature_time_period_length
       )
     end
 
-    #
     # Public: Unpublishes this initiative
     #
     # Returns true if the record was properly saved, false otherwise.
@@ -251,10 +256,25 @@ module Decidim
       attributes["hashtag"].to_s.delete("#")
     end
 
+    # Public: Calculates the number of total current supports.
+    #
+    # Returns an Integer.
     def supports_count
-      face_to_face_votes = offline_votes.nil? || online_signature_type? ? 0 : offline_votes
-      digital_votes = offline_signature_type? ? 0 : (initiative_votes_count + initiative_supports_count)
-      digital_votes + face_to_face_votes
+      online_votes_count + offline_votes_count
+    end
+
+    # Public: Calculates the number of current supports for a scope.
+    #
+    # Returns an Integer.
+    def supports_count_for(scope)
+      online_votes_count_for(scope) + offline_votes_count_for(scope)
+    end
+
+    # Public: Calculates the number of supports required to accept the initiative for a scope.
+    #
+    # Returns an Integer.
+    def supports_required_for(scope)
+      initiative_type_scopes.find_by(decidim_scopes_id: scope&.id).supports_required
     end
 
     # Public: Returns the percentage of required supports reached
@@ -266,7 +286,75 @@ module Decidim
 
     # Public: Whether the supports required objective has been reached
     def supports_goal_reached?
-      supports_count >= supports_required
+      initiative_type_scopes.map(&:scope).all? { |scope| supports_goal_reached_for?(scope) }
+    end
+
+    # Public: Whether the supports required objective has been reached for a scope
+    def supports_goal_reached_for?(scope)
+      supports_count_for(scope) >= supports_required_for(scope)
+    end
+
+    # Public: Calculates all the votes across all the scopes.
+    #
+    # Returns an Integer.
+    def online_votes_count
+      return 0 if offline_signature_type?
+
+      online_votes["total"].to_i
+    end
+
+    def offline_votes_count
+      return 0 if online_signature_type?
+
+      offline_votes["total"].to_i
+    end
+
+    def online_votes_count_for(scope)
+      return 0 if offline_signature_type?
+
+      scope_key = (scope&.id || "global").to_s
+
+      (online_votes || {}).fetch(scope_key, 0).to_i
+    end
+
+    def offline_votes_count_for(scope)
+      return 0 if online_signature_type?
+
+      scope_key = (scope&.id || "global").to_s
+
+      (offline_votes || {}).fetch(scope_key, 0).to_i
+    end
+
+    def update_online_votes_counters
+      online_votes = votes.group(:scope).count.each_with_object({}) do |(scope, count), counters|
+        counters[scope&.id || "global"] = count
+        counters["total"] ||= 0
+        counters["total"] += count
+      end
+
+      # rubocop:disable Rails/SkipsModelValidations
+      update_column("online_votes", online_votes)
+      # rubocop:enable Rails/SkipsModelValidations
+    end
+
+    def set_offline_votes_total
+      return if offline_votes.blank? || scope.nil?
+
+      offline_votes["total"] = offline_votes[scope.id.to_s]
+    end
+
+    # Public: Finds all the InitiativeTypeScopes that are eligible to be voted by a user.
+    # Usually this is only the `scoped_type` but voting on children of the scoped type is
+    # enabled we have to filter all the available scopes in the initiative type to select
+    # the ones that are a descendant of the initiative type.
+    #
+    # Returns an Array of Decidim::InitiativesScopeType.
+    def votable_initiative_type_scopes
+      return Array(scoped_type) unless type.child_scope_threshold_enabled?
+
+      initiative_type_scopes.select do |initiative_type_scope|
+        initiative_type_scope.scope.present? && (scoped_type.global_scope? || scoped_type.scope.ancestor_of?(initiative_type_scope.scope))
+      end.prepend(scoped_type).uniq
     end
 
     # Public: Overrides slug attribute from participatory processes.
@@ -289,18 +377,20 @@ module Decidim
       true
     end
 
-    # PUBLIC
-    #
-    # Checks if user is the author or is part of the promotal committee
+    # Public:  Checks if user is the author or is part of the promotal committee
     # of the initiative.
     #
-    # RETURNS boolean
+    # Returns a Boolean.
     def has_authorship?(user)
       return true if author.id == user.id
 
       committee_members.approved.where(decidim_users_id: user.id).any?
     end
 
+    def author_users
+      [author].concat(committee_members.excluding_author.map(&:user))
+    end
+
     def accepts_offline_votes?
       published? && (offline_signature_type? || any_signature_type?)
     end
@@ -332,8 +422,27 @@ module Decidim
       organization.available_authorizations.include?("sms") && type.validate_sms_code_on_votes?
     end
 
+    # Public: Returns an empty object. This method should be implemented by
+    # `ParticipatorySpaceResourceable`, but for some reason this model does not
+    # implement this interface.
+    def user_role_config_for(_user, _role_name)
+      Decidim::ParticipatorySpaceRoleConfig::Base.new(:empty_role_name)
+    end
+
     private
 
+    # Private: This is just an alias because the naming on InitiativeTypeScope
+    # is very confusing. The `scopes` method doesn't return Decidim::Scope but
+    # Decidim::InitiativeTypeScopes.
+    #
+    # ¯\_(ツ)_/¯
+    #
+    # Returns an Array of Decidim::InitiativesScopeType.
+    def initiative_type_scopes
+      type.scopes
+    end
+
+    # Private: A validator that verifies the signaature type is allowed by the InitiativeType.
     def signature_type_allowed
       return if published?
 
@@ -351,5 +460,36 @@ module Decidim
       notifier = Decidim::Initiatives::StatusChangeNotifier.new(initiative: self)
       notifier.notify
     end
+
+    # Allow ransacker to search for a key in a hstore column (`title`.`en`)
+    [:title, :description].each do |column|
+      ransacker column do |parent|
+        Arel::Nodes::InfixOperation.new("->>", parent.table[column], Arel::Nodes.build_quoted(I18n.locale.to_s))
+      end
+    end
+
+    # Allow ransacker to search on an Enum Field
+    ransacker :state, formatter: proc { |int| states[int] }
+
+    ransacker :type_id do
+      Arel.sql("decidim_initiatives_type_scopes.decidim_initiatives_types_id")
+    end
+
+    # method for sort_link by number of supports
+    ransacker :supports_count do
+      Arel.sql("(coalesce((online_votes->>'total')::int,0) + coalesce((offline_votes->>'total')::int,0))")
+    end
+
+    ransacker :id_string do
+      Arel.sql(%{cast("decidim_initiatives"."id" as text)})
+    end
+
+    ransacker :author_name do
+      Arel.sql("decidim_users.name")
+    end
+
+    ransacker :author_nickname do
+      Arel.sql("decidim_users.nickname")
+    end
   end
 end