decidim-core 0.29.6 → 0.30.0.rc1

data/lib/decidim/moderation_tools.rb

@@ -28,12 +28,16 @@ module Decidim
 
     # Public: fetches the participatory space of the resource's component or from the resource itself
     def participatory_space
-      @participatory_space ||= @reportable.component&.participatory_space || @reportable.try(:participatory_space)
+      @participatory_space ||= if reportable.class.respond_to?(:participatory_space?)
+                                 reportable
+                               else
+                                 reportable.component&.participatory_space || reportable.try(:participatory_space)
+                               end
     end
 
     # Public: updates the reported content for the moderation object associated with resource
     def update_reported_content!
-      moderation.update!(reported_content: @reportable.reported_searchable_content_text)
+      moderation.update!(reported_content: reportable.reported_searchable_content_text)
     end
 
     # Public: creates a new report for the given resource, having a basic set of options
@@ -59,18 +63,16 @@ module Decidim
         event_class: Decidim::ResourceHiddenEvent,
         resource: @reportable,
         extra: {
-          report_reasons:,
-          force_email: true
+          report_reasons:
         },
-        affected_users:,
-        force_send: true
+        affected_users: @reportable.try(:authors) || [@reportable.try(:normalized_author)]
       }
 
       Decidim::EventsManager.publish(**data)
     end
 
     # Public: hides the resource
-    def hide!
+    def hide_with_admin_log!
       Decidim.traceability.perform_action!(
         "hide",
         moderation,
@@ -79,25 +81,20 @@ module Decidim
           reportable_type: @reportable.class.name
         }
       ) do
-        @reportable.moderation.update!(hidden_at: Time.current)
-        @reportable.try(:touch)
+        hide!
       end
+    end
 
-      if @reportable.is_a?(Decidim::Comments::Commentable)
-        @reportable.comment_threads.each do |comment|
-          Decidim::HideChildResourcesJob.perform_later(comment, @current_user.id)
-        end
+    # Public: hides the resources
+    def hide!
+      Decidim.traceability.perform_action_without_log!(current_user) do
+        @reportable.moderation.update!(hidden_at: Time.current)
+        @reportable.try(:touch)
       end
-
-      send_notification_to_author
     end
 
     private
 
-    def affected_users
-      @affected_users ||= (@reportable.try(:authors) || [@reportable.try(:author)]).select { |author| author.is_a?(Decidim::User) }
-    end
-
     def report_reasons
       @reportable.moderation.reports.pluck(:reason).uniq
     end

data/lib/decidim/newsletter_encryptor.rb

@@ -14,7 +14,7 @@ module Decidim
 
     def self.crypt_data
       key = ActiveSupport::KeyGenerator.new("sent_at").generate_key(
-        Rails.application.secrets.secret_key_base, ActiveSupport::MessageEncryptor.key_len
+        Rails.application.secret_key_base, ActiveSupport::MessageEncryptor.key_len
       )
       ActiveSupport::MessageEncryptor.new(key)
     end

data/lib/decidim/nicknamizable.rb

@@ -27,16 +27,19 @@ module Decidim
       # * Disambiguates it so it is unique.
       #
       # name - the String to nicknamize
-      # organization_id - the organization id we are using as scope for the uniqueness
+      # scope - a Hash with extra values to scope the nickname to
       #
       # Example to nicknamize a user name, scoped to the organization:
       #
-      #    nicknamize(user_name, organization_id)
+      #    nicknamize(user_name, organization: current_organization)
       #
-      def nicknamize(name, organization_id)
+      def nicknamize(name, scope = {})
         return unless name
 
-        disambiguate(name.parameterize(separator: "_")[nickname_length_range], organization_id)
+        disambiguate(
+          name.parameterize(separator: "_")[nickname_length_range],
+          scope
+        )
       end
 
       private
@@ -45,11 +48,11 @@ module Decidim
         (0...nickname_max_length)
       end
 
-      def disambiguate(name, organization_id)
+      def disambiguate(name, scope)
         candidate = name
 
         2.step do |n|
-          return candidate if Decidim::UserBaseEntity.where(nickname: candidate.downcase).where(decidim_organization_id: organization_id).empty?
+          return candidate if Decidim::UserBaseEntity.where("nickname ILIKE ?", candidate.downcase).where(scope).empty?
 
           candidate = numbered_variation_of(name, n)
         end

data/lib/decidim/paddable.rb

@@ -66,7 +66,7 @@ module Decidim
           return tokenizer.hex_digest(id)
         end
 
-        Digest::MD5.hexdigest("#{id}-#{Rails.application.secrets.secret_key_base}")
+        Digest::MD5.hexdigest("#{id}-#{Rails.application.secret_key_base}")
       end
 
       def build_pad_url(id)

data/lib/decidim/participable.rb

@@ -14,25 +14,25 @@ module Decidim
 
       def skip_space_slug?(method_name)
         [
-          "edit_#{underscored_name}_path".to_sym,
-          "edit_#{underscored_name}_url".to_sym,
-          "new_#{underscored_name}_path".to_sym,
-          "new_#{underscored_name}_url".to_sym,
-          "#{underscored_name}_path".to_sym,
-          "#{underscored_name}_url".to_sym,
-          "#{underscored_name.pluralize}_path".to_sym,
-          "#{underscored_name.pluralize}_url".to_sym
+          :"edit_#{underscored_name}_path",
+          :"edit_#{underscored_name}_url",
+          :"new_#{underscored_name}_path",
+          :"new_#{underscored_name}_url",
+          :"#{underscored_name}_path",
+          :"#{underscored_name}_url",
+          :"#{underscored_name.pluralize}_path",
+          :"#{underscored_name.pluralize}_url"
         ].include?(method_name)
       end
 
       def slug_param_name
-        "#{underscored_name}_slug".to_sym
+        :"#{underscored_name}_slug"
       end
 
       def mounted_params
         {
           :host => organization.host,
-          "#{underscored_name}_slug".to_sym => slug
+          :"#{underscored_name}_slug" => slug
         }
       end
 

data/lib/decidim/participatory_space_user.rb

@@ -37,6 +37,16 @@ module Decidim
         raise "Not implemented"
       end
 
+      def self.ransackable_attributes(auth_object = nil)
+        return [] unless auth_object&.admin?
+
+        %w(name nickname email invitation_accepted_at last_sign_in_at role)
+      end
+
+      def self.ransackable_associations(_auth_object = nil)
+        []
+      end
+
       def self.order_by_name
         includes(:user).order("decidim_users.name ASC")
       end

data/lib/decidim/private_download_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  module PrivateDownloadHelper
+    def attach_archive(export_data, name, user)
+      private_exports = user.private_exports.build
+      private_exports.export_type = name
+      private_exports.file.attach(io: StringIO.open(FileZipper.new(export_data.filename(name), export_data.read).zip), filename: "#{name}.zip")
+      private_exports.expires_at = Decidim.download_your_data_expiry_time.from_now
+      private_exports.metadata = {}
+      private_exports.save!
+      private_exports.reload
+    end
+  end
+end

data/lib/decidim/record_encryptor.rb

@@ -53,54 +53,59 @@ module Decidim
         #   def name=(value)
         #     super(encrypt_value(value))
         #   end
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-
-          # def full_name
-          #   return @full_name_decrypted if instance_variable_defined?(:@full_name_decrypted)
-          #
-          #   encrypted_value = begin
-          #     if defined?(super)
-          #       super
-          #     elsif instance_variable_defined?(:@full_name)
-          #       @full_name
-          #     end
-          #   end
-          #   @full_name_decrypted = decrypt_value(encrypted_value)
-          # end
-          def #{attribute}
-            return @#{attribute}_decrypted if instance_variable_defined?(:@#{attribute}_decrypted)
-
-            encrypted_value = begin
-              if defined?(super)
-                super
-              elsif instance_variable_defined?(:@#{attribute})
-                @#{attribute}
-              end
-            end
-            @#{attribute}_decrypted = decrypt_#{method_suffix}(encrypted_value)
-          end
+        create_encrypted_getter(attribute, method_suffix)
+        create_encrypted_setter(attribute, method_suffix)
+      end
+
+      # def full_name
+      #   return @full_name_decrypted if instance_variable_defined?(:@full_name_decrypted)
+      #
+      #   encrypted_value = begin
+      #     if defined?(super)
+      #       super
+      #     elsif instance_variable_defined?(:@full_name)
+      #       @full_name
+      #     end
+      #   end
+      #   @full_name_decrypted = decrypt_value(encrypted_value)
+      # end
+      def create_encrypted_getter(attribute, method_suffix)
+        define_method(attribute) do
+          return instance_variable_get(:"@#{attribute}_decrypted") if instance_variable_defined?(:"@#{attribute}_decrypted")
+
+          encrypted_value = if defined?(super)
+                              super()
+                            elsif instance_variable_defined?(:"@#{attribute}")
+                              instance_variable_get(:"@#{attribute}")
+                            end
+
+          decrypted_value = send(:"decrypt_#{method_suffix}", encrypted_value)
+          instance_variable_set(:"@#{attribute}_decrypted", decrypted_value)
+        end
+      end
 
-          # def full_name=(value)
-          #   remove_instance_variable(:@full_name_decrypted) if instance_variable_defined?(:@full_name_decrypted)
-          #   encrypted_value = encrypt_value(value)
-          #
-          #   if defined?(super)
-          #     super(encrypted_value)
-          #   else
-          #     @full_name = encrypted_value
-          #   end
-          # end
-          def #{attribute}=(value)
-            remove_instance_variable(:@#{attribute}_decrypted) if instance_variable_defined?(:@#{attribute}_decrypted)
-            encrypted_value = encrypt_#{method_suffix}(value)
-
-            if defined?(super)
-              super(encrypted_value)
-            else
-              @#{attribute} = encrypted_value
-            end
+      # def full_name=(value)
+      #   remove_instance_variable(:@full_name_decrypted) if instance_variable_defined?(:@full_name_decrypted)
+      #   encrypted_value = encrypt_value(value)
+      #
+      #   if defined?(super)
+      #     super(encrypted_value)
+      #   else
+      #     @full_name = encrypted_value
+      #   end
+      # end
+      def create_encrypted_setter(attribute, method_suffix)
+        define_method("#{attribute}=") do |value|
+          remove_instance_variable(:"@#{attribute}_decrypted") if instance_variable_defined?(:"@#{attribute}_decrypted")
+
+          encrypted_value = send(:"encrypt_#{method_suffix}", value)
+
+          if defined?(super)
+            super(encrypted_value)
+          else
+            instance_variable_set(:"@#{attribute}", encrypted_value)
           end
-        RUBY
+        end
       end
     end
 

data/lib/decidim/reportable.rb

@@ -53,12 +53,8 @@ module Decidim
       # Public: The reported content url
       #
       # Returns String
-      def reported_content_url(options = {})
-        if hidden?
-          ResourceLocatorPresenter.new(self).index(options)
-        else
-          ResourceLocatorPresenter.new(self).url(options)
-        end
+      def reported_content_url
+        raise NotImplementedError
       end
 
       # Public: The collection of attribute names that are considered

data/lib/decidim/resourceable.rb

@@ -50,6 +50,22 @@ module Decidim
         scope.where(id: from).or(scope.where(id: to))
       end
 
+      def linked_resources_from(resource_name, link_name, component_published: true)
+        scope = sibling_scope(resource_name, component_published:)
+
+        scope
+          .joins(:resource_links_from)
+          .where(decidim_resource_links: { name: link_name, to_id: id, to_type: self.class.name })
+      end
+
+      def linked_resources_to(resource_name, link_name, component_published: true)
+        scope = sibling_scope(resource_name, component_published:)
+
+        scope
+          .joins(:resource_links_to)
+          .where(decidim_resource_links: { name: link_name, from_id: id, from_type: self.class.name })
+      end
+
       # Builds an ActiveRecord::Relation in order to load all the resources
       # that are in the same parent as this model.
       #

data/lib/decidim/seeds.rb

@@ -21,7 +21,7 @@ module Decidim
       user = Decidim::User.find_or_initialize_by(email:)
       user.update!(
         name: ::Faker::Name.name,
-        nickname: ::Faker::Twitter.unique.screen_name,
+        nickname: "#{::Faker::Twitter.unique.screen_name}-#{rand(10_000)}"[0...20],
         password: "decidim123456789",
         organization:,
         confirmed_at: Time.current,
@@ -38,18 +38,6 @@ module Decidim
       user
     end
 
-    def random_scope(participatory_space:)
-      if participatory_space.scope
-        scopes = participatory_space.scope.descendants
-        global = participatory_space.scope
-      else
-        scopes = participatory_space.organization.scopes
-        global = nil
-      end
-
-      ::Faker::Boolean.boolean(true_ratio: 0.5) ? global : scopes.sample
-    end
-
     def seeds_root = File.join(__dir__, "..", "..", "db", "seeds")
 
     def hero_image = create_blob!(seeds_file: "city.jpeg", filename: "hero_image.jpeg", content_type: "image/jpeg")
@@ -97,13 +85,23 @@ module Decidim
       )
     end
 
-    def create_category!(participatory_space:)
-      Decidim::Category.create!(
-        name: Decidim::Faker::Localized.sentence(word_count: 5),
-        description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-          Decidim::Faker::Localized.paragraph(sentence_count: 3)
-        end,
-        participatory_space:
+    def create_taxonomy!(name:, parent:)
+      Decidim::Taxonomy.create!(
+        name: Decidim::Faker::Localized.literal(name),
+        organization:,
+        parent:
+      )
+    end
+
+    def create_taxonomy_filter!(root_taxonomy:, taxonomies:, participatory_space_manifests: [])
+      Decidim::TaxonomyFilter.create!(
+        root_taxonomy:,
+        participatory_space_manifests:,
+        filter_items: taxonomies.map do |taxonomy_item|
+          Decidim::TaxonomyFilterItem.new(
+            taxonomy_item:
+          )
+        end
       )
     end
 

data/lib/decidim/settings_manifest.rb

@@ -70,6 +70,8 @@ module Decidim
             validates name, presence: true if attribute.required
             validates name, inclusion: { in: attribute.build_choices } if attribute.type == :enum
           end
+
+          SettingsManifest.add_integer_with_units_validation(self, name, attribute) if attribute.type == :integer_with_units
         end
       end
 
@@ -77,6 +79,20 @@ module Decidim
       @schema
     end
 
+    def self.add_integer_with_units_validation(schema, name, attribute)
+      schema.class_eval do
+        validate do
+          value = send(name)
+          value = [value["0"].to_i, value["1"].to_s] if value.is_a?(::Hash)
+
+          errors.add(name, :invalid) unless value.is_a?(::Array) &&
+                                            value.size == 2 &&
+                                            value[0].is_a?(Integer) &&
+                                            attribute.build_units.include?(value[1])
+        end
+      end
+    end
+
     def required_attributes_for_authorization
       attributes.select { |_, attribute| attribute.required_for_authorization? }
     end
@@ -91,6 +107,7 @@ module Decidim
       TYPES = {
         boolean: { klass: Boolean, default: false },
         integer: { klass: Integer, default: 0 },
+        integer_with_units: { klass: Decidim::Attributes::IntegerWithUnits, default: [5, "minutes"] },
         string: { klass: String, default: nil },
         float: { klass: Float, default: nil },
         text: { klass: String, default: nil },
@@ -98,7 +115,8 @@ module Decidim
         enum: { klass: String, default: nil },
         select: { klass: String, default: nil },
         scope: { klass: Integer, default: nil },
-        time: { klass: Decidim::Attributes::TimeWithZone, default: nil }
+        time: { klass: Decidim::Attributes::TimeWithZone, default: nil },
+        taxonomy_filters: { klass: Array, default: [] }
       }.freeze
 
       attribute :type, Symbol, default: :boolean
@@ -111,9 +129,20 @@ module Decidim
       attribute :required_for_authorization, Boolean, default: false
       attribute :readonly
       attribute :choices
+      attribute :units
       attribute :include_blank, Boolean, default: false
 
       validates :type, inclusion: { in: TYPES.keys }
+      validate :validate_integer_with_units_structure
+
+      def validate_integer_with_units_structure
+        return unless type == :integer_with_units
+
+        errors.add(:default, :invalid) unless default_value.is_a?(::Array) &&
+                                              default_value.size == 2 &&
+                                              default_value[0].is_a?(Integer) &&
+                                              build_units.include?(default_value[1])
+      end
 
       def type_class
         return Decidim::Attributes::RichText if type == :text && editor == true
@@ -129,6 +158,10 @@ module Decidim
         choices.try(:call) || choices
       end
 
+      def build_units
+        units.try(:call) || units
+      end
+
       def readonly?(context)
         readonly&.call(context)
       end

data/lib/decidim/soft_deletable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "paranoia"
+
+module Decidim
+  # This concern contains the logic related to soft deletion (trashing).
+  module SoftDeletable
+    extend ActiveSupport::Concern
+
+    included do
+      acts_as_paranoid
+
+      scope :deleted_at_desc, -> { order(deleted_at: :desc) }
+    end
+  end
+end

data/lib/decidim/taxonomizable.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the components needed when you want a model to have taxonomies.
+  #
+  # The including model needs to implement the following interface:
+  #
+  #  @abstract  method that gives an associated organization
+  #  @method organization
+  #    @return [Decidim::Organization]
+  #
+  module Taxonomizable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :taxonomizations, as: :taxonomizable, class_name: "Decidim::Taxonomization", dependent: :destroy
+      has_many :taxonomies, through: :taxonomizations
+
+      validate :no_root_taxonomies
+      validate :taxonomies_belong_to_organization
+
+      # finds taxonomizables belonging to a specific taxonomy
+      scope :with_taxonomy, ->(taxonomy_id) { includes(:taxonomies).references(:decidim_taxonomies).where("? = ANY(decidim_taxonomies.part_of)", taxonomy_id) }
+
+      # finds taxonomizables belonging to any of the taxonomies specified (or its children)
+      scope :with_taxonomies, lambda { |*taxonomy_ids|
+        conditions = ["? = ANY(part_of)"] * taxonomy_ids.count
+        taxonomies = Decidim::Taxonomy.where(conditions.join(" OR "), *taxonomy_ids.map(&:to_i))
+        includes(:taxonomies).joins(:taxonomies).where(decidim_taxonomies: { id: taxonomies })
+      }
+
+      # finds taxonomizables belonging to all groups of taxonomies specified, each group is an array of taxonomy ids that are ORed together
+      scope :with_any_taxonomies, lambda { |*taxonomy_groups|
+        return with_taxonomies(*taxonomy_groups) unless taxonomy_groups.first.is_a?(Array)
+
+        queries = []
+        taxonomy_groups.each do |root_id, taxonomy_ids|
+          taxonomy_ids = taxonomy_ids.flatten.compact_blank
+          next if taxonomy_ids.empty?
+
+          taxonomy_ids = [root_id] if taxonomy_ids.include?("all")
+
+          queries << with_taxonomies(*taxonomy_ids)
+        end
+        return self if queries.empty?
+        return queries.first if queries.count == 1
+
+        subquery = queries.map(&:arel).reduce do |memo, query|
+          Arel::Nodes::Intersect.new(memo, query)
+        end
+
+        @klass.from(Arel::Nodes::As.new(subquery, Arel.sql(@klass.arel_table.name)))
+      }
+
+      private
+
+      def no_root_taxonomies
+        return unless taxonomies.any?(&:root?)
+
+        errors.add(:taxonomies, :invalid)
+      end
+
+      def taxonomies_belong_to_organization
+        return if taxonomies.all? { |taxonomy| taxonomy.organization == organization }
+
+        errors.add(:taxonomies, :invalid)
+      end
+    end
+  end
+end

data/lib/decidim/translatable_attributes.rb

@@ -62,7 +62,7 @@ module Decidim
             final = super(value)
             return unless final # Do not set the `nil` values for the parent hash
 
-            final = value_type.serialize(final) if value_type && !attachment?(final)
+            final = value_type.serialize(final) if value_type
 
             public_send("#{name}=", field.merge(locale => final))
           end
@@ -127,9 +127,5 @@ module Decidim
       locale.to_s == try(:default_locale).to_s ||
         locale.to_s == try(:current_organization).try(:default_locale).to_s
     end
-
-    def attachment?(value)
-      value.is_a?(String) && value.include?(ActiveStorage.routes_prefix)
-    end
   end
 end

data/lib/decidim/view_model.rb

@@ -8,7 +8,6 @@ module Decidim
     include ActionView::Helpers::TranslationHelper
     include ::Cell::Translation
     include Decidim::ResourceHelper
-    include Decidim::ScopesHelper
     include ActionController::Helpers
     include Decidim::ActionAuthorization
     include Decidim::ActionAuthorizationHelper

data/lib/tasks/decidim_download_your_data_tasks.rake

@@ -64,7 +64,7 @@ namespace :decidim do
     input = $stdin.gets.chomp
     if input.casecmp("y").zero?
       puts %(  Continue...)
-      Decidim::User.where("newsletter_notifications_at < ?", Time.zone.parse("2018-05-25 00:00 +02:00")).find_each(&:newsletter_opt_in_notify)
+      Decidim::User.where(newsletter_notifications_at: ...Time.zone.parse("2018-05-25 00:00 +02:00")).find_each(&:newsletter_opt_in_notify)
     else
       puts %(  Execution cancelled...)
     end
@@ -76,9 +76,7 @@ namespace :decidim do
     attachments = ActiveStorage::Attachment.joins(:blob).where(
       name: "download_your_data_file",
       record_type: "Decidim::UserBaseEntity"
-    ).where(
-      "active_storage_blobs.created_at < ?", Decidim.download_your_data_expiry_time.ago
-    )
+    ).where(active_storage_blobs: { created_at: ...Decidim.download_your_data_expiry_time.ago })
     attachments.each do |attachment|
       delete_download_your_data_file attachment
     end

data/lib/tasks/decidim_procfile.rake

@@ -11,6 +11,12 @@ namespace :decidim do
         shakapacker: bin/shakapacker-dev-server
       RUBY
 
+      if defined?(Sidekiq)
+        actions :append_file, "Procfile.dev", <<~RUBY
+          sidekiq: bundle exec sidekiq -C config/sidekiq.yml
+        RUBY
+      end
+
       actions :create_file, "bin/dev", %(#!/usr/bin/env sh
 
 set -e

data/lib/tasks/decidim_tasks.rake

@@ -6,6 +6,7 @@ namespace :decidim do
     :choose_target_plugins,
     :"decidim:upgrade_app",
     :"railties:install:migrations",
+    :"decidim:upgrade:migrations",
     :"decidim:upgrade:webpacker",
     :"decidim_api:generate_docs"
   ]