decidim-initiatives 0.21.0 → 0.22.0

data/app/forms/decidim/initiatives/initiative_form.rb

@@ -12,15 +12,24 @@ module Decidim
       attribute :description, String
       attribute :type_id, Integer
       attribute :scope_id, Integer
+      attribute :area_id, Integer
       attribute :decidim_user_group_id, Integer
       attribute :signature_type, String
+      attribute :signature_end_date, Date
       attribute :state, String
+      attribute :attachment, AttachmentForm
 
       validates :title, :description, presence: true
       validates :title, length: { maximum: 150 }
       validates :signature_type, presence: true
       validates :type_id, presence: true
+      validates :area, presence: true, if: ->(form) { form.area_id.present? }
       validate :scope_exists
+      validate :notify_missing_attachment_if_errored
+      validate :trigger_attachment_errors
+      validates :signature_end_date, date: { after: Date.current }, if: lambda { |form|
+        form.context.initiative_type.custom_signature_end_date_enabled? && form.signature_end_date.present?
+      }
 
       def map_model(model)
         self.type_id = model.type.id
@@ -35,6 +44,10 @@ module Decidim
         super.presence
       end
 
+      def area
+        @area ||= current_organization.areas.find_by(id: area_id)
+      end
+
       private
 
       def scope_exists
@@ -42,6 +55,27 @@ module Decidim
 
         errors.add(:scope_id, :invalid) unless InitiativesTypeScope.where(decidim_initiatives_types_id: type_id, decidim_scopes_id: scope_id).exists?
       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
+        return if attachment.blank?
+
+        errors.add(:attachment, :needs_to_be_reattached) if errors.any?
+      end
+
+      def trigger_attachment_errors
+        return if attachment.blank?
+        return if attachment.valid?
+
+        attachment.errors.each { |error| errors.add(:attachment, error) }
+
+        attachment = Attachment.new(file: attachment.try(:file))
+
+        errors.add(:attachment, :file) if !attachment.save && attachment.errors.has_key?(:file)
+      end
     end
   end
 end

data/app/forms/decidim/initiatives/vote_form.rb

@@ -96,7 +96,9 @@ module Decidim
 
         errors.add(:base, :invalid) unless authorized? &&
                                            authorization_handler &&
-                                           authorization_handler_metadata_variations.any? { |variation| authorization.metadata.symbolize_keys == variation.symbolize_keys }
+                                           authorization_handler_metadata_variations.any? do |variation|
+                                             authorization.metadata.symbolize_keys.except(:extras) == variation.symbolize_keys.except(:extras)
+                                           end
       end
 
       def author

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Initiatives
+    # Custom helpers, scoped to the initiatives engine.
+    #
+    module ApplicationHelper
+      include Decidim::CheckBoxesTreeHelper
+
+      def filter_states_values
+        TreeNode.new(
+          TreePoint.new("", t("decidim.initiatives.application_helper.filter_state_values.all")),
+          [
+            TreePoint.new("open", t("decidim.initiatives.application_helper.filter_state_values.open")),
+            TreeNode.new(
+              TreePoint.new("closed", t("decidim.initiatives.application_helper.filter_state_values.closed")),
+              [
+                TreePoint.new("accepted", t("decidim.initiatives.application_helper.filter_state_values.accepted")),
+                TreePoint.new("rejected", t("decidim.initiatives.application_helper.filter_state_values.rejected"))
+              ]
+            ),
+            TreePoint.new("answered", t("decidim.initiatives.application_helper.filter_state_values.answered"))
+          ]
+        )
+      end
+
+      def filter_scopes_values
+        main_scopes = current_organization.scopes.top_level
+
+        scopes_values = main_scopes.includes(:scope_type, :children).flat_map do |scope|
+          TreeNode.new(
+            TreePoint.new(scope.id.to_s, translated_attribute(scope.name, current_organization)),
+            scope_children_to_tree(scope)
+          )
+        end
+
+        scopes_values.prepend(TreePoint.new("global", t("decidim.scopes.global")))
+
+        TreeNode.new(
+          TreePoint.new("", t("decidim.initiatives.application_helper.filter_scope_values.all")),
+          scopes_values
+        )
+      end
+
+      def scope_children_to_tree(scope)
+        return unless scope.children.any?
+
+        scope.children.includes(:scope_type, :children).flat_map do |child|
+          TreeNode.new(
+            TreePoint.new(child.id.to_s, translated_attribute(child.name, current_organization)),
+            scope_children_to_tree(child)
+          )
+        end
+      end
+
+      def filter_types_values
+        types_values = Decidim::InitiativesType.where(organization: current_organization).map do |type|
+          TreeNode.new(
+            TreePoint.new(type.id.to_s, type.title[I18n.locale.to_s])
+          )
+        end
+
+        TreeNode.new(
+          TreePoint.new("", t("decidim.initiatives.application_helper.filter_type_values.all")),
+          types_values
+        )
+      end
+
+      def filter_areas_values
+        areas_or_types = areas_for_select(current_organization)
+
+        areas_values = if areas_or_types.first.is_a?(Decidim::Area)
+                         filter_areas(areas_or_types)
+                       else
+                         filter_areas_and_types(areas_or_types)
+                       end
+
+        TreeNode.new(
+          TreePoint.new("", t("decidim.initiatives.application_helper.filter_area_values.all")),
+          areas_values
+        )
+      end
+
+      def filter_areas(areas)
+        areas.map do |area|
+          TreeNode.new(
+            TreePoint.new(area.id.to_s, area.name[I18n.locale.to_s])
+          )
+        end
+      end
+
+      def filter_areas_and_types(area_types)
+        area_types.map do |area_type|
+          TreeNode.new(
+            TreePoint.new(area_type.area_ids.join("_"), area_type.name[I18n.locale.to_s]),
+            area_type.areas.map do |area|
+              TreePoint.new(area.id.to_s, area.name[I18n.locale.to_s])
+            end
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,7 @@ module Decidim
     include Decidim::HasReference
     include Decidim::Randomable
     include Decidim::Searchable
+    include Decidim::Initiatives::HasArea
 
     belongs_to :organization,
                foreign_key: "decidim_organization_id",
@@ -30,7 +31,8 @@ module Decidim
                inverse_of: :initiatives
 
     delegate :type, :scope, :scope_name, to: :scoped_type, allow_nil: true
-    delegate :promoting_committee_enabled?, to: :type
+    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",
@@ -67,24 +69,32 @@ module Decidim
               case_sensitive: false
 
     scope :open, lambda {
-      published
-        .where.not(state: [:discarded, :rejected, :accepted, :created])
-        .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_most_recently_published, -> { order(published_at: :desc) }
     scope :order_by_supports, -> { order(Arel.sql("initiative_votes_count + coalesce(offline_votes, 0) desc")) }
     scope :order_by_most_commented, lambda {
       select("decidim_initiatives.*")
@@ -227,7 +237,7 @@ 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
 
@@ -301,6 +311,10 @@ module Decidim
       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
@@ -368,5 +382,43 @@ module Decidim
 
     # 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
+      query = <<~SQL
+        (
+          SELECT
+            CASE
+              WHEN signature_type = 0 THEN 0
+              ELSE COALESCE(offline_votes, 0)
+            END
+            +
+            CASE
+              WHEN signature_type = 1 THEN 0
+              ELSE initiative_votes_count + initiative_supports_count
+            END
+           FROM decidim_initiatives as initiatives
+          WHERE initiatives.id = decidim_initiatives.id
+          GROUP BY initiatives.id
+        )
+      SQL
+      Arel.sql(query)
+    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

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

@@ -35,6 +35,7 @@ module Decidim
           initiative_type_scope_action?
           initiative_committee_action?
           initiative_admin_user_action?
+          initiative_export_action?
           moderator_action?
           allow! if permission_action.subject == :attachment
 
@@ -69,6 +70,8 @@ module Decidim
         def attachment_action?
           return unless permission_action.subject == :attachment
 
+          disallow! && return unless initiative.attachments_enabled?
+
           attachment = context.fetch(:attachment, nil)
           attached = attachment&.attached_to
 
@@ -158,6 +161,10 @@ module Decidim
           end
         end
 
+        def initiative_export_action?
+          allow! if permission_action.subject == :initiatives && permission_action.action == :export
+        end
+
         def moderator_action?
           return unless permission_action.subject == :moderation