decidim-core 0.29.2 → 0.30.0.rc2

data/lib/decidim/download_your_data_serializers.rb

@@ -19,5 +19,24 @@ module Decidim
         Decidim.participatory_space_manifests.map(&:data_portable_entities).flatten |
         (Decidim::Comments.data_portable_entities.flatten if defined?(Decidim::Comments))
     end
+
+    def self.help_definitions_for(user)
+      export_format = "CSV"
+      help_definition = {}
+
+      data_entities.each do |object|
+        klass = Object.const_get(object)
+        exporter = Exporters.find_exporter(export_format).new(klass.user_collection(user), klass.export_serializer)
+        entity = klass.model_name.route_key
+        headers = exporter.headers_without_locales
+        help_definition[entity] = {}
+
+        headers.each do |header|
+          help_definition[entity][header] = I18n.t("decidim.open_data.help.#{entity}.#{header}", default: I18n.t("decidim.download_your_data.help.#{entity}.#{header}"))
+        end
+      end
+
+      help_definition
+    end
   end
 end

data/lib/decidim/exporters/csv.rb

@@ -30,6 +30,12 @@ module Decidim
         @headers ||= processed_collection.inject([]) { |keys, resource| keys | resource.keys }
       end
 
+      def headers_without_locales
+        return [] if collection.empty?
+
+        @headers_without_locales ||= @serializer.new(collection.first).run.keys
+      end
+
       protected
 
       def custom_sanitize(value)

data/lib/decidim/exporters/export_manifest.rb

@@ -14,6 +14,12 @@ module Decidim
 
       # A setting to choose if the collection exported by this manifest should
       # be included in the open data export available for all users.
+      #
+      # Optionally, you can define a specific serializer using the `open_data_serializer` method
+      # to have a granular control on which fields are added to the open data export.
+      # This is specially useful for ParticipatorySpaces, as the serializer is used for the
+      # export/import feature, and we do not want to publish some of the data available there
+      # (as the components settings).
       attribute :include_in_open_data, Boolean, default: false
 
       attr_reader :name, :manifest
@@ -73,6 +79,14 @@ module Decidim
         @serializer ||= serializer || Decidim::Exporters::Serializer
       end
 
+      # Public: Sets the open data serializer when an argument is provided, returns the
+      # stored serializer otherwise.
+      #
+      # See more information in the `serializer` method.
+      def open_data_serializer(serializer = nil)
+        @open_data_serializer ||= serializer || nil
+      end
+
       DEFAULT_FORMATS = %w(CSV JSON Excel).freeze
 
       # Public: Sets the available formats if an argument is provided and

data/lib/decidim/exporters/pdf.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "wicked_pdf"
+require "hexapdf"
 
 module Decidim
   module Exporters
@@ -10,47 +10,51 @@ module Decidim
     # the desired template, layout and orientation.
     #
     class PDF < Exporter
+      include Decidim::TranslatableAttributes
+      include Decidim::SanitizeHelper
+
       # Public: Exports a PDF version of the collection by rendering
       # the template into html and then converting it to PDF.
       #
       # Returns an ExportData instance.
       def export
-        html = controller.render_to_string(
-          template:,
-          layout:,
-          locals:
-        )
+        composer.styles(**styles)
 
-        document = WickedPdf.new.pdf_from_string(html, orientation:)
+        add_data!
 
-        ExportData.new(document, "pdf")
+        ExportData.new(composer.write_to_string, "pdf")
       end
 
-      # may be overwritten if needed
-      def orientation
-        "Portrait"
+      protected
+
+      delegate :document, to: :composer
+      delegate :layout, to: :document
+
+      def font
+        @font ||= load_font("source-sans-pro-v21-cyrillic_cyrillic-ext_greek_greek-ext_latin_latin-ext_vietnamese-regular.ttf")
       end
 
-      # implementing classes should return a valid ERB path here
-      def template
-        raise NotImplementedError
+      def bold_font
+        @bold_font ||= load_font("source-sans-pro-v21-cyrillic_cyrillic-ext_greek_greek-ext_latin_latin-ext_vietnamese-700.ttf")
       end
 
-      # implementing classes should return a valid ERB path here
-      def layout
-        raise NotImplementedError
+      def load_font(path)
+        document.fonts.add(Decidim::Core::Engine.root.join("app/packs/fonts/decidim/").join(path))
       end
 
-      # This method may be overwritten if the template needs more local variables
-      def locals
-        { collection: }
+      def composer
+        @composer ||= ::HexaPDF::Composer.new(page_size:, page_orientation:)
       end
 
-      protected
+      def page_size = :A4
 
-      def controller
+      def page_orientation = :portrait
+
+      def add_data!
         raise NotImplementedError
       end
+
+      def styles = {}
     end
   end
 end

data/lib/decidim/filter_form_builder.rb

@@ -13,9 +13,8 @@ module Decidim
     #        if represented by an array containing a value and a name or a check_boxes_tree
     #        struct as defined in Decidim::CheckBoxesTreeHelper for more complex situations
     #        which require nested options.
-    # @param label_scope [String] The scope used to translate the title of the section.
-    # @param id [String] The id of the section. It is also used to get the translation of
-    #        the section title.
+    # @param label [String] The title of the section.
+    # @param id [String] The id of the section.
     # @param options [Hash] Additional options. Except :type, the rest of options are passed
     #        to the partial used to generate the section.
     # @option options [Symbol, String] :type The type of selector to use with the collection.
@@ -23,7 +22,7 @@ module Decidim
     #         tree struct is passed. The default selector for arrays is radio_buttons.
     #
     # @return [ActionView::OutputBuffer] the HTML of the generated collection filter.
-    def collection_filter(method:, collection:, label_scope:, id:, **options)
+    def collection_filter(method:, collection:, label:, id:, **options)
       type = options.delete(:type) || default_form_type_for_collection(collection)
 
       case type.to_s
@@ -31,29 +30,27 @@ module Decidim
         options.merge!(builder_type: type.to_s.pluralize)
         type = "collection"
       when "check_boxes_tree"
-        options.merge!(check_boxes_tree_id: check_boxes_tree_id(method))
+        options.merge!(check_boxes_tree_id: check_boxes_tree_id(method.to_s.gsub(/\[|\]/, "_"), id))
       end
 
       @template.render(
         "decidim/shared/filters/#{type}",
-        **options.merge(
-          method:,
-          collection:,
-          label_scope:,
-          id:,
-          form: self
-        )
+        **options, method:,
+                   collection:,
+                   label:,
+                   id:,
+                   form: self
       )
     end
 
     def dropdown_label(item, method, options = {})
-      @template.render("decidim/shared/filters/dropdown_label", **options.merge(item:, method:, form: self))
+      @template.render("decidim/shared/filters/dropdown_label", **options, item:, method:, form: self)
     end
 
     private
 
-    def check_boxes_tree_id(method)
-      method
+    def check_boxes_tree_id(*args)
+      args.map(&:to_s).join("_")
     end
 
     def default_form_type_for_collection(collection)

data/lib/decidim/form_builder.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require "foundation_rails_helper/form_builder"
-
 module Decidim
   # This custom FormBuilder adds fields needed to deal with translatable fields,
   # following the conventions set on `Decidim::TranslatableAttributes`.
-  class FormBuilder < FoundationRailsHelper::FormBuilder
+  class FormBuilder < LegacyFormBuilder
     include ActionView::Context
     include Decidim::TranslatableAttributes
     include Decidim::Map::Autocomplete::FormBuilder
@@ -62,7 +60,7 @@ module Decidim
     #
     # Renders form fields for each locale.
     def translated(type, name, options = {})
-      return translated_one_locale(type, name, locales.first, options.merge(label: (options[:label] || label_for(name)))) if locales.count == 1
+      return translated_one_locale(type, name, locales.first, options.merge(label: options[:label] || label_for(name))) if locales.count == 1
 
       tabs_id = sanitize_tabs_selector(options[:tabs_id] || "#{object_name}-#{name}-tabs")
 
@@ -98,7 +96,7 @@ module Decidim
       field attribute, options do |opts|
         opts[:autocomplete] ||= :off
         opts[:class] ||= "input-group-field"
-        method(__method__).super_method.super_method.call(attribute, opts)
+        super(attribute, opts)
       end
     end
 
@@ -225,35 +223,6 @@ module Decidim
       end
     end
 
-    # Public: Generates a select field with the categories. Only leaf categories can be set as selected.
-    #
-    # name       - The name of the field (usually category_id)
-    # collection - A collection of categories.
-    # options    - An optional Hash with options:
-    # - prompt   - An optional String with the text to display as prompt.
-    # - disable_parents - A Boolean to disable parent categories. Defaults to `true`.
-    # html_options - HTML options for the select
-    #
-    # Returns a String.
-    def categories_select(name, collection, options = {}, html_options = {})
-      options = {
-        disable_parents: true
-      }.merge(options)
-
-      disable_parents = options[:disable_parents]
-
-      selected = object.send(name)
-      selected = selected.first if selected.is_a?(Array) && selected.length > 1
-      categories = categories_for_select(collection)
-      disabled = if disable_parents
-                   disabled_categories_for(collection)
-                 else
-                   []
-                 end
-
-      select(name, @template.options_for_select(categories, selected:, disabled:), options, html_options)
-    end
-
     # Public: Generates a select field for areas.
     #
     # name       - The name of the field (usually area_id)
@@ -301,46 +270,6 @@ module Decidim
       select(name, @template.options_for_select(resources, selected: options[:selected]), options)
     end
 
-    # Public: Generates a picker field for scope selection.
-    #
-    # attribute     - The name of the field (usually scope_id)
-    # options       - An optional Hash with options:
-    # - multiple    - Multiple mode, to allow multiple scopes selection.
-    # - label       - Show label?
-    # - checkboxes_on_top - Show checked picker values on top (default) or below the picker prompt (only for multiple pickers)
-    # - namespace   - prepend a custom name to the html element's DOM id.
-    #
-    # Also it should receive a block that returns a Hash with :url and :text for each selected scope (and for null scope for prompt)
-    #
-    # Returns a String.
-    def scopes_picker(attribute, options = {})
-      id = if self.options.has_key?(:namespace)
-             "#{self.options[:namespace]}_#{sanitize_for_dom_selector(@object_name)}"
-           else
-             "#{sanitize_for_dom_selector(@object_name)}_#{attribute}"
-           end
-
-      picker_options = {
-        id:,
-        class: "picker-#{options[:multiple] ? "multiple" : "single"}",
-        name: "#{@object_name}[#{attribute}]"
-      }
-
-      picker_options[:class] += " is-invalid-input" if error?(attribute)
-
-      prompt_params = yield(nil)
-      scopes = selected_scopes(attribute).map { |scope| [scope, yield(scope)] }
-      template = ""
-      template += "<label>#{label_for(attribute) + required_for_attribute(attribute)}</label>" unless options[:label] == false
-      template += @template.render("decidim/scopes/scopes_picker_input",
-                                   picker_options:,
-                                   prompt_params:,
-                                   scopes:,
-                                   values_on_top: !options[:multiple] || options[:checkboxes_on_top])
-      template += error_and_help_text(attribute, options)
-      template.html_safe
-    end
-
     # Public: Generates a picker field for selection (either simple or multiselect).
     #
     # attribute     - The name of the object's attribute.
@@ -378,7 +307,7 @@ module Decidim
       custom_label(attribute, options[:label], options[:label_options], field_before_label: true) do
         options.delete(:label)
         options.delete(:label_options)
-        @template.check_box(@object_name, attribute, objectify_options(options.except(:help_text)), checked_value, unchecked_value)
+        super(attribute, options.except(:help_text), checked_value, unchecked_value)
       end + error_and_help_text(attribute, options)
     end
 
@@ -563,8 +492,6 @@ module Decidim
       end
 
       help_text = options.delete(:help_text)
-      prefix = options.delete(:prefix)
-      postfix = options.delete(:postfix)
 
       class_options = extract_validations(attribute, options).merge(class_options)
 
@@ -573,7 +500,7 @@ module Decidim
       content = content.html_safe
 
       html = error_and_help_text(attribute, options.merge(help_text:))
-      html + wrap_prefix_and_postfix(content, prefix, postfix)
+      html + content
     end
 
     # rubocop: disable Metrics/CyclomaticComplexity
@@ -716,30 +643,6 @@ module Decidim
       content_tag(:span, text, class: "form-error")
     end
 
-    def categories_for_select(scope)
-      sorted_main_categories = scope.first_class.includes(:subcategories).sort_by do |category|
-        [category.weight, translated_attribute(category.name, category.participatory_space.organization)]
-      end
-
-      sorted_main_categories.flat_map do |category|
-        parent = [[translated_attribute(category.name, category.participatory_space.organization), category.id]]
-
-        sorted_subcategories = category.subcategories.sort_by do |subcategory|
-          [subcategory.weight, translated_attribute(subcategory.name, subcategory.participatory_space.organization)]
-        end
-
-        sorted_subcategories.each do |subcategory|
-          parent << ["- #{translated_attribute(subcategory.name, subcategory.participatory_space.organization)}", subcategory.id]
-        end
-
-        parent
-      end
-    end
-
-    def disabled_categories_for(scope)
-      scope.first_class.joins(:subcategories).pluck(:id)
-    end
-
     def tab_element_class_for(type, index)
       element_class = "tabs-#{type}"
       element_class += " is-active" if index.zero?
@@ -803,15 +706,6 @@ module Decidim
       ).html_safe
     end
 
-    # Private: Returns an array of scopes related to object attribute
-    def selected_scopes(attribute)
-      selected = object.send(attribute) || []
-      selected = selected.values if selected.is_a?(Hash)
-      selected = [selected] unless selected.is_a?(Array)
-      selected = Decidim::Scope.where(id: selected.map(&:to_i)) unless selected.first.is_a?(Decidim::Scope)
-      selected
-    end
-
     # Private: Returns the help text and error tags at the end of the field.
     # Modified to change the tag to a valid HTML tag inside the <label> element.
     def error_and_help_text(attribute, options = {})
@@ -870,24 +764,7 @@ module Decidim
 
       content_tag(:span,
                   content_tag(:span, options[:value], class: name),
-                  class: column_classes(options).to_s)
-    end
-
-    # Private: Wraps the prefix and postfix for the field. Overridden from
-    # FoundationRailsHelper to make the generated HTML valid since these
-    # elements are printed within <label> elements and <div>'s are not allowed
-    # there.
-    def wrap_prefix_and_postfix(block, prefix_options, postfix_options)
-      prefix = tag_from_options("prefix", prefix_options)
-      postfix = tag_from_options("postfix", postfix_options)
-
-      input_size = calculate_input_size(prefix_options, postfix_options)
-      klass = column_classes(input_size.marshal_dump).to_s
-      input = content_tag(:span, block, class: klass)
-
-      return block unless input_size.changed?
-
-      content_tag(:span, prefix + input + postfix, class: "row collapse")
+                  class: "columns")
     end
 
     def language_selector_select(locales, tabs_id, name)

data/lib/decidim/has_category.rb

@@ -60,7 +60,11 @@ module Decidim
       def category_belongs_to_organization
         return unless category
 
-        errors.add(:category, :invalid) unless component.categories.exists?(id: category.id)
+        errors.add(:category, :invalid) unless component_categories.exists?(id: category.id)
+      end
+
+      def component_categories
+        Decidim::Category.where(participatory_space: component.participatory_space)
       end
     end
   end

data/lib/decidim/has_private_users.rb

@@ -33,6 +33,10 @@ module Decidim
         end
       end
 
+      def members_public_page?
+        private_space && participatory_space_private_users.published.any?
+      end
+
       def can_participate?(user)
         return true unless private_space?
         return false unless user

data/lib/decidim/has_taxonomy_settings.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module HasTaxonomySettings
+    extend ActiveSupport::Concern
+
+    included do
+      after_save :update_components_counter_cache
+      after_destroy :update_components_counter_cache
+
+      def has_taxonomy_settings?
+        settings.respond_to?(:taxonomy_filters)
+      end
+
+      def available_taxonomy_filters
+        return Decidim::TaxonomyFilter.none unless has_taxonomy_settings?
+
+        @available_taxonomy_filters ||= Decidim::TaxonomyFilter.for(organization).where(id: settings.taxonomy_filters)
+      end
+
+      def available_root_taxonomies
+        return Decidim::Taxonomy.none unless has_taxonomy_settings?
+
+        @available_root_taxonomies ||= organization.taxonomies.roots.where(id: available_taxonomy_filters.map(&:root_taxonomy_id))
+      end
+
+      def available_taxonomy_ids
+        return [] unless has_taxonomy_settings?
+
+        @available_taxonomy_ids ||= Decidim::TaxonomyFilterItem.where(
+          taxonomy_filter_id: available_taxonomy_filters.where(id: settings.taxonomy_filters).pluck(:id)
+        ).pluck(:taxonomy_item_id)
+      end
+
+      def update_components_counter_cache
+        return unless has_taxonomy_settings?
+
+        current_filters = attribute("settings")&.dig("global", "taxonomy_filters") || []
+        previous_filters = attribute_previously_was("settings")&.dig("global", "taxonomy_filters") || []
+
+        Decidim::TaxonomyFilter.for(organization).where(id: (current_filters + previous_filters)).each(&:update_components_count)
+      end
+    end
+  end
+end

data/lib/decidim/has_upload_validations.rb

@@ -25,7 +25,7 @@ module Decidim
       def validates_avatar(attribute = :avatar, options = {})
         validates_upload(
           attribute,
-          **options.merge(max_size: ->(record) { record.maximum_avatar_size })
+          **options, max_size: ->(record) { record.maximum_avatar_size }
         )
       end
 

data/lib/decidim/legacy_form_builder.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2015 Sébastien Gruhier (http://xilinus.com/) - MIT LICENSE
+#
+# This file has been copied and modified from https://github.com/sgruhier/foundation_rails_helper/blob/master/lib/foundation_rails_helper/form_builder.rb
+# We have done this so we can decouple Decidim from this dependency, which is not updated to Rails 7.1
+# We also plan to fully remove Foundation CSS legacy code in the future
+
+module Decidim
+  class LegacyFormBuilder < ActionView::Helpers::FormBuilder
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::OutputSafetyHelper
+    %w(file_field email_field text_field text_area url_field
+       number_field date_field datetime_field search_field color_field)
+      .each do |method_name|
+      define_method(method_name) do |*args|
+        attribute = args[0]
+        options = args[1] || {}
+        field(attribute, options) do |opts|
+          super(attribute, opts)
+        end
+      end
+    end
+
+    def label(attribute, text = nil, options = {})
+      if error?(attribute)
+        options[:class] ||= ""
+        options[:class] += " is-invalid-label"
+      end
+
+      super(attribute, (text || "").html_safe, options)
+    end
+
+    def radio_button(attribute, tag_value, options = {})
+      options[:label_options] ||= {}
+      label_options = options.delete(:label_options)&.merge!(value: tag_value)
+      label_text = options.delete(:label)
+      l = label(attribute, label_text, label_options) unless label_text == false
+      r = @template.radio_button(@object_name, attribute, tag_value,
+                                 objectify_options(options))
+
+      "#{r}#{l}".html_safe
+    end
+
+    def datetime_select(attribute, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        super(attribute, options, html_opts.merge(autocomplete: :off))
+      end
+    end
+
+    def date_select(attribute, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        super(attribute, options, html_opts.merge(autocomplete: :off))
+      end
+    end
+
+    def time_zone_select(attribute, priorities = nil, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        super(attribute, priorities, options,
+              html_opts.merge(autocomplete: :off))
+      end
+    end
+
+    def select(attribute, choices, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        html_options[:autocomplete] ||= :off
+        super(attribute, choices, options, html_opts)
+      end
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+    def collection_select(attribute, collection, value_method, text_method, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        html_options[:autocomplete] ||= :off
+        super(attribute, collection, value_method, text_method, options,
+              html_opts)
+      end
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def autocomplete(attribute, url, options = {})
+      field attribute, options do |opts|
+        opts.merge!(update_elements: opts[:update_elements],
+                    min_length: 0, value: object.send(attribute))
+        autocomplete_field(attribute, url, opts)
+      end
+    end
+
+    def submit(value = nil, options = {})
+      options[:class] ||= "button"
+      super
+    end
+
+    def error_for(attribute, options = {})
+      return unless error?(attribute)
+
+      class_name = "form-error is-visible"
+      class_name += " #{options[:class]}" if options[:class]
+
+      error_messages = object.errors[attribute].join(", ")
+      error_messages = error_messages.html_safe if options[:html_safe_errors]
+      content_tag(:small, error_messages,
+                  class: class_name.sub("is-invalid-input", ""))
+    end
+
+    private
+
+    def error?(attribute)
+      object.respond_to?(:errors) && object.errors[attribute].present?
+    end
+
+    def default_label_text(object, attribute)
+      return object.class.human_attribute_name(attribute) if object.class.respond_to?(:human_attribute_name)
+
+      attribute.to_s.humanize
+    end
+  end
+end