decidim-core 0.24.3 → 0.25.0.rc1

data/app/presenters/decidim/menu_presenter.rb

@@ -13,7 +13,6 @@ module Decidim
     def initialize(name, view, options = {})
       @name = name
       @view = view
-
       @options = options
     end
 
@@ -29,7 +28,7 @@ module Decidim
     end
 
     def render
-      content_tag :nav, class: "main-nav" do
+      content_tag :nav, class: "main-nav", "aria-label": @options.fetch(:label, nil) do
         render_menu
       end
     end
@@ -37,7 +36,7 @@ module Decidim
     protected
 
     def render_menu(&block)
-      content_tag :ul do
+      content_tag :ul, @options.fetch(:container_options, {}) do
         elements = block_given? ? [block.call(@view)] : []
         safe_join(elements + menu_items)
       end

data/app/presenters/decidim/nil_presenter.rb

@@ -13,7 +13,7 @@ module Decidim
     end
 
     def avatar_url
-      Decidim::AvatarUploader.new.default_url
+      Decidim::AvatarUploader.new(Decidim::User.new, :avatar).default_url
     end
 
     def respond_to_missing?

data/app/presenters/decidim/official_author_presenter.rb

@@ -18,7 +18,7 @@ module Decidim
     end
 
     def avatar_url
-      ActionController::Base.helpers.asset_path("decidim/default-avatar.svg")
+      ActionController::Base.helpers.asset_pack_path("media/images/default-avatar.svg")
     end
 
     def deleted?

data/app/presenters/decidim/stats_presenter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A general presenter to render statistics in participatory spaces.
+  class StatsPresenter < Rectify::Presenter
+    def comments_stats(name)
+      comments = Decidim.component_manifests.map do |component_manifest|
+        component_manifest.stats.only([:comments_count])
+                          .filter({ tag: :comments })
+                          .with_context(published_components)
+                          .map { |_name, value| value }.sum
+      end
+      comments_count = comments.inject(0, :+) { |sum, value| sum + value }
+      [[name, :comments_count, comments_count]]
+    end
+
+    def statistics(grouped_stats)
+      statistics = []
+      grouped_stats.each do |_manifest_name, stats|
+        stats.each_with_index.each do |stat, _index|
+          stat.each_with_index.map do |_item, subindex|
+            next unless (subindex % 3).zero?
+            next if stat[subindex + 2].zero?
+
+            statistics << { stat_title: stat[subindex + 1], stat_number: stat[subindex + 2] }
+          end
+        end
+      end
+      statistics
+    end
+  end
+end

data/app/presenters/decidim/user_group_presenter.rb

@@ -15,8 +15,6 @@ module Decidim
       "verified-badge"
     end
 
-    delegate :url, to: :avatar, prefix: true
-
     def can_be_contacted?
       true
     end

data/app/presenters/decidim/user_presenter.rb

@@ -22,14 +22,26 @@ module Decidim
       "verified-badge"
     end
 
-    delegate :url, to: :avatar, prefix: true
-
     def profile_url
       return "" if respond_to?(:deleted?) && deleted?
 
       decidim.profile_url(__getobj__.nickname, host: __getobj__.organization.host)
     end
 
+    def avatar
+      attached_uploader(:avatar)
+    end
+
+    def avatar_url(variant = nil)
+      return avatar.default_url unless avatar.attached?
+
+      avatar.path(variant: variant)
+    end
+
+    def default_avatar_url
+      attached_uploader.default_url
+    end
+
     def profile_path
       return "" if respond_to?(:deleted?) && deleted?
 

data/app/queries/decidim/metric_manage.rb

@@ -28,7 +28,7 @@ module Decidim
     def save
       return @registry if @registry
 
-      return if cumulative.zero?
+      return if cumulative.zero? && %w(blocked_users reported_users user_reports).exclude?(@metric_name)
 
       @registry = Decidim::Metric.find_or_initialize_by(day: @day.to_s, metric_type: @metric_name, organization: @organization)
       @registry.assign_attributes(cumulative: cumulative, quantity: quantity)
@@ -74,8 +74,8 @@ module Decidim
     end
 
     # Returns the ids for all the published components in the given +spaces+.
-    def visible_component_ids_from_spaces(spaces)
-      Decidim::Component.where(participatory_space: spaces).published.pluck(:id)
+    def visible_components_from_spaces(spaces)
+      Decidim::Component.where(participatory_space: spaces).published
     end
   end
 end

data/app/queries/decidim/similar_emendations.rb

@@ -42,7 +42,7 @@ module Decidim
     attr_reader :component, :emendation, :amender
 
     def amendable_module
-      emendation.class.parent
+      emendation.class.module_parent
     end
 
     def title_similarity

data/app/queries/decidim/stats_users_count.rb

@@ -15,10 +15,9 @@ module Decidim
     end
 
     def query
-      users = Decidim::User.where(organization: @organization)
+      users = Decidim::User.where(organization: @organization).not_deleted.not_blocked.confirmed
       users = users.where("created_at >= ?", @start_at) if @start_at.present?
       users = users.where("created_at <= ?", @end_at) if @end_at.present?
-      users = users.where.not(confirmed_at: nil)
       users.count
     end
   end

data/app/serializers/decidim/exporters/participatory_space_components_serializer.rb

@@ -36,10 +36,11 @@ module Decidim
       private
 
       attr_reader :participatory_space
+      alias resource participatory_space
 
       def serialize_component_specific_data(component)
         specific_serializer = component.manifest.specific_data_serializer_class.new(component)
-        specific_serializer.serialize
+        specific_serializer.run
       end
     end
   end

data/app/serializers/decidim/exporters/serializer.rb

@@ -19,12 +19,41 @@ module Decidim
         @resource = resource
       end
 
+      # Publishes a serialize event and returns serialized hash by default (can be customized at the event).
+      def run
+        finalize(serialize)
+      end
+
       # Public: Returns a serialized view of the provided resource.
       #
       # Returns a nested Hash with the fields.
       def serialize
         @resource.to_h
       end
+
+      # Public: Publishes notification (event) so that subscribers can modify serialized data.
+      #
+      # serialized_data - Hash with the serialized data for this resource.
+      #
+      # Returns a nested Hash with the fields by default.
+      def finalize(serialized_data)
+        event_data = {
+          resource: resource,
+          serialized_data: serialized_data
+        }
+        ActiveSupport::Notifications.publish(event_name, event_data)
+
+        event_data[:serialized_data]
+      end
+
+      # Public: Converts serializers class name to event name.
+      #
+      # For example: Decidim::Budgets::ProjectSerializer -> "decidim.serialize.budgets.project_serializer"
+      #
+      # Returns String
+      def event_name
+        ActiveSupport::Inflector.underscore(self.class.to_s).sub("/", ".serialize.").gsub("/", ".")
+      end
     end
   end
 end

data/app/services/decidim/action_authorizer.rb

@@ -37,11 +37,12 @@ module Decidim
     attr_reader :user, :component, :resource, :action
 
     def authorization_handlers
-      if permission&.has_key?("authorization_handler_name")
+      available_authorizations = component.organization.available_authorizations
+      if permission&.has_key?("authorization_handler_name") && available_authorizations.include?(permission["authorization_handler_name"])
         options = permission["options"]
         { permission["authorization_handler_name"] => options.present? ? { "options" => options } : {} }
       else
-        permission&.fetch("authorization_handlers", {})
+        permission&.fetch("authorization_handlers", {})&.slice(*available_authorizations)
       end
     end
 

data/app/services/decidim/activity_search.rb

@@ -29,7 +29,8 @@ module Decidim
       query = query.where(user: options[:user]) if options[:user]
       query = query.where(resource_type: options[:resource_name]) if options[:resource_name]
 
-      filter_follows(query)
+      query = filter_follows(query)
+      filter_hidden(query)
     end
 
     # Overwrites the default Searchlight run method since we want to return
@@ -120,6 +121,50 @@ module Decidim
       query.where(chained_conditions)
     end
 
+    def filter_hidden(query)
+      # Filter out the items that have been moderated.
+      query = query.joins(
+        <<~SQL.squish
+          LEFT JOIN decidim_moderations
+            ON decidim_moderations.decidim_reportable_type = decidim_action_logs.resource_type
+            AND decidim_moderations.decidim_reportable_id = decidim_action_logs.resource_id
+            AND decidim_moderations.hidden_at IS NOT NULL
+        SQL
+      ).where(decidim_moderations: { id: nil })
+
+      # Filter out the private space items that should not be visible for the
+      # current user.
+      current_user_id = options.fetch(:current_user, nil)&.id.to_i
+      Decidim.participatory_space_manifests.map do |manifest|
+        klass = manifest.model_class_name.constantize
+        next unless klass.include?(Decidim::HasPrivateUsers)
+
+        table = klass.table_name
+        query = query.joins(
+          Arel.sql(
+            <<~SQL.squish
+              LEFT JOIN #{table}
+                ON decidim_action_logs.participatory_space_type = '#{manifest.model_class_name}'
+                AND #{table}.id = decidim_action_logs.participatory_space_id
+              LEFT JOIN decidim_participatory_space_private_users AS #{manifest.name}_private_users
+                ON #{manifest.name}_private_users.privatable_to_type = '#{manifest.model_class_name}'
+                AND #{table}.id = #{manifest.name}_private_users.privatable_to_id
+            SQL
+          )
+        ).where(
+          Arel.sql(
+            <<~SQL.squish
+              #{table}.id IS NULL OR
+              #{table}.private_space = 'f' OR
+              #{manifest.name}_private_users.decidim_user_id = #{current_user_id}
+            SQL
+          )
+        )
+      end
+
+      query
+    end
+
     def followed_users_conditions(follows)
       followed_users = follows.where(decidim_followable_type: "Decidim::UserBaseEntity")
       return [] if followed_users.empty?

data/app/services/decidim/data_portability_exporter.rb

@@ -2,7 +2,7 @@
 
 require "seven_zip_ruby"
 require "zip"
-require_relative "zip_stream/zip_stream_writer"
+require_relative "zip_stream/writer"
 
 module Decidim
   # Public: Generates a 7z(seven zip) file with data files ready to be persisted

data/app/services/decidim/zip_stream/writer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ZipStream
+    module Writer
+      def add_user_data_to_zip_stream(out, user_data)
+        user_data.each do |element|
+          filename_file = element.last.filename(element.first.parameterize)
+
+          out.put_next_entry(filename_file)
+          if element.last.read.presence
+            out.write element.last.read
+          else
+            out.write "No data"
+          end
+        end
+      end
+
+      def add_attachments_to_zip_stream(out, export_attachments)
+        export_attachments.each do |attachment_block|
+          next if attachment_block.last.nil?
+
+          folder_name = attachment_block.first.parameterize
+          attachment_block.last.each do |attachment|
+            next unless attachment.attached?
+
+            blobs = attachment.is_a?(ActiveStorage::Attached::One) ? [attachment.blob] : attachment.blobs
+            blobs.each do |blob|
+              out.put_next_entry("#{folder_name}/#{blob.filename}")
+              blob.open do |f|
+                out << f.read
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/uploaders/decidim/application_uploader.rb

@@ -4,10 +4,15 @@ module Decidim
   # This class deals with uploading files to Decidim. It is intended to just
   # hold the uploads configuration, so you should inherit from this class and
   # then tweak any configuration you need.
-  class ApplicationUploader < CarrierWave::Uploader::Base
-    include CarrierWave::MiniMagick
+  class ApplicationUploader
+    def initialize(model, mounted_as)
+      @model = model
+      @mounted_as = mounted_as
+    end
+
+    attr_reader :validable_dimensions, :model, :mounted_as, :content_type_allowlist, :content_type_denylist
 
-    process :validate_inside_organization
+    delegate :variants, to: :class
 
     # Override the directory where uploaded files will be stored.
     # This is a sensible default for uploaders that are meant to be mounted:
@@ -19,38 +24,74 @@ module Decidim
       default_path
     end
 
-    # When the uploaded content can't be processed, we want to make sure
-    # not to expose internal tools errors to the users.
-    # We'll show a generic error instead.
-    def manipulate!
-      super
-    rescue CarrierWave::ProcessingError => e
-      Rails.logger.error(e)
-      raise CarrierWave::ProcessingError, I18n.t("carrierwave.errors.general")
+    def variant(key)
+      if key && variants[key].present?
+        model.send(mounted_as).variant(variants[key])
+      else
+        model.send(mounted_as)
+      end
+    end
+
+    def attached?
+      model.send(mounted_as).attached?
+    end
+
+    def url(options = {})
+      representable = model.send(mounted_as)
+      return super unless representable.is_a? ActiveStorage::Attached
+
+      variant_url(options.delete(:variant), **options)
+    end
+
+    def variant_url(key, options = {})
+      return unless attached?
+
+      representable = variant(key)
+      if representable.is_a? ActiveStorage::Attached
+        Rails.application.routes.url_helpers.rails_blob_url(representable.blob, **protocol_option.merge(options))
+      else
+        Rails.application.routes.url_helpers.rails_representation_url(representable, **protocol_option.merge(options))
+      end
+    end
+
+    def path(options = {})
+      representable = model.send(mounted_as)
+      return super() unless representable.is_a? ActiveStorage::Attached
+
+      variant_path(options.delete(:variant), **options)
+    end
+
+    def variant_path(key, options = {})
+      variant_url(key, **options.merge(only_path: true))
     end
 
-    # As of Carrierwave 2.0 fog_provider method has been deprecated, and is throwing RuntimeError
-    # RuntimeError: Carrierwave fog_provider not supported: DEPRECATION WARNING: #fog_provider is deprecated...
-    # We are attempting to fetch the provider from credentials, if not we consider to be file
-    def provider
-      fog_credentials.fetch(:provider, "file").downcase
+    def remote_url=(url)
+      uri = URI.parse(url)
+      filename = File.basename(uri.path)
+      file = URI.open(url)
+      model.send(mounted_as).attach(io: file, filename: filename)
+    rescue URI::InvalidURIError
+      model.errors.add(mounted_as, :invalid)
     end
 
-    # We overwrite the downloader to be able to fetch some elements from URL.
-    def downloader
-      Decidim::Downloader
+    def protocol_option
+      return {} unless Rails.application.config.force_ssl
+
+      { protocol: "https" }
     end
 
-    protected
+    class << self
+      # Each class inherits variants from parents and can define their own
+      # variants with the set_variants class method
+      def variants
+        @variants ||= {}
+      end
 
-    # Validates that the associated model is always within an organization in
-    # order to pass the organization specific settings for the file upload
-    # checks (e.g. file extension, mime type, etc.).
-    def validate_inside_organization
-      return if model.is_a?(Decidim::Organization)
-      return if model.respond_to?(:organization) && model.organization.is_a?(Decidim::Organization)
+      def set_variants
+        return unless block_given?
 
-      raise CarrierWave::IntegrityError, I18n.t("carrierwave.errors.not_inside_organization")
+        variants.merge!(yield)
+      end
     end
   end
 end