decidim-core 0.19.1 → 0.23.0

data/app/helpers/decidim/omniauth_helper.rb

@@ -3,18 +3,6 @@
 module Decidim
   # Helper that provides methods to enable or disable omniauth buttons
   module OmniauthHelper
-    # Public: returns true if the social provider is enabled
-    def social_provider_enabled?(provider)
-      Rails.application.secrets.dig(:omniauth, provider.to_sym, :enabled)
-    end
-
-    # Public: returns true if any provider is enabled
-    def any_social_provider_enabled?
-      User.omniauth_providers.any? do |provider|
-        social_provider_enabled? provider
-      end
-    end
-
     # Public: normalize providers names to they can be used for buttons
     # and icons.
     def normalize_provider_name(provider)
@@ -23,7 +11,7 @@ module Decidim
 
     # Public: icon for omniauth buttons
     def oauth_icon(provider)
-      info = Rails.application.secrets.dig(:omniauth, provider.to_sym)
+      info = current_organization.enabled_omniauth_providers[provider.to_sym]
 
       if info
         icon_path = info[:icon_path]
@@ -35,5 +23,10 @@ module Decidim
       name ||= normalize_provider_name(provider)
       icon(name)
     end
+
+    # Public: pretty print provider name
+    def provider_name(provider)
+      provider.to_s.gsub(/_|-/, " ").camelize
+    end
   end
 end

data/app/helpers/decidim/orders_helper.rb

@@ -23,7 +23,21 @@ module Decidim
     # options - An optional hash of options
     #         * i18n_scope - The scope of the i18n translations
     def order_link(order, options = {})
-      link_to t("#{options[:i18n_scope]}.#{order}"), url_for(params.to_unsafe_h.merge(page: nil, order: order)), data: { order: order }, remote: true
+      i18n_scope = options.delete(:i18n_scope)
+
+      link_to(
+        t("#{i18n_scope}.#{order}"),
+        url_for(params.to_unsafe_h.except(
+          "component_id",
+          "participatory_process_slug",
+          "assembly_slug",
+          "initiative_slug"
+        ).merge(page: nil, order: order)),
+        {
+          data: { order: order },
+          remote: true
+        }.merge(options)
+      )
     end
   end
 end

data/app/helpers/decidim/paginate_helper.rb

@@ -12,7 +12,9 @@ module Decidim
       # Kaminari uses url_for to generate the url, but this doesn't play nice with our engine system
       # and unless we remove these params they are added again as query string :(
       default_params = {
-        participatory_process_id: nil,
+        participatory_process_slug: nil,
+        assembly_slug: nil,
+        initiative_slug: nil,
         component_id: nil
       }
 

data/app/helpers/decidim/participatory_space_helpers.rb

@@ -36,7 +36,7 @@ module Decidim
     end
 
     def participatory_space_wrapper(&block)
-      content_tag :main, class: "wrapper" do
+      content_tag :div, class: "wrapper" do
         concat(participatory_space_floating_help)
         concat(capture(&block))
       end

data/app/helpers/decidim/resource_versions_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helper to print resource versions.
+  module ResourceVersionsHelper
+    include ResourceHelper
+
+    # Displays the localized version for the given resource.
+    #
+    # resource - the Resource that has the version to display.
+    # options - An optional hash of options
+    #         * class: A string of extra css classes
+    #
+    # Returns a String.
+    def resource_version(resource, options = {})
+      return unless resource.respond_to?(:versions) && resource.versions.present?
+
+      html = []
+      html << resource_version_number(resource.versions_count)
+      html << " "
+      html << resource_version_of(resource.versions_count)
+      html << " "
+      html << link_to_other_resource_versions(options[:versions_path]) if options[:versions_path]
+
+      content_tag(:div, safe_join(html), class: "tech-info #{options[:class]}")
+    end
+
+    def resource_version_number(count, css_class = "")
+      content_tag(:strong, t("version", scope: "decidim.versions.resource_version", number: count), class: css_class)
+    end
+
+    def resource_version_of(count)
+      t("of_versions", scope: "decidim.versions.resource_version", number: count)
+    end
+
+    def link_to_other_resource_versions(versions_path)
+      link_to(
+        t(
+          "see_other_versions",
+          scope: "decidim.versions.resource_version"
+        ),
+        versions_path
+      )
+    end
+  end
+end

data/app/helpers/decidim/rich_text_editor_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helper related to organization' setting :rich_text_editor_in_public_views.
+  module RichTextEditorHelper
+    def self.included(base)
+      base.include Decidim::SanitizeHelper
+    end
+
+    delegate :rich_text_editor_in_public_views?, to: :current_organization
+
+    def text_editor_for(form, attribute, options = {})
+      if rich_text_editor_in_public_views?
+        options[:lines] ||= 25
+        form.editor attribute, options
+      else
+        options.delete(:hashtaggable)
+        options[:rows] ||= 10
+        form.text_area attribute, options
+      end
+    end
+  end
+end

data/app/helpers/decidim/sanitize_helper.rb

@@ -3,7 +3,9 @@
 module Decidim
   # Helper that provides methods to render order selector and links
   module SanitizeHelper
-    include ActionView::Helpers::SanitizeHelper
+    def self.included(base)
+      base.include ActionView::Helpers::SanitizeHelper
+    end
 
     # Public: It sanitizes a user-inputted string with the
     # `Decidim::UserInputScrubber` scrubber, so that video embeds work
@@ -12,12 +14,20 @@ module Decidim
     # html - A string representing user-inputted HTML.
     #
     # Returns an HTML-safe String.
-    def decidim_sanitize(html)
-      sanitize(html, scrubber: Decidim::UserInputScrubber.new)
+    def decidim_sanitize(html, options = {})
+      if options[:strip_tags]
+        strip_tags sanitize(html, scrubber: Decidim::UserInputScrubber.new)
+      else
+        sanitize(html, scrubber: Decidim::UserInputScrubber.new)
+      end
     end
 
     def decidim_html_escape(text)
       ERB::Util.unwrapped_html_escape(text.to_str)
     end
+
+    def decidim_url_escape(text)
+      decidim_html_escape(text).sub(/^javascript:/, "")
+    end
   end
 end

data/app/helpers/decidim/scopes_helper.rb

@@ -13,9 +13,9 @@ module Decidim
     #
     # Returns boolean.
     def has_visible_scopes?(resource)
-      resource.participatory_space.scopes_enabled? &&
+      resource.component.scopes_enabled? &&
         resource.scope.present? &&
-        resource.participatory_space.scope != resource.scope
+        resource.component.scope != resource.scope
     end
 
     # Retrieves the translated name and type for an scope.
@@ -35,7 +35,7 @@ module Decidim
     # form - FormBuilder object
     # name - attribute name
     # options       - An optional Hash with options:
-    # - checkboxes_on_top - Show checked picker values on top (default) or below the picker prompt
+    # - checkboxes_on_top - Show checked picker values on top (default) or below the picker prompt (only for multiple pickers)
     #
     # Returns nothing.
     def scopes_picker_field(form, name, root: false, options: { checkboxes_on_top: true })
@@ -64,7 +64,7 @@ module Decidim
     # Renders a scopes picker field in a filter form.
     # form - FilterFormBuilder object
     # name - attribute name
-    # checkboxes_on_top - Show picker values on top (default) or below the picker prompt
+    # checkboxes_on_top - Show picker values on top (default) or below the picker prompt (only for multiple pickers)
     #
     # Returns nothing.
     def scopes_picker_filter(form, name, checkboxes_on_top = true)
@@ -78,10 +78,11 @@ module Decidim
       form.scopes_picker name, options do |scope|
         {
           url: decidim.scopes_picker_path(
-            root: try(:current_participatory_space)&.scope,
+            root: try(:current_participatory_space).try(:scope),
             current: scope&.id,
             title: I18n.t("decidim.scopes.prompt"),
-            global_value: "global"
+            global_value: "global",
+            max_depth: try(:current_participatory_space).try(:scope_type_max_depth)
           ),
           text: scope_name_for_picker(scope, I18n.t("decidim.scopes.prompt"))
         }

data/app/helpers/decidim/tooltip_helper.rb

@@ -5,7 +5,7 @@ module Decidim
   # on the layout.
   module TooltipHelper
     def with_tooltip(title, &block)
-      content_tag(:span, data: { tooltip: true, disable_hover: false, click_open: false },
+      content_tag(:span, data: { tooltip: true, disable_hover: false, keep_on_hover: true, click_open: false },
                          title: title, &block)
     end
   end

data/app/helpers/decidim/traceability_helper.rb

@@ -11,10 +11,7 @@ module Decidim
     #
     # Returns an HTML-safe String representing the HTML to render the author.
     def render_resource_last_editor(resource)
-      render partial: "decidim/shared/version_author",
-             locals: {
-               author: Decidim.traceability.last_editor(resource)
-             }
+      cell "decidim/version_author", Decidim.traceability.last_editor(resource)
     end
 
     # Renders the avatar and author name of the author of the given version.
@@ -23,10 +20,7 @@ module Decidim
     #
     # Returns an HTML-safe String representing the HTML to render the author.
     def render_resource_editor(version)
-      render partial: "decidim/shared/version_author",
-             locals: {
-               author: Decidim.traceability.version_editor(version)
-             }
+      cell "decidim/version_author", Decidim.traceability.version_editor(version)
     end
   end
 end

data/app/helpers/decidim/translations_helper.rb

@@ -54,6 +54,12 @@ module Decidim
       end
     end
 
-    module_function :multi_translation, :empty_translatable, :ensure_translatable
+    def translated_in_current_locale?(attribute)
+      return false if attribute.nil?
+
+      attribute[I18n.locale.to_s].present?
+    end
+
+    module_function :multi_translation, :empty_translatable, :ensure_translatable, :translated_in_current_locale?
   end
 end

data/app/helpers/decidim/user_profile_helper.rb

@@ -17,7 +17,7 @@ module Decidim
       active = is_active_link?(link, (options[:aria_link_type] || :inclusive))
 
       content_tag(:li, class: "tabs-title#{active ? " is-active" : nil}") do
-        aria_selected_link_to(text, link, options)
+        link_to(text, link, options)
       end
     end
   end

data/app/helpers/decidim/widget_urls_helper.rb

@@ -2,10 +2,12 @@
 
 module Decidim
   module WidgetUrlsHelper
-    def embed_modal_for(url)
+    def embed_modal_for(url, options = {})
+      extra_locals = options[:locals] || {}
+
       js_embed_code = String.new(content_tag(:script, "", src: url))
       embed_code = String.new(content_tag(:noscript, content_tag(:iframe, "", src: url.gsub(".js", ".html"), frameborder: 0, scrolling: "vertical")))
-      render partial: "decidim/shared/embed_modal", locals: { js_embed_code: js_embed_code, embed_code: embed_code }
+      render partial: "decidim/shared/embed_modal", locals: { js_embed_code: js_embed_code, embed_code: embed_code }.merge(extra_locals)
     end
   end
 end

data/app/jobs/decidim/data_portability_export_job.rb

@@ -4,18 +4,26 @@ module Decidim
   class DataPortabilityExportJob < ApplicationJob
     queue_as :default
 
-    def perform(user, format)
-      objects = Decidim::DataPortabilitySerializers.data_entities
-      export_data = []
-      export_images = []
+    def perform(user, export_format = ::Decidim::DataPortabilityExporter::DEFAULT_EXPORT_FORMAT)
+      filename = "#{SecureRandom.urlsafe_base64}.zip"
+      path = Rails.root.join("tmp/#{filename}")
+      password = SecureRandom.urlsafe_base64
 
-      objects.each do |object|
-        klass = Object.const_get(object)
-        export_data << [klass.model_name.name.parameterize.pluralize, Decidim::Exporters.find_exporter(format).new(klass.user_collection(user), klass.export_serializer).export]
-        export_images << [klass.model_name.name.parameterize.pluralize, klass.data_portability_images(user).flatten] unless klass.data_portability_images(user).nil?
-      end
+      generate_zip_file(user, path, password, export_format)
+      save_or_upload_file(path)
 
-      ExportMailer.data_portability_export(user, export_data, export_images).deliver_now
+      ExportMailer.data_portability_export(user, filename, password).deliver_later
+    end
+
+    private
+
+    def generate_zip_file(user, path, password, export_format)
+      DataPortabilityExporter.new(user, path, password, export_format).export
+    end
+
+    # Saves to file system or uploads to storage service depending on the configuration.
+    def save_or_upload_file(path)
+      DataPortabilityUploader.new.store!(File.open(path, "rb"))
     end
   end
 end

data/app/jobs/decidim/event_publisher_job.rb

@@ -9,7 +9,7 @@ module Decidim
     def perform(event_name, data)
       @resource = data[:resource]
 
-      return unless notifiable?
+      return unless data[:force_send] || notifiable?
 
       EmailNotificationGeneratorJob.perform_later(
         event_name,

data/app/jobs/decidim/export_job.rb

@@ -9,7 +9,7 @@ module Decidim
         manifest.name == name.to_sym
       end
 
-      collection = export_manifest.collection.call(component)
+      collection = export_manifest.collection.call(component, user)
       serializer = export_manifest.serializer
 
       export_data = Decidim::Exporters.find_exporter(format).new(collection, serializer).export

data/app/jobs/decidim/export_participatory_space_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  class ExportParticipatorySpaceJob < ApplicationJob
+    queue_as :default
+
+    def perform(user, participatory_space, name, format)
+      export_manifest = participatory_space.manifest.export_manifests.find do |manifest|
+        manifest.name == name.to_sym
+      end
+
+      collection = export_manifest.collection.call(participatory_space)
+      serializer = export_manifest.serializer
+
+      export_data = Decidim::Exporters.find_exporter(format).new(collection, serializer).export
+
+      Decidim::ExportMailer.export(user, name, export_data).deliver_now
+    end
+  end
+end

data/app/jobs/decidim/machine_translation_fields_job.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This job is part of the machine translation flow. This one specifically
+  # delegates the arguments to the translation service, if any.
+  class MachineTranslationFieldsJob < ApplicationJob
+    queue_as :default
+
+    # Performs the job. It won't perform anything if the
+    # `Decidim.machine_translation_service` config is not set.
+    #
+    # resource - Any kind of `Decidim::TranslatableResource` model instance
+    # field_name - A Symbol representing the name of the field being translated
+    # field_value - A String with the value of the field to translate
+    # target_locale - A Symbol representing the target locale for the translation
+    # source_locale - A Symbol representing the source locale for the translation
+    def perform(resource, field_name, field_value, target_locale, source_locale)
+      klass = Decidim.machine_translation_service_klass
+      return unless klass
+
+      klass.new(
+        resource,
+        field_name,
+        field_value,
+        target_locale,
+        source_locale
+      ).translate
+    end
+  end
+end

data/app/jobs/decidim/machine_translation_resource_job.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This job is part of the machine translation flow. This one is fired every
+  # time a `Decidim::TranslatableResource` is created or updated. If any of the
+  # attributes defines as translatable is modified, then for each of those
+  # attributes this job will schedule a `Decidim::MachineTranslationFieldsJob`.
+  class MachineTranslationResourceJob < ApplicationJob
+    queue_as :default
+
+    # Performs the job.
+    #
+    # resource - Any kind of `Decidim::TranslatableResource` model instance
+    # previous_changes - A Hash with the set fo changes. This is intended to be
+    #   taken from `resource.previous_changes`, but we need to manually pass
+    #   them to the job because the value gets lost when serializing the
+    #   resource.
+    # source_locale - A Symbol representing the source locale for the translation
+    def perform(resource, previous_changes, source_locale)
+      return unless Decidim.machine_translation_service_klass
+
+      @resource = resource
+      @locales_to_be_translated = []
+      translatable_fields = @resource.class.translatable_fields_list.map(&:to_s)
+      translatable_fields.each do |field|
+        next unless @resource[field].is_a?(Hash) && previous_changes.keys.include?(field)
+
+        translated_locales = translated_locales_list(field)
+        remove_duplicate_translations(field, translated_locales) if @resource[field]["machine_translations"].present?
+
+        next unless default_locale_changed_or_translation_removed(previous_changes, field)
+
+        @locales_to_be_translated += pending_locales(translated_locales) if @locales_to_be_translated.blank?
+
+        @locales_to_be_translated.each do |target_locale|
+          MachineTranslationFieldsJob.perform_later(
+            resource,
+            field,
+            resource_field_value(
+              previous_changes,
+              field
+            ),
+            target_locale,
+            source_locale
+          )
+        end
+      end
+    end
+
+    def default_locale_changed_or_translation_removed(previous_changes, field)
+      default_locale = default_locale(@resource)
+      values = previous_changes[field]
+      old_value = values.first
+      new_value = values.last
+      return true unless old_value.is_a?(Hash)
+
+      return true if old_value[default_locale] != new_value[default_locale]
+
+      # In a case where the default locale isn't changed
+      # but a translation of a different locale is deleted
+      # We trigger a job to translate only for that locale
+      if old_value[default_locale] == new_value[default_locale]
+        locales_present = old_value.keys
+        locales_present.each do |locale|
+          @locales_to_be_translated << locale if old_value[locale] != new_value[locale] && new_value[locale] == ""
+        end
+      end
+
+      @locales_to_be_translated.present?
+    end
+
+    def resource_field_value(previous_changes, field)
+      values = previous_changes[field]
+      new_value = values.last
+      return new_value[default_locale(@resource)] if new_value.is_a?(Hash)
+
+      new_value
+    end
+
+    def default_locale(resource)
+      if resource.respond_to? :organization
+        resource.organization.default_locale.to_s
+      else
+        Decidim.available_locales.first.to_s
+      end
+    end
+
+    def translated_locales_list(field)
+      return nil unless @resource[field].is_a? Hash
+
+      translated_locales = []
+      existing_locales = @resource[field].keys - ["machine_translations"]
+      existing_locales.each do |locale|
+        translated_locales << locale if @resource[field][locale].present?
+      end
+
+      translated_locales
+    end
+
+    def remove_duplicate_translations(field, translated_locales)
+      machine_translated_locale = @resource[field]["machine_translations"].keys
+      unless (translated_locales & machine_translated_locale).nil?
+        (translated_locales & machine_translated_locale).each { |key| @resource[field]["machine_translations"].delete key }
+      end
+    end
+
+    def pending_locales(translated_locales)
+      available_locales = @resource.organization.available_locales.map(&:to_s) if @resource.respond_to? :organization
+      available_locales ||= Decidim.available_locales.map(&:to_s)
+      available_locales - translated_locales
+    end
+  end
+end