decidim-core 0.26.4 → 0.27.0.rc1

data/lib/decidim/filterable_resource.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A concern that adds extra search helpers for the models for Ransack
+  # searches.
+  module FilterableResource
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def ransacker_i18n(field_name, attr_name = nil)
+        ransacker field_name do |parent|
+          Arel::Nodes::InfixOperation.new("->>", parent.table[attr_name || field_name], Arel::Nodes.build_quoted(I18n.locale.to_s))
+        end
+      end
+
+      def ransacker_i18n_multi(field_name, attrs)
+        raise "The second argument needs to be an array" unless attrs.is_a?(Array)
+        raise "You need to define at least one field in the second argument" if attrs.count < 1
+        return ransacker_i18n(field_name, attrs.first) if attrs.count < 2
+
+        # Create an i18n ransacker search for each of the provided attributes.
+        attrs.each { |attr_name| ransacker_i18n(attr_name) }
+
+        # Create the field name search alias for the attributes
+        ransacker_text_multi(field_name, attrs)
+      end
+
+      def ransacker_text_multi(field_name, attrs)
+        raise "The second argument needs to be an array" unless attrs.is_a?(Array)
+        raise "You need to define at least two fields in the second argument" if attrs.count < 1
+
+        # Alias the field_name as an OR query with all the provided fields.
+        ransack_alias field_name, attrs.join("_or_").to_sym
+      end
+
+      def scope_search_multi(scope_key, possible_scopes)
+        scope scope_key, lambda { |*value_keys|
+          search_values = value_keys.compact.compact_blank
+
+          conditions = possible_scopes.map do |scope|
+            search_values.member?(scope.to_s) ? try(scope) : nil
+          end.compact
+          return self unless conditions.any?
+
+          scoped_query = where(id: conditions.shift)
+          conditions.each do |condition|
+            scoped_query = scoped_query.or(where(id: condition))
+          end
+
+          scoped_query
+        }
+      end
+    end
+  end
+end

data/lib/decidim/fingerprint_calculator.rb

@@ -33,10 +33,8 @@ module Decidim
     def sort_hash(hash)
       return hash unless hash.is_a?(Hash)
 
-      Hash[
-        hash.map { |key, value| [key, sort_hash(value)] }
-            .sort_by { |key, _value| key }
-      ]
+      hash.map { |key, value| [key, sort_hash(value)] }
+          .sort_by { |key, _value| key }.to_h
     end
   end
 end

data/lib/decidim/form_builder.rb

@@ -67,7 +67,7 @@ module Decidim
       tabs_id = sanitize_tabs_selector(options[:tabs_id] || "#{object_name}-#{name}-tabs")
 
       label_tabs = content_tag(:div, class: "label--tabs") do
-        field_label = label_i18n(name, options[:label] || label_for(name))
+        field_label = label_i18n(name, options[:label] || label_for(name), required: options[:required])
 
         language_selector = "".html_safe
         language_selector = create_language_selector(locales, tabs_id, name) if options[:label] != false
@@ -94,6 +94,13 @@ module Decidim
       safe_join [label_tabs, tabs_content]
     end
 
+    def password_field(attribute, options = {})
+      field attribute, options do |opts|
+        opts[:autocomplete] ||= :off
+        method(__method__).super_method.super_method.call(attribute, opts)
+      end
+    end
+
     def translated_one_locale(type, name, locale, options = {})
       return hashtaggable_text_field(type, name, locale, options) if options.delete(:hashtaggable)
 
@@ -135,7 +142,7 @@ module Decidim
       tabs_id = sanitize_tabs_selector(options[:tabs_id] || "#{object_name}-#{name}-tabs")
 
       label_tabs = content_tag(:div, class: "label--tabs") do
-        field_label = label_i18n(name, options[:label] || label_for(name))
+        field_label = label_i18n(name, options[:label] || label_for(name), required: options[:required])
 
         tabs_panels = "".html_safe
         if options[:label] != false
@@ -380,14 +387,7 @@ module Decidim
     def datetime_field(attribute, options = {})
       value = object.send(attribute)
       data = { datepicker: "", timepicker: "" }
-      if value.present?
-        case value
-        when ActiveSupport::TimeWithZone
-          data[:startdate] = I18n.l(value, format: :decidim_short)
-        when Time, DateTime
-          data[:startdate] = I18n.l(value.in_time_zone(Time.zone), format: :decidim_short)
-        end
-      end
+      data[:startdate] = I18n.l(value, format: :decidim_short) if value.present? && value.is_a?(ActiveSupport::TimeWithZone)
       datepicker_format = ruby_format_to_datepicker(I18n.t("time.formats.decidim_short"))
       data[:"date-format"] = datepicker_format
 
@@ -400,97 +400,117 @@ module Decidim
       template.html_safe
     end
 
+    # Public: Generates a file upload field for Decidim::Attachment type of attachment.
+    # It is similar to upload method, but it changes some options so that attachment can
+    # have title and different upload validations.
+    #
+    # attribute    - The String name of the attribute to build the field.
+    # options      - A Hash with options to build the field. See upload method for
+    # more detailed information.
+    def attachment(attribute, options = {})
+      object_attachment = object.attachment.present?
+      record = object_attachment ? object.attachment : object
+      options = {
+        titled: true,
+        resource_class: "Decidim::Attachment",
+        show_current: false,
+        max_file_size: max_file_size(record, :file),
+        label: I18n.t("decidim.forms.upload.labels.add_attachment"),
+        button_edit_label: I18n.t("decidim.forms.upload.labels.edit_image"),
+        extension_allowlist: Decidim.organization_settings(Decidim::Attachment).upload_allowed_file_extensions
+      }.merge(options)
+
+      # Upload help uses extension allowlist from the options so we need to call this AFTER setting the defaults.
+      options[:help] = upload_help(record, attribute, options) if options[:help].blank?
+
+      upload(attribute, options)
+    end
+
     # Public: Generates a file upload field and sets the form as multipart.
     # If the file is an image it displays the default image if present or the current one.
-    # By default it also generates a checkbox to delete the file. This checkbox can
-    # be hidden if `options[:optional]` is passed as `false`.
+    # By default it also generates a button to replace the file.
     #
-    # attribute    - The String name of the attribute to buidl the field.
+    # attribute    - The String name of the attribute to build the field.
     # options      - A Hash with options to build the field.
+    #              * max_file_size: Maximum size for the file (If you really want to change max
+    #                 file size you should probably change it in validator).
+    #              * resouce_name: Name of the resource (e.g. user)
+    #              * resource_class: Attribute's resource class (e.g. Decidim::User)
+    #              * resouce_class: Class of the resource (e.g. user)
     #              * optional: Whether the file can be optional or not.
-    # rubocop:disable Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/PerceivedComplexity
+    #              * titled: Whether the file can have title or not.
+    #              * show_current: Whether the current file is displayed next to the button.
+    #              * help: Array of help messages which are displayed inside of the upload modal.
+    #              * dimensions_info: Hash about resize dimensions (e.g. {:medium=>{:processor=>:resize_to_fit, :dimensions=>[600, 160]}})
+    #                 produces 'Resized to fit 600 x 160 px.'
+    #              * extension_allowlist: Array of allowed file extensions (e.g. %w(jpeg jpg png))
+    #              * label: Label for the attribute
+    #              * button_label: Label for the button
+    #              * button_edit_label: Button label when file is already selected.
     def upload(attribute, options = {})
       self.multipart = true
-      options[:optional] = options[:optional].nil? ? true : options[:optional]
-      label_text = options[:label] || label_for(attribute)
-      alt_text = label_text
+      max_file_size = options[:max_file_size] || max_file_size(object, attribute)
+      button_label = options[:button_label] || choose_button_label(attribute)
+      help_messages = options[:help] || upload_help(object, attribute, options)
 
-      file = object.send attribute
-      template = ""
-      template += label(attribute, label_text + required_for_attribute(attribute))
-      template += upload_help(attribute, options)
-      template += @template.file_field @object_name, attribute
+      options = {
+        attribute: attribute,
+        resource_name: @object_name,
+        resource_class: options[:resource_class]&.to_s || resource_class(attribute),
+        optional: true,
+        titled: false,
+        show_current: true,
+        max_file_size: max_file_size,
+        help: help_messages,
+        label: label_for(attribute),
+        button_label: button_label,
+        button_edit_label: I18n.t("decidim.forms.upload.labels.replace")
+      }.merge(options)
 
-      template += extension_allowlist_help(options[:extension_allowlist]) if options[:extension_allowlist].present?
-      template += image_dimensions_help(options[:dimensions_info]) if options[:dimensions_info].present?
+      ::Decidim::ViewModel.cell(
+        "decidim/upload_modal",
+        self,
+        options
+      ).call
+    end
 
-      default_image_path = uploader_default_image_path(attribute)
-      file_path = file_attachment_path(file)
+    def max_file_size(record, attribute)
+      Decidim::FileValidatorHumanizer.new(record, attribute).max_file_size
+    end
 
-      if file_path.present? && file.attachment.image? || default_image_path.present?
-        if file_path.present?
-          template += @template.content_tag :label, I18n.t("current_image", scope: "decidim.forms")
-          template += @template.link_to @template.image_tag(file_path, alt: alt_text), file_path, target: "_blank", rel: "noopener"
+    def choose_button_label(attribute)
+      @choose_button_label ||= begin
+        if resource_class(attribute).attached_config[attribute].uploader <= Decidim::ImageUploader
+          I18n.t("decidim.forms.upload.labels.add_image")
         else
-          template += @template.content_tag :label, I18n.t("default_image", scope: "decidim.forms")
-          template += @template.link_to @template.image_tag(default_image_path, alt: alt_text), default_image_path, target: "_blank", rel: "noopener"
-        end
-      elsif file_path.present?
-        template += @template.label_tag I18n.t("current_file", scope: "decidim.forms")
-        template += @template.link_to file.filename, file_path, target: "_blank", rel: "noopener"
-      end
-
-      if file_path.present? && options[:optional]
-        template += content_tag :div, class: "field" do
-          safe_join([
-                      @template.check_box(@object_name, "remove_#{attribute}"),
-                      label("remove_#{attribute}", I18n.t("remove_this_file", scope: "decidim.forms"))
-                    ])
+          I18n.t("decidim.forms.upload.labels.add_file")
         end
+      rescue NoMethodError
+        I18n.t("decidim.forms.upload.labels.add_file")
       end
-
-      if object.errors[attribute].any?
-        template += content_tag :p, class: "is-invalid-label" do
-          safe_join object.errors[attribute], "<br/>".html_safe
-        end
-      end
-
-      template.html_safe
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/PerceivedComplexity
-
-    def upload_help(attribute, options = {})
-      humanizer = FileValidatorHumanizer.new(object, attribute)
 
-      help_scope = begin
-        if options[:help_i18n_scope].present?
-          options[:help_i18n_scope]
-        elsif humanizer.uploader.is_a?(Decidim::ImageUploader)
-          "decidim.forms.file_help.image"
-        else
-          "decidim.forms.file_help.file"
-        end
-      end
+    def upload_help(record, attribute, options = {})
+      humanizer = FileValidatorHumanizer.new(record, attribute)
 
-      help_messages = begin
-        if options[:help_i18n_messages].present?
-          Array(options[:help_i18n_messages])
-        else
-          %w(message_1 message_2)
-        end
-      end
+      help_scope = if options[:help_i18n_scope].present?
+                     options[:help_i18n_scope]
+                   elsif humanizer.uploader.is_a?(Decidim::ImageUploader)
+                     "decidim.forms.file_help.image"
+                   else
+                     "decidim.forms.file_help.file"
+                   end
 
-      content_tag(:div, class: "help-text") do
-        inner = "<p>#{I18n.t("explanation", scope: help_scope)}</p>".html_safe
-        inner + content_tag(:ul) do
-          messages = help_messages.each.map { |msg| I18n.t(msg, scope: help_scope) }
-          messages += humanizer.messages
+      help_messages = if options[:help_i18n_messages].present?
+                        Array(options[:help_i18n_messages])
+                      else
+                        %w(message_1 message_2)
+                      end
 
-          messages.map { |msg| content_tag(:li, msg) }.join("\n").html_safe
-        end.html_safe
-      end
+      help_messages = help_messages.each.map { |msg| I18n.t(msg, scope: help_scope) } + humanizer.messages
+      help_messages += extension_allowlist_help(options[:extension_allowlist]) if options[:extension_allowlist]
+      help_messages += image_dimensions_help(options[:dimensions_info]) if options[:dimensions_info]
+      help_messages
     end
 
     # Public: Returns the translated name for the given attribute.
@@ -531,15 +551,15 @@ module Decidim
     # inputs inside the label and to automatically inject validations
     # from the object.
     #
-    # attribute    - The String name of the attribute to buidl the field.
+    # attribute    - The String name of the attribute to build the field.
     # options      - A Hash with options to build the field.
     # html_options - An optional Hash with options to pass to the html element.
     #
     # Returns a String
     def field(attribute, options, html_options = nil, &block)
       label = options.delete(:label)
-      label_options = options.delete(:label_options)
-      custom_label(attribute, label, label_options) do
+      label_options = options.delete(:label_options) || {}
+      custom_label(attribute, label, { required: options[:required] }.merge(label_options)) do
         field_with_validations(attribute, options, html_options, &block)
       end
     end
@@ -654,7 +674,7 @@ module Decidim
     def find_validator(attribute, klass)
       return unless object.respond_to?(:_validators)
 
-      object._validators[attribute.to_sym].find { |validator| validator.class == klass }
+      object._validators[attribute.to_sym].find { |validator| validator.instance_of?(klass) }
     end
 
     # Private: Override method from FoundationRailsHelper to render the text of the
@@ -670,8 +690,16 @@ module Decidim
     def custom_label(attribute, text, options, field_before_label: false, show_required: true)
       return block_given? ? yield.html_safe : "".html_safe if text == false
 
+      required = options.is_a?(Hash) && options.delete(:required)
       text = default_label_text(object, attribute) if text.nil? || text == true
-      text += required_for_attribute(attribute) if show_required
+      if show_required
+        text +=
+          if required
+            required_indicator
+          else
+            required_for_attribute(attribute)
+          end
+      end
 
       text = if field_before_label && block_given?
                safe_join([yield, text.html_safe])
@@ -753,45 +781,36 @@ module Decidim
         options[:class] ||= ""
         options[:class] += " is-invalid-label"
       end
-      text += required_for_attribute(attribute)
+      text +=
+        if options.delete(:required)
+          required_indicator
+        else
+          required_for_attribute(attribute)
+        end
 
       label(attribute, (text || "").html_safe, options)
     end
 
-    # Private: Returns default url for attribute when uploader is an
-    # image and has defined a default url
-    def uploader_default_image_path(attribute)
-      uploader = FileValidatorHumanizer.new(object, attribute).uploader
-      return if uploader.blank?
-      return unless uploader.is_a?(Decidim::ImageUploader)
-
-      uploader.try(:default_url)
-    end
-
-    # Private: Returns blob path when file is attached
-    def file_attachment_path(file)
-      return unless file && file.try(:attached?)
+    def required_for_attribute(attribute)
+      return required_indicator if attribute_required?(attribute)
 
-      Rails.application.routes.url_helpers.rails_blob_url(file.blob, only_path: true)
+      "".html_safe
     end
 
-    def required_for_attribute(attribute)
-      if attribute_required?(attribute)
-        visible_title = content_tag(:span, "*", "aria-hidden": true)
-        screenreader_title = content_tag(
-          :span,
-          I18n.t("required", scope: "forms"),
-          class: "show-for-sr"
-        )
-        return content_tag(
-          :span,
-          visible_title + screenreader_title,
-          title: I18n.t("required", scope: "forms"),
-          data: { tooltip: true, disable_hover: false, keep_on_hover: true },
-          class: "label-required"
-        ).html_safe
-      end
-      "".html_safe
+    def required_indicator
+      visible_title = content_tag(:span, "*", "aria-hidden": true)
+      screenreader_title = content_tag(
+        :span,
+        I18n.t("required", scope: "forms"),
+        class: "show-for-sr"
+      )
+      content_tag(
+        :span,
+        visible_title + screenreader_title,
+        title: I18n.t("required", scope: "forms"),
+        data: { tooltip: true, disable_hover: false, keep_on_hover: true },
+        class: "label-required"
+      ).html_safe
     end
 
     # Private: Returns an array of scopes related to object attribute
@@ -825,28 +844,17 @@ module Decidim
     end
 
     def extension_allowlist_help(extension_allowlist)
-      content_tag :p, class: "extensions-help help-text" do
-        safe_join([
-                    content_tag(:span, I18n.t("extension_allowlist", scope: "decidim.forms.files")),
-                    " ",
-                    safe_join(extension_allowlist.map { |ext| content_tag(:b, ext) }, ", ")
-                  ])
-      end
+      ["#{I18n.t("extension_allowlist", scope: "decidim.forms.files")} #{extension_allowlist.map { |ext| ext }.join(", ")}"]
     end
 
     def image_dimensions_help(dimensions_info)
-      content_tag :p, class: "image-dimensions-help help-text" do
-        safe_join([
-                    content_tag(:span, I18n.t("dimensions_info", scope: "decidim.forms.images")),
-                    " ",
-                    content_tag(:span) do
-                      safe_join(dimensions_info.map do |_version, info|
-                        processor = @template.content_tag(:span, I18n.t("processors.#{info[:processor]}", scope: "decidim.forms.images"))
-                        dimensions = @template.content_tag(:b, I18n.t("dimensions", scope: "decidim.forms.images", width: info[:dimensions].first, height: info[:dimensions].last))
-                        safe_join([processor, "  ", dimensions, ". ".html_safe])
-                      end)
-                    end
-                  ])
+      dimensions_info.map do |_version, info|
+        dimensions = I18n.t("dimensions", scope: "decidim.forms.images", width: info[:dimensions].first, height: info[:dimensions].last)
+        I18n.t(
+          "processors.#{info[:processor]}",
+          scope: "decidim.forms.images",
+          dimensions: dimensions
+        ).html_safe
       end
     end
 
@@ -918,5 +926,18 @@ module Decidim
         drag_and_drop_help_text: I18n.t("drag_and_drop_help", scope: "decidim.editor_images")
       }
     end
+
+    # Private: Determines the correct resource class for validators from the
+    # object or its PassthruValidator.
+    def resource_class(attribute)
+      if object._validators[attribute].is_a?(Array) && object._validators[attribute].size.positive?
+        passthru = object._validators[attribute].find { |v| v.is_a?(PassthruValidator) }
+        return passthru.options[:to] if passthru && passthru.options[:to].present?
+      end
+      klass = object.send(attribute)
+      return object.send(attribute).record.class if klass.respond_to?(:record) && klass.record.present?
+
+      object.class
+    end
   end
 end

data/lib/decidim/gamification/badge.rb

@@ -5,7 +5,7 @@ module Decidim
     # This class represents an abstract badge. Instances of this class can define
     # different badge types with different rules such as gaining new levels, etc.
     class Badge
-      include Virtus.model
+      include Decidim::AttributeObject::Model
       include ActiveModel::Validations
 
       # The name of the badge.
@@ -14,7 +14,7 @@ module Decidim
       # An array of scores needed to reach a new level. For example, the array
       # [1, 5, 10] represents 1 point to get to Level 1, 5 points to get to level 2,
       # 10 points to get to level 3.
-      attribute :levels, Array, default: []
+      attribute :levels, Array[Integer], default: []
 
       # An array of types for which this badge is valid for.
       attribute :valid_for, Array[Symbol], default: [:user]
@@ -27,7 +27,6 @@ module Decidim
       attribute :reset, Proc
 
       validates :name, :levels, presence: true
-      validates :levels, empty: false
 
       validate do
         errors.add(:levels, "level thresholds should be ordered") if levels.sort != levels

data/lib/decidim/gamification/badge_scorer.rb

@@ -74,6 +74,7 @@ module Decidim
       private
 
       class NegativeScoreException < StandardError; end
+
       class InvalidAmountException < StandardError; end
 
       def with_level_tracking

data/lib/decidim/has_area.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the components needed when you want a model to belong to an
+  # area.
+  module HasArea
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :area,
+                 foreign_key: "decidim_area_id",
+                 class_name: "Decidim::Area",
+                 optional: true
+
+      scope :with_area, ->(area_id) { where(decidim_area_id: area_id) }
+
+      scope :with_any_area, lambda { |*original_area_ids|
+        area_ids = original_area_ids.map { |id| id.to_s.split("_") }.flatten.uniq
+        return self if area_ids.include?("all")
+
+        where(decidim_area_id: area_ids)
+      }
+    end
+  end
+end

data/lib/decidim/has_attachments.rb

@@ -26,14 +26,14 @@ module Decidim
       #
       # Returns an Array<Attachment>
       def photos
-        @photos ||= attachments.select(&:photo?)
+        @photos ||= attachments.with_attached_file.order(:weight).select(&:photo?)
       end
 
       # All the attachments that are documents for this model.
       #
       # Returns an Array<Attachment>
       def documents
-        @documents ||= attachments.includes(:attachment_collection).select(&:document?)
+        @documents ||= attachments.with_attached_file.order(:weight).includes(:attachment_collection).select(&:document?)
       end
 
       # All the attachments that are documents for this model that has a collection.

data/lib/decidim/has_category.rb

@@ -11,6 +11,42 @@ module Decidim
       has_one :categorization, as: :categorizable
       has_one :category, through: :categorization
 
+      scope :with_category, lambda { |category|
+        return includes(:category).where(decidim_categories: { id: nil }) if category == "without" || category.nil?
+
+        includes(:category).where(decidim_categories: { id: category }).or(
+          includes(:category).where(decidim_categories: { parent_id: category })
+        )
+      }
+
+      scope :with_any_category, lambda { |*categories|
+        return self if categories.include?("all")
+
+        parent_ids = categories.without("without")
+        cat_ids = parent_ids.dup
+        cat_ids.prepend(nil) if categories.include?("without")
+
+        subquery = includes(:category).where(decidim_categories: { id: cat_ids })
+        return subquery if parent_ids.none?
+
+        subquery.or(
+          includes(:category).where(decidim_categories: { parent_id: parent_ids })
+        )
+      }
+
+      scope :with_any_global_category, lambda { |*categories|
+        return self if categories.include?("all")
+
+        cat_ids = categories.without("without")
+
+        additional_ids = cat_ids.grep(/Decidim__/)
+        additional_ids = additional_ids.map { |a| a.gsub("__", "::").gsub(/(\d+)/, '.\1').split(".") }
+        additional_ids = additional_ids.map { |v| v.first.safe_constantize.send(:find, v.last.to_i).category_ids }
+        additional_ids = additional_ids.flatten
+
+        with_any_category(*(categories + additional_ids))
+      }
+
       validate :category_belongs_to_organization
 
       def previous_category

data/lib/decidim/has_resource_permission.rb

@@ -14,6 +14,8 @@ module Decidim
 
       delegate :resource_manifest, :resource_key, to: :class
 
+      alias_method :manifest, :resource_manifest
+
       # Public: Whether the permissions for this object actions can be set at resource level.
       def allow_resource_permissions?
         false

data/lib/decidim/importers/import_manifest.rb

@@ -6,7 +6,7 @@ module Decidim
     # specify it's own creator, which will be responsible for producing (creating)
     # and finishing (saving) the imported resource.
     class ImportManifest
-      include Virtus.model
+      include Decidim::AttributeObject::Model
 
       attr_reader :name, :manifest
 
@@ -24,7 +24,7 @@ module Decidim
         super()
         @name = name.to_sym
         @manifest = manifest
-        @messages = Messages.new
+        @messages = ImportManifestMessages.new
       end
 
       # Public: Sets the creator when an argument is provided, returns the
@@ -112,25 +112,7 @@ module Decidim
         @example.present?
       end
 
-      class Messages
-        def initialize
-          @store = {}
-        end
-
-        def has?(key)
-          @store.has_key?(key)
-        end
-
-        def set(key, &block)
-          raise ArgumentError, "You need to provide a block for the message." unless block_given?
-
-          @store[key] = block
-        end
-
-        def render(key, context = nil, **extra)
-          context.instance_exec(**extra, &@store[key]) if @store[key]
-        end
-      end
+      class ImportManifestMessages < Decidim::ManifestMessages; end
     end
   end
 end